@teamscale/javascript-instrumenter 0.0.1-beta.5 → 0.0.1-beta.51

package/dist/src/instrumenter/Instrumenter.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -18,14 +22,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IstanbulInstrumenter = exports.IS_INSTRUMENTED_TOKEN = void 0;
+exports.sourceMapFromMapFile = exports.sourceMapFromCodeComment = exports.loadInputSourceMap = exports.loadSourceMap = exports.IstanbulInstrumenter = exports.IS_INSTRUMENTED_TOKEN = void 0;
 const Task_1 = require("./Task");
 const commons_1 = require("@cqse/commons");
+const source_map_1 = require("source-map");
 const istanbul = __importStar(require("istanbul-lib-instrument"));
 const fs = __importStar(require("fs"));
+const mkdirp = __importStar(require("mkdirp"));
 const path = __importStar(require("path"));
 const convertSourceMap = __importStar(require("convert-source-map"));
+const Postprocessor_1 = require("./Postprocessor");
+const typescript_optional_1 = require("typescript-optional");
+const async_1 = __importDefault(require("async"));
 exports.IS_INSTRUMENTED_TOKEN = '/** $IS_JS_PROFILER_INSTRUMENTED=true **/';
 /**
  * An instrumenter based on the IstanbulJs instrumentation and coverage framework.
@@ -39,14 +51,19 @@ class IstanbulInstrumenter {
     /**
      * {@inheritDoc #IInstrumenter.instrument}
      */
-    instrument(task) {
-        fs.existsSync(this.vaccineFilePath);
-        // ATTENTION: Here is potential for parallelization. Maybe we can
-        // run several instrumentation workers in parallel?
-        const result = task.elements
-            .map(e => this.instrumentOne(task.collector, e, task.originSourcePattern))
-            .reduce((prev, current) => current.withIncrement(prev), Task_1.TaskResult.neutral());
-        return Promise.resolve(result);
+    async instrument(task) {
+        this.clearDumpOriginsFileIfNeeded(task.dumpOriginsFile);
+        // We limit the number of instrumentations in parallel to one to
+        // not overuse memory (NodeJS has only limited mem to use).
+        return async_1.default
+            .mapLimit(task.elements, 1, async (taskElement) => {
+            return await this.instrumentOne(task.collector, taskElement, task.excludeFilesPattern, task.originSourcePattern, task.dumpOriginsFile);
+        })
+            .then(results => {
+            return results.reduce((prev, curr) => {
+                return prev.withIncrement(curr);
+            }, Task_1.TaskResult.neutral());
+        });
     }
     /**
      * Perform the instrumentation for one given task element (file to instrument).
@@ -54,20 +71,28 @@ class IstanbulInstrumenter {
      * @param collector - The collector to send the coverage information to.
      * @param taskElement - The task element to perform the instrumentation for.
      * @param sourcePattern - A pattern to restrict the instrumentation to only a fraction of the task element.
+     * @param dumpOriginsFile - A file path where all origins from the source map should be dumped in json format, or undefined if no origins should be dumped
      */
-    instrumentOne(collector, taskElement, sourcePattern) {
-        var _a, _b, _c;
+    async instrumentOne(collector, taskElement, excludeBundles, sourcePattern, dumpOriginsFile) {
+        var _a, _b;
         const inputFileSource = fs.readFileSync(taskElement.fromFile, 'utf8');
         // We skip files that we have already instrumented
         if (inputFileSource.startsWith(exports.IS_INSTRUMENTED_TOKEN)) {
             if (!taskElement.isInPlace()) {
-                fs.writeFileSync(taskElement.toFile, inputFileSource);
+                writeToFile(taskElement.toFile, inputFileSource);
             }
-            return new Task_1.TaskResult(0, 0, 1, 0, 0, 0);
+            return new Task_1.TaskResult(0, 0, 0, 1, 0, 0, 0);
         }
         // Not all file types are supported by the instrumenter
         if (!this.isFileTypeSupported(taskElement.fromFile)) {
-            return new Task_1.TaskResult(0, 0, 0, 1, 0, 0);
+            return new Task_1.TaskResult(0, 0, 0, 0, 1, 0, 0);
+        }
+        // We might want to skip the instrumentation of the file
+        if (excludeBundles.isExcluded(taskElement.fromFile)) {
+            if (!taskElement.isInPlace()) {
+                writeToFile(taskElement.toFile, inputFileSource);
+            }
+            return new Task_1.TaskResult(0, 1, 0, 0, 0, 0, 0);
         }
         // Report progress
         this.logger.info(`Instrumenting "${path.basename(taskElement.fromFile)}"`);
@@ -77,29 +102,37 @@ class IstanbulInstrumenter {
         // alternative configurations of the instrumenter.
         const configurationAlternatives = this.configurationAlternativesFor(taskElement);
         for (let i = 0; i < configurationAlternatives.length; i++) {
+            const configurationAlternative = configurationAlternatives[i];
             let inputSourceMap;
             try {
-                const instrumenter = istanbul.createInstrumenter(configurationAlternatives[i]);
-                inputSourceMap = this.loadInputSourceMap(inputFileSource, taskElement);
+                const instrumenter = istanbul.createInstrumenter(configurationAlternative);
+                inputSourceMap = loadInputSourceMap(inputFileSource, taskElement.fromFile, taskElement.externalSourceMapFile);
                 // Based on the source maps of the file to instrument, we can now
                 // decide if we should NOT write an instrumented version of it
                 // and use the original code instead and write it to the target path.
                 //
-                if (this.shouldExcludeFromInstrumentation(sourcePattern, taskElement.fromFile, (_b = (_a = instrumenter.lastSourceMap()) === null || _a === void 0 ? void 0 : _a.sources) !== null && _b !== void 0 ? _b : [])) {
-                    fs.writeFileSync(taskElement.toFile, inputFileSource);
-                    return new Task_1.TaskResult(1, 0, 0, 0, 0, 0);
+                const originSourceFiles = (_a = inputSourceMap === null || inputSourceMap === void 0 ? void 0 : inputSourceMap.sources) !== null && _a !== void 0 ? _a : [];
+                if (dumpOriginsFile) {
+                    this.dumpOrigins(dumpOriginsFile, originSourceFiles);
                 }
                 // The main instrumentation (adding coverage statements) is performed now:
-                instrumentedSource = instrumenter
-                    .instrumentSync(inputFileSource, taskElement.fromFile, inputSourceMap)
-                    .replace(/return actualCoverage/g, 'return makeCoverageInterceptor(actualCoverage)')
+                instrumentedSource = instrumenter.instrumentSync(inputFileSource, taskElement.fromFile, inputSourceMap);
+                this.logger.debug('Instrumentation source maps to:', (_b = instrumenter.lastSourceMap()) === null || _b === void 0 ? void 0 : _b.sources);
+                // In case of a bundle, the initial instrumentation step might have added
+                // too much and undesired instrumentations. Remove them now.
+                const instrumentedSourcemap = instrumenter.lastSourceMap();
+                let instrumentedAndCleanedSource = await this.removeUnwantedInstrumentation(taskElement, instrumentedSource, configurationAlternative, sourcePattern, instrumentedSourcemap);
+                instrumentedAndCleanedSource = instrumentedAndCleanedSource
+                    .replace(/actualCoverage\s*=\s*coverage\[path\]/g, 'actualCoverage=_$registerCoverageObject(coverage[path])')
                     .replace(/new Function\("return this"\)\(\)/g, "typeof window === 'object' ? window : this");
-                this.logger.debug('Instrumentation source maps to:', (_c = instrumenter.lastSourceMap()) === null || _c === void 0 ? void 0 : _c.sources);
                 // The process also can result in a new source map that we will append in the result.
                 //
                 // `lastSourceMap` === Sourcemap for the last file that was instrumented.
                 finalSourceMap = convertSourceMap.fromObject(instrumenter.lastSourceMap()).toComment();
-                break;
+                // We now can glue together the final version of the instrumented file.
+                const vaccineSource = this.loadVaccine(collector);
+                writeToFile(taskElement.toFile, `${exports.IS_INSTRUMENTED_TOKEN} ${vaccineSource} ${instrumentedAndCleanedSource} \n${finalSourceMap}`);
+                return new Task_1.TaskResult(1, 0, 0, 0, 0, 0, 0);
             }
             catch (e) {
                 // If also the last configuration alternative failed,
@@ -108,16 +141,42 @@ class IstanbulInstrumenter {
                     if (!inputSourceMap) {
                         return Task_1.TaskResult.warning(`Failed loading input source map for ${taskElement.fromFile}: ${e.message}`);
                     }
-                    fs.writeFileSync(taskElement.toFile, inputFileSource);
+                    writeToFile(taskElement.toFile, inputFileSource);
                     return Task_1.TaskResult.error(e);
                 }
             }
         }
-        // We now can glue together the final version of the instrumented file.
-        //
-        const vaccineSource = this.loadVaccine(collector);
-        fs.writeFileSync(taskElement.toFile, `${exports.IS_INSTRUMENTED_TOKEN} ${vaccineSource} ${instrumentedSource} \n${finalSourceMap}`);
-        return new Task_1.TaskResult(1, 0, 0, 0, 0, 0);
+        return new Task_1.TaskResult(0, 0, 0, 0, 0, 1, 0);
+    }
+    async removeUnwantedInstrumentation(taskElement, instrumentedSource, configurationAlternative, sourcePattern, instrumentedSourcemap) {
+        const instrumentedSourceMapConsumer = await new source_map_1.SourceMapConsumer(instrumentedSourcemap);
+        // Without a source map, excludes/includes do not work.
+        if (!instrumentedSourceMapConsumer) {
+            return instrumentedSource;
+        }
+        const removedInstrumentationFor = new Set();
+        // Remove the unwanted instrumentation
+        const cleaned = (0, Postprocessor_1.cleanSourceCode)(instrumentedSource, configurationAlternative.esModules, location => {
+            const originalPosition = instrumentedSourceMapConsumer.originalPositionFor({
+                line: location.start.line,
+                column: location.start.column
+            });
+            if (!originalPosition.source) {
+                return false;
+            }
+            const isToCover = sourcePattern.isAnyIncluded([originalPosition.source]);
+            if (!isToCover) {
+                removedInstrumentationFor.add(originalPosition.source);
+            }
+            return isToCover;
+        });
+        if (removedInstrumentationFor.size) {
+            this.logger.info(`Removed from ${taskElement.toFile} instrumentation for:`);
+            removedInstrumentationFor.forEach(entry => this.logger.info(entry));
+        }
+        // Explicitly free the source map to avoid memory leaks
+        instrumentedSourceMapConsumer.destroy();
+        return cleaned;
     }
     /**
      * Loads the vaccine from the vaccine file and adjusts some template parameters.
@@ -125,23 +184,9 @@ class IstanbulInstrumenter {
      * @param collector - The collector to send coverage information to.
      */
     loadVaccine(collector) {
-        // We first replace some of the parameters in the file with the
+        // We first replace parameters in the file with the
         // actual values, for example, the collector to send the coverage information to.
-        return fs
-            .readFileSync(this.vaccineFilePath, 'utf8')
-            .replace(/\$REPORT_TO_HOST/g, collector.host)
-            .replace(/\$REPORT_TO_PORT/g, `${collector.port}`);
-    }
-    /**
-     * Should the given file be excluded from the instrumentation,
-     * based on the source files that have been transpiled into it?
-     *
-     * @param pattern - The pattern to match the origin source files.
-     * @param sourceFile - The bundle file name.
-     * @param originSourceFiles - The list of files that were transpiled into the bundle.
-     */
-    shouldExcludeFromInstrumentation(pattern, sourceFile, originSourceFiles) {
-        return !pattern.isAnyIncluded(originSourceFiles);
+        return fs.readFileSync(this.vaccineFilePath, 'utf8').replace(/\$REPORT_TO_URL/g, collector.url);
     }
     /**
      * @returns whether the given file is supported for instrumentation.
@@ -158,33 +203,69 @@ class IstanbulInstrumenter {
         this.logger.debug(`Determining configuration alternatives for ${taskElement.fromFile}`);
         const baseConfig = {
             coverageVariable: '__coverage__',
-            produceSourceMap: true
+            produceSourceMap: 'both'
         };
         return [
             { ...baseConfig, ...{ esModules: true } },
             { ...baseConfig, ...{ esModules: false } }
         ];
     }
-    /**
-     * Given a source code file and the task element, load the corresponding sourcemap.
-     *
-     * @param inputSource - The source code that might contain sourcemap comments.
-     * @param taskElement - The task element that can have a reference to an external sourcemap.
-     */
-    loadInputSourceMap(inputSource, taskElement) {
-        if (taskElement.externalSourceMapFile.isPresent()) {
-            const sourceMapOrigin = taskElement.externalSourceMapFile.get();
-            if (!(sourceMapOrigin instanceof Task_1.SourceMapFileReference)) {
-                throw new commons_1.IllegalArgumentException('Type of source map not yet supported!');
+    /** Appends all origins from the source map to a given file. Creates the file if it does not exist yet. */
+    dumpOrigins(dumpOriginsFile, originSourceFiles) {
+        const jsonContent = JSON.stringify(originSourceFiles, null, 2);
+        fs.writeFile(dumpOriginsFile, jsonContent + '\n', { flag: 'a' }, error => {
+            if (error) {
+                this.logger.warn('Could not dump origins file');
+            }
+        });
+    }
+    /** Clears the dump origins file if it exists, such that it is now ready to be appended for every instrumented file. */
+    clearDumpOriginsFileIfNeeded(dumpOriginsFile) {
+        if (dumpOriginsFile && fs.existsSync(dumpOriginsFile)) {
+            try {
+                fs.unlinkSync(dumpOriginsFile);
+            }
+            catch (err) {
+                this.logger.warn('Could not clear origins file: ' + err);
             }
-            return sourceMapFromMapFile(sourceMapOrigin.sourceMapFilePath);
-        }
-        else {
-            return sourceMapFromCodeComment(inputSource, taskElement.fromFile);
         }
     }
 }
 exports.IstanbulInstrumenter = IstanbulInstrumenter;
+/**
+ * Extract the sourcemap from the given source code.
+ *
+ * @param instrumentedSource - The source code.
+ * @param instrumentedSourceFileName - The file name to assume for the file name.
+ */
+async function loadSourceMap(instrumentedSource, instrumentedSourceFileName) {
+    const instrumentedSourceMap = loadInputSourceMap(instrumentedSource, instrumentedSourceFileName, typescript_optional_1.Optional.empty());
+    if (instrumentedSourceMap) {
+        return await new source_map_1.SourceMapConsumer(instrumentedSourceMap);
+    }
+    return undefined;
+}
+exports.loadSourceMap = loadSourceMap;
+/**
+ * Given a source code file, load the corresponding sourcemap.
+ *
+ * @param inputSource - The source code that might contain sourcemap comments.
+ * @param taskFile - The name of the file the `inputSource` is from.
+ * @param externalSourceMapFile - An external source map file to consider.
+ */
+function loadInputSourceMap(inputSource, taskFile, externalSourceMapFile) {
+    if (externalSourceMapFile.isPresent()) {
+        const sourceMapOrigin = externalSourceMapFile.get();
+        if (!(sourceMapOrigin instanceof Task_1.SourceMapFileReference)) {
+            throw new commons_1.IllegalArgumentException('Type of source map not yet supported!');
+        }
+        return sourceMapFromMapFile(sourceMapOrigin.sourceMapFilePath);
+    }
+    else {
+        return sourceMapFromCodeComment(inputSource, taskFile);
+    }
+}
+exports.loadInputSourceMap = loadInputSourceMap;
 /**
  * Extract a sourcemap for a given code comment.
  *
@@ -218,11 +299,11 @@ function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
                 // One JS file can refer to several source map files in its comments.
                 failedLoading++;
             }
-            if (result) {
-                return result;
-            }
         }
     } while (matched);
+    if (result) {
+        return result;
+    }
     if (failedLoading > 0) {
         throw new commons_1.IllegalArgumentException('None of the referenced source map files loaded!');
     }
@@ -230,6 +311,7 @@ function sourceMapFromCodeComment(sourcecode, sourceFilePath) {
         return undefined;
     }
 }
+exports.sourceMapFromCodeComment = sourceMapFromCodeComment;
 /**
  * Read a source map from a source map file.
  *
@@ -239,3 +321,8 @@ function sourceMapFromMapFile(mapFilePath) {
     const content = fs.readFileSync(mapFilePath, 'utf8');
     return JSON.parse(content);
 }
+exports.sourceMapFromMapFile = sourceMapFromMapFile;
+function writeToFile(filePath, fileContent) {
+    mkdirp.sync(path.dirname(filePath));
+    fs.writeFileSync(filePath, fileContent);
+}

package/dist/src/instrumenter/Postprocessor.d.ts

@@ -0,0 +1,9 @@
+import { SourceLocation } from '@babel/types';
+/**
+ * Remove IstanbulJs instrumentations based on the given
+ * hook `makeCoverable`.
+ *
+ * An instrumentation is removed if the hook `makeCoverable` returns `false`.
+ */
+export declare function cleanSourceCode(code: string, esModules: boolean, makeCoverable: (location: SourceLocation) => boolean): string;
+//# sourceMappingURL=Postprocessor.d.ts.map

package/dist/src/instrumenter/Postprocessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Postprocessor.d.ts","sourceRoot":"","sources":["../../../src/instrumenter/Postprocessor.ts"],"names":[],"mappings":"AAGA,OAAO,EAQN,cAAc,EASd,MAAM,cAAc,CAAC;AAqKtB;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,OAAO,EAClB,aAAa,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,GAClD,MAAM,CAaR"}

package/dist/src/instrumenter/Postprocessor.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanSourceCode = void 0;
+const parser_1 = require("@babel/parser");
+const generator_1 = __importDefault(require("@babel/generator"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const types_1 = require("@babel/types");
+const commons_1 = require("@cqse/commons");
+const COVERAGE_OBJ_FUNCTION_NAME_PREFIX = 'cov_';
+/**
+ * Generator for identifiers that are unique across files to instrument.
+ * Relevant in case no Ecmascript modules are used.
+ *
+ * We assume that the files to be executed in a browser can
+ * stem from different runs of the instrumenter. We have to decrease
+ * the probability of colliding identifiers.
+ */
+const fileIdSeqGenerator = (() => {
+    const instrumenterRunId = process.pid;
+    let fileIdSeq = 0;
+    return {
+        next: () => {
+            fileIdSeq++;
+            let num;
+            if (fileIdSeq < 10000) {
+                num = instrumenterRunId * 10000 + fileIdSeq;
+            }
+            else if (fileIdSeq < 100000) {
+                num = instrumenterRunId * 100000 + fileIdSeq;
+            }
+            else {
+                throw new Error(`Not more that 100k files supported to be instrumented in one run.`);
+            }
+            return num.toString(36);
+        }
+    };
+})();
+function getIstanbulCoverageFunctionDeclarationName(node) {
+    var _a;
+    if (!(0, types_1.isFunctionDeclaration)(node)) {
+        return undefined;
+    }
+    const functionName = (_a = node.id) === null || _a === void 0 ? void 0 : _a.name;
+    if (functionName === null || functionName === void 0 ? void 0 : functionName.startsWith(COVERAGE_OBJ_FUNCTION_NAME_PREFIX)) {
+        return functionName;
+    }
+    else {
+        return undefined;
+    }
+}
+function createFileIdMappingHandler() {
+    const fileIdMap = new Map();
+    return {
+        enterPath(path) {
+            var _a;
+            if (!(0, types_1.isVariableDeclaration)(path.node)) {
+                return;
+            }
+            const grandParentPath = (_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.parentPath;
+            const coverageFunctionName = getIstanbulCoverageFunctionDeclarationName(grandParentPath === null || grandParentPath === void 0 ? void 0 : grandParentPath.node);
+            if (grandParentPath && coverageFunctionName) {
+                const declaration = path.node;
+                if (declaration.declarations.length === 1) {
+                    const declarator = declaration.declarations[0];
+                    if ((0, types_1.isIdentifier)(declarator.id) && declarator.id.name === 'hash') {
+                        // We take note of the hash that is stored within the `cov_*' function.
+                        const fileIdVarName = `_$f${fileIdSeqGenerator.next()}`;
+                        const fileId = declarator.init.value;
+                        fileIdMap.set(coverageFunctionName, fileIdVarName);
+                        grandParentPath.insertBefore(newStringConstDeclarationNode(fileIdVarName, fileId));
+                    }
+                }
+            }
+        },
+        getFileHashForCoverageObjectId(coverageObjectId) {
+            return fileIdMap.get(coverageObjectId);
+        }
+    };
+}
+function createPartialInstrumentationHandler(fileIdMappingHandler) {
+    return {
+        enterPath(path, makeCoverable) {
+            if (!(0, types_1.isUpdateExpression)(path.node)) {
+                return;
+            }
+            const increment = extractCoverageIncrement(path.node);
+            if (!increment) {
+                return;
+            }
+            const wantCoverageIncrement = path.node.loc && makeCoverable(path.node.loc) && increment.type !== 'function';
+            // Add a new coverage instrument if desired
+            if (wantCoverageIncrement) {
+                const fileIdVarName = fileIdMappingHandler.getFileHashForCoverageObjectId(increment.coverageObjectId);
+                if (!fileIdVarName) {
+                    throw new commons_1.IllegalStateException(`File ID variable for coverage object with ID ${increment.coverageObjectId} not found!`);
+                }
+                const insertAsExpression = (0, types_1.isSequenceExpression)(path.parent);
+                insertNodeBefore(path, newCoverageIncrementNode(fileIdVarName, increment, insertAsExpression));
+            }
+            // Remove the existing coverage increment node
+            path.remove();
+        }
+    };
+}
+/**
+ * Remove IstanbulJs instrumentations based on the given
+ * hook `makeCoverable`.
+ *
+ * An instrumentation is removed if the hook `makeCoverable` returns `false`.
+ */
+function cleanSourceCode(code, esModules, makeCoverable) {
+    const ast = (0, parser_1.parse)(code, { sourceType: esModules ? 'module' : 'script' });
+    const fileIdMappingHandler = createFileIdMappingHandler();
+    const partialInstrumentationHandler = createPartialInstrumentationHandler(fileIdMappingHandler);
+    (0, traverse_1.default)(ast, {
+        enter(path) {
+            fileIdMappingHandler.enterPath(path);
+            partialInstrumentationHandler.enterPath(path, makeCoverable);
+        }
+    });
+    return (0, generator_1.default)(ast, {}, code).code;
+}
+exports.cleanSourceCode = cleanSourceCode;
+/**
+ * We cannot just run `path.insertBefore` to add a new element to an AST.
+ * See https://github.com/jamiebuilds/babel-handbook/blob/master/translations/en/plugin-handbook.md#toc-inserting-a-sibling-node .
+ *
+ * Special handling for some container nodes is needed.
+ */
+function insertNodeBefore(path, toInsert) {
+    if ((0, types_1.isSequenceExpression)(path.parent)) {
+        path.parentPath.unshiftContainer('expressions', [toInsert]);
+    }
+    else {
+        path.insertBefore(toInsert);
+    }
+}
+/**
+ * Creates a new string constant AST node.
+ */
+function newStringConstDeclarationNode(name, value) {
+    return {
+        type: 'VariableDeclaration',
+        kind: 'const',
+        declarations: [
+            {
+                type: 'VariableDeclarator',
+                id: {
+                    type: 'Identifier',
+                    name
+                },
+                init: {
+                    type: 'StringLiteral',
+                    value
+                }
+            }
+        ]
+    };
+}
+/**
+ * Creates a new coverage increment statement.
+ */
+function newCoverageIncrementNode(fileIdVarName, increment, asExpression) {
+    let expression;
+    if (increment.type === 'branch') {
+        expression = newBranchCoverageIncrementExpression(fileIdVarName, increment);
+    }
+    else if (increment.type === 'statement') {
+        expression = newStatementCoverageIncrementExpression(fileIdVarName, increment);
+    }
+    else {
+        throw new Error(`Unexpected coverage increment type: ${increment.type}`);
+    }
+    if (asExpression) {
+        return expression;
+    }
+    return {
+        type: 'ExpressionStatement',
+        expression
+    };
+}
+/**
+ * Create a branch coverage increment node.
+ */
+function newBranchCoverageIncrementExpression(fileIdVarName, increment) {
+    return {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '_$brCov' },
+        arguments: [
+            { type: 'Identifier', name: fileIdVarName },
+            { type: 'NumericLiteral', value: increment.branchId },
+            { type: 'NumericLiteral', value: increment.locationId }
+        ]
+    };
+}
+/**
+ * Create a statement coverage increment node.
+ */
+function newStatementCoverageIncrementExpression(fileIdVarName, increment) {
+    return {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '_$stmtCov' },
+        arguments: [
+            { type: 'Identifier', name: fileIdVarName },
+            { type: 'NumericLiteral', value: increment.statementId }
+        ]
+    };
+}
+/**
+ * Returns the call expression from `cov_2pvvu1hl8v().b[2][0]++;` if
+ * the given UpdateExpression is a branch coverage update expression.
+ */
+function extractBranchCoverageIncrement(expr) {
+    if (expr.operator === '++' &&
+        (0, types_1.isMemberExpression)(expr.argument) &&
+        (0, types_1.isMemberExpression)(expr.argument.object) &&
+        (0, types_1.isMemberExpression)(expr.argument.object.object) &&
+        (0, types_1.isCallExpression)(expr.argument.object.object.object) &&
+        isCoverageObjectCall(expr.argument.object.object.object)) {
+        const coverageObjectId = expr.argument.object.object.object.callee.name;
+        const branchId = expr.argument.object.property.value;
+        const locationId = expr.argument.property.value;
+        return { type: 'branch', branchId, locationId, coverageObjectId };
+    }
+    return null;
+}
+/**
+ * Returns the call expression from `cov_104fq7oo4i().s[0]++;` if
+ * the given UpdateExpression is a statement coverage update expression.
+ */
+function extractStatementCoverageIncrement(expr) {
+    if (expr.operator === '++' &&
+        (0, types_1.isMemberExpression)(expr.argument) &&
+        (0, types_1.isMemberExpression)(expr.argument.object) &&
+        (0, types_1.isCallExpression)(expr.argument.object.object) &&
+        (0, types_1.isIdentifier)(expr.argument.object.property) &&
+        expr.argument.object.property.name === 's' &&
+        isCoverageObjectCall(expr.argument.object.object)) {
+        const coverageObjectId = expr.argument.object.object.callee.name;
+        const statementId = expr.argument.property.value;
+        return { type: 'statement', statementId, coverageObjectId };
+    }
+    return null;
+}
+/**
+ * Returns the call expression from `cov_104fq7oo4i().f[0]++;` if
+ * the given UpdateExpression is a function coverage update expression.
+ */
+function extractFunctionCoverageIncrement(expr) {
+    if (expr.operator === '++' &&
+        (0, types_1.isMemberExpression)(expr.argument) &&
+        (0, types_1.isMemberExpression)(expr.argument.object) &&
+        (0, types_1.isCallExpression)(expr.argument.object.object) &&
+        (0, types_1.isIdentifier)(expr.argument.object.property) &&
+        expr.argument.object.property.name === 'f' &&
+        isCoverageObjectCall(expr.argument.object.object)) {
+        const coverageObjectId = expr.argument.object.object.callee.name;
+        const functionId = expr.argument.property.value;
+        return { type: 'function', functionId, coverageObjectId };
+    }
+    return null;
+}
+/**
+ * Given an `UpdateExpression` extract the call expression returning the coverage object.
+ */
+function extractCoverageIncrement(expr) {
+    var _a, _b;
+    return ((_b = (_a = extractBranchCoverageIncrement(expr)) !== null && _a !== void 0 ? _a : extractStatementCoverageIncrement(expr)) !== null && _b !== void 0 ? _b : extractFunctionCoverageIncrement(expr));
+}
+/**
+ * Check if the given call expression is a coverage call expression.
+ * If this is not the case return `undefined`, and the call expression itself otherwise.
+ */
+function isCoverageObjectCall(callExpression) {
+    return (callExpression !== undefined &&
+        (0, types_1.isIdentifier)(callExpression.callee) &&
+        callExpression.callee.name.startsWith(COVERAGE_OBJ_FUNCTION_NAME_PREFIX));
+}