supercov 0.0.2 → 0.0.4

package/dist/instrumenter.js

@@ -61,27 +61,58 @@ function collectConditions(node, conditions) {
     }
     conditions.push(node);
 }
-function instrumentConditions(node, frameId, nextIndex, decisionLogicalNodes) {
+function instrumentConditions(node, frameId, nextIndex, decisionLogicalNodes, conditionRuntimeName) {
     if (t.isLogicalExpression(node) &&
         (node.operator === "&&" || node.operator === "||")) {
-        const logical = t.logicalExpression(node.operator, instrumentConditions(node.left, frameId, nextIndex, decisionLogicalNodes), instrumentConditions(node.right, frameId, nextIndex, decisionLogicalNodes));
+        const logical = t.logicalExpression(node.operator, instrumentConditions(node.left, frameId, nextIndex, decisionLogicalNodes, conditionRuntimeName), instrumentConditions(node.right, frameId, nextIndex, decisionLogicalNodes, conditionRuntimeName));
         decisionLogicalNodes.add(logical);
         return logical;
     }
     if (t.isUnaryExpression(node, { operator: "!" }) &&
         hasCompoundBooleanDecision(node.argument)) {
-        return t.unaryExpression("!", instrumentConditions(node.argument, frameId, nextIndex, decisionLogicalNodes), true);
+        return t.unaryExpression("!", instrumentConditions(node.argument, frameId, nextIndex, decisionLogicalNodes, conditionRuntimeName), true);
     }
     const index = nextIndex.value;
     nextIndex.value += 1;
-    return t.callExpression(t.identifier(CONDITION), [
+    return t.callExpression(t.identifier(conditionRuntimeName), [
         t.cloneNode(frameId),
         t.numericLiteral(index),
-        t.cloneNode(node, true),
+        node,
     ]);
 }
-function hitStatement(id) {
-    return t.expressionStatement(t.callExpression(t.identifier(HIT), [t.stringLiteral(id)]));
+function hitStatement(id, hitRuntimeName) {
+    return t.expressionStatement(t.callExpression(t.identifier(hitRuntimeName), [t.stringLiteral(id)]));
+}
+function allocatedRuntimeNames(code) {
+    const preferred = [
+        BEGIN,
+        CONDITION,
+        END,
+        HIT,
+        SELECTION_BEGIN,
+        SELECTION_RIGHT,
+        SELECTION_END,
+        WITH_REQUEST_PHASE,
+        OPTIONAL_SELECT,
+        DEFAULT_SELECTED,
+        DEFAULT_ENTERED,
+        TRY_BEGIN,
+        TRY_CATCH,
+        TRY_END,
+        LOOP_BEGIN,
+        LOOP_ENTERED,
+        LOOP_END,
+    ];
+    const names = {};
+    const used = new Set();
+    for (const base of preferred) {
+        let candidate = base;
+        while (used.has(candidate) || code.includes(candidate))
+            candidate = `_${candidate}`;
+        names[base] = candidate;
+        used.add(candidate);
+    }
+    return names;
 }
 function functionLabel(path) {
     if ("id" in path.node && t.isIdentifier(path.node.id))
@@ -109,10 +140,91 @@ function isExecutableStatement(node) {
     }
     return !("declare" in node && node.declare === true);
 }
+function isAnonymousFunctionDefinition(node) {
+    return (t.isArrowFunctionExpression(node) ||
+        (t.isFunctionExpression(node) && node.id === null) ||
+        (t.isClassExpression(node) && node.id === null));
+}
+function isSourceSensitiveFunction(path) {
+    let child = path;
+    for (let parent = path.parentPath; parent; parent = parent.parentPath) {
+        const candidate = parent.node;
+        const value = child.node;
+        if ((t.isParenthesizedExpression(candidate) ||
+            t.isTSAsExpression(candidate) ||
+            t.isTSTypeAssertion(candidate) ||
+            t.isTSNonNullExpression(candidate)) &&
+            candidate.expression === value) {
+            child = parent;
+            continue;
+        }
+        if ((t.isConditionalExpression(candidate) &&
+            (candidate.consequent === value || candidate.alternate === value)) ||
+            (t.isLogicalExpression(candidate) &&
+                (candidate.left === value || candidate.right === value)) ||
+            (t.isSequenceExpression(candidate) &&
+                candidate.expressions.at(-1) === value) ||
+            (t.isAssignmentExpression(candidate) && candidate.right === value)) {
+            child = parent;
+            continue;
+        }
+        if (((t.isClassMethod(candidate) ||
+            t.isClassProperty(candidate) ||
+            t.isObjectMethod(candidate) ||
+            t.isObjectProperty(candidate)) &&
+            candidate.computed &&
+            candidate.key === value) ||
+            ((t.isMemberExpression(candidate) ||
+                t.isOptionalMemberExpression(candidate)) &&
+                candidate.computed &&
+                candidate.property === value))
+            return true;
+        if (t.isCallExpression(candidate) &&
+            t.isIdentifier(candidate.callee, { name: "String" }) &&
+            candidate.arguments.includes(value))
+            return true;
+        if (t.isBinaryExpression(candidate) &&
+            ["+", "<", "<=", ">", ">="].includes(candidate.operator) &&
+            (candidate.left === value || candidate.right === value))
+            return true;
+        if ((t.isMemberExpression(candidate) ||
+            t.isOptionalMemberExpression(candidate)) &&
+            !candidate.computed &&
+            t.isIdentifier(candidate.property, { name: "toString" }) &&
+            candidate.object === value)
+            return true;
+        // Any other operation consumes or stores the function value. Static
+        // ancestry can no longer prove that this exact function is coerced.
+        return false;
+    }
+    return false;
+}
+function isInsideWithStatement(path) {
+    return Boolean(path.findParent((parent) => parent.isWithStatement()));
+}
 export function instrumentMcdc(code, file) {
+    const names = allocatedRuntimeNames(code);
+    const BEGIN = names["__supercovMcdcBegin"];
+    const CONDITION = names["__supercovMcdcCondition"];
+    const END = names["__supercovMcdcEnd"];
+    const HIT = names["__supercovCoverageHit"];
+    const SELECTION_BEGIN = names["__supercovSelectionBegin"];
+    const SELECTION_RIGHT = names["__supercovSelectionRight"];
+    const SELECTION_END = names["__supercovSelectionEnd"];
+    const WITH_REQUEST_PHASE = names["__supercovWithRequestPhase"];
+    const OPTIONAL_SELECT = names["__supercovOptionalSelect"];
+    const DEFAULT_SELECTED = names["__supercovDefaultSelected"];
+    const DEFAULT_ENTERED = names["__supercovDefaultEntered"];
+    const TRY_BEGIN = names["__supercovTryBegin"];
+    const TRY_CATCH = names["__supercovTryCatch"];
+    const TRY_END = names["__supercovTryEnd"];
+    const LOOP_BEGIN = names["__supercovLoopBegin"];
+    const LOOP_ENTERED = names["__supercovLoopEntered"];
+    const LOOP_END = names["__supercovLoopEnd"];
     const parserPlugins = [
         "typescript",
         "decorators-legacy",
+        "sourcePhaseImports",
         ...(file.endsWith("x") ? ["jsx"] : []),
     ];
     const ast = parse(code, {
@@ -128,11 +240,52 @@ export function instrumentMcdc(code, file) {
     const generatedStatements = new WeakSet();
     const decisionLogicalNodes = new WeakSet();
     let usesRequestPhaseHandler = false;
+    // Instrumentation necessarily changes a function's source text. When code
+    // directly observes or coerces that source, keep the entire function body
+    // untouched and report the resulting coverage boundary explicitly.
+    const sourceSensitiveFunctions = new WeakSet();
+    traverse(ast, {
+        Function(path) {
+            if (!isSourceSensitiveFunction(path))
+                return;
+            sourceSensitiveFunctions.add(path.node);
+            if (!path.node.loc)
+                return;
+            limitations.push({
+                id: stableId(file, "semantic-safety", path.node, "function-source"),
+                kind: "semantic-safety",
+                file,
+                line: path.node.loc.start.line,
+                column: path.node.loc.start.column + 1,
+                source: sourceFor(code, path.node),
+                reason: "function body is left uninstrumented because this expression observes or coerces Function source text",
+            });
+        },
+    });
+    const isWithinSourceSensitiveFunction = (path) => (path.isFunction() && sourceSensitiveFunctions.has(path.node)) ||
+        Boolean(path.findParent((parent) => parent.isFunction() && sourceSensitiveFunctions.has(parent.node)));
+    traverse(ast, {
+        WithStatement(path) {
+            if (!path.node.loc)
+                return;
+            limitations.push({
+                id: stableId(file, "semantic-safety", path.node, "with-environment"),
+                kind: "semantic-safety",
+                file,
+                line: path.node.loc.start.line,
+                column: path.node.loc.start.column + 1,
+                source: sourceFor(code, path.node),
+                reason: "with-statement body is left uninstrumented because its object environment can intercept probe identifiers",
+            });
+        },
+    });
+    const isUnsafeInstrumentationContext = (path) => isWithinSourceSensitiveFunction(path) || isInsideWithStatement(path);
     // Record executable statements before adding any instrumentation statements.
     traverse(ast, {
         Statement(path) {
             const node = path.node;
             if (!node.loc ||
+                isUnsafeInstrumentationContext(path) ||
                 generatedStatements.has(node) ||
                 !isExecutableStatement(node))
                 return;
@@ -147,7 +300,7 @@ export function instrumentMcdc(code, file) {
                 column: node.loc.start.column + 1,
                 source: sourceFor(code, node),
             });
-            const probe = hitStatement(id);
+            const probe = hitStatement(id, HIT);
             generatedStatements.add(probe);
             if (path.parentPath.isProgram() ||
                 path.parentPath.isBlockStatement() ||
@@ -196,43 +349,48 @@ export function instrumentMcdc(code, file) {
     };
     traverse(ast, {
         OptionalMemberExpression(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             if (!path.node.optional || !t.isExpression(path.node.object))
                 return;
             path.node.object = instrumentOptionalOperand(path, path.node.object);
         },
         OptionalCallExpression(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             if (!path.node.optional || !t.isExpression(path.node.callee))
                 return;
             const callee = path.node.callee;
+            if (t.isOptionalMemberExpression(callee)) {
+                if (path.node.loc) {
+                    limitations.push({
+                        id: stableId(file, "semantic-safety", path.node, "optional-chain-call"),
+                        kind: "semantic-safety",
+                        file,
+                        line: path.node.loc.start.line,
+                        column: path.node.loc.start.column + 1,
+                        source: sourceFor(code, path.node),
+                        reason: "optional calls whose receiver is itself an optional chain are left native to preserve chain short-circuiting and method receiver semantics",
+                    });
+                }
+                return;
+            }
             if (t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) {
-                // Preserve the receiver of `object.method?.()` by evaluating the
-                // object and method once and calling through Function#call.
-                if (t.isSuper(callee.object) || !t.isExpression(callee.object)) {
-                    if (path.node.loc) {
-                        limitations.push({
-                            id: stableId(file, "dynamic-code", path.node, "optional-super"),
-                            kind: "dynamic-code",
-                            file,
-                            line: path.node.loc.start.line,
-                            column: path.node.loc.start.column + 1,
-                            source: sourceFor(code, path.node),
-                            reason: "optional calls through super cannot be probed without changing receiver semantics",
-                        });
-                    }
-                    return;
+                // Rewriting `object.method?.()` through `.call` preserves `this` for
+                // the immediate invocation but breaks the specification's optional
+                // chain continuation (`object.method?.()()`). Leave it native until a
+                // probe can preserve the chain's internal short-circuit target.
+                if (path.node.loc) {
+                    limitations.push({
+                        id: stableId(file, "semantic-safety", path.node, "optional-method-call"),
+                        kind: "semantic-safety",
+                        file,
+                        line: path.node.loc.start.line,
+                        column: path.node.loc.start.column + 1,
+                        source: sourceFor(code, path.node),
+                        reason: "optional method calls are left native to preserve receiver and whole-chain short-circuit semantics",
+                    });
                 }
-                const objectId = path.scope.generateUidIdentifier("supercovOptionalObject");
-                const callableId = path.scope.generateUidIdentifier("supercovOptionalCallable");
-                const frameScope = path.scope.getFunctionParent() ?? path.scope.getProgramParent();
-                frameScope.push({ id: t.cloneNode(objectId), kind: "let" });
-                frameScope.push({ id: t.cloneNode(callableId), kind: "let" });
-                const objectAssignment = t.assignmentExpression("=", t.cloneNode(objectId), callee.object);
-                const member = t.memberExpression(t.cloneNode(objectId), t.cloneNode(callee.property), callee.computed);
-                const callableAssignment = t.assignmentExpression("=", t.cloneNode(callableId), member);
-                const selected = instrumentOptionalOperand(path, t.cloneNode(callableId));
-                const call = t.optionalCallExpression(t.optionalMemberExpression(selected, t.identifier("call"), false, true), [t.cloneNode(objectId), ...path.node.arguments.map((argument) => t.cloneNode(argument))], false);
-                path.replaceWith(t.sequenceExpression([objectAssignment, callableAssignment, call]));
-                path.skip();
                 return;
             }
             path.node.callee = instrumentOptionalOperand(path, callee);
@@ -243,6 +401,8 @@ export function instrumentMcdc(code, file) {
     traverse(ast, {
         AssignmentExpression: {
             exit(path) {
+                if (isUnsafeInstrumentationContext(path))
+                    return;
                 const node = path.node;
                 if (!node.loc ||
                     (node.operator !== "&&=" &&
@@ -274,6 +434,11 @@ export function instrumentMcdc(code, file) {
                 const assignment = t.assignmentExpression(node.operator, t.cloneNode(node.left), t.callExpression(t.identifier(SELECTION_RIGHT), [
                     t.cloneNode(frameId),
                     node.right,
+                    ...(t.isIdentifier(node.left) &&
+                        !node.left.extra?.parenthesized &&
+                        isAnonymousFunctionDefinition(node.right)
+                        ? [t.stringLiteral(node.left.name)]
+                        : []),
                 ]));
                 path.replaceWith(t.sequenceExpression([
                     assignFrame,
@@ -291,6 +456,8 @@ export function instrumentMcdc(code, file) {
     // value without comparing values or evaluating either expression twice.
     traverse(ast, {
         Function(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             if (!t.isBlockStatement(path.node.body))
                 return;
             const entries = [];
@@ -320,6 +487,10 @@ export function instrumentMcdc(code, file) {
                     pattern.right = t.callExpression(t.identifier(DEFAULT_SELECTED), [
                         t.stringLiteral(defaultId),
                         pattern.right,
+                        ...(t.isIdentifier(pattern.left) &&
+                            isAnonymousFunctionDefinition(pattern.right)
+                            ? [t.stringLiteral(pattern.left.name)]
+                            : []),
                     ]);
                     entries.push(t.expressionStatement(t.callExpression(t.identifier(DEFAULT_ENTERED), [
                         t.stringLiteral(defaultId),
@@ -355,6 +526,8 @@ export function instrumentMcdc(code, file) {
     // after JavaScript has completed the binding operation.
     traverse(ast, {
         VariableDeclaration(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const parent = path.parentPath;
             if (parent.isForStatement() && path.key === "init") {
                 let hasDefault = false;
@@ -400,6 +573,10 @@ export function instrumentMcdc(code, file) {
                     pattern.right = t.callExpression(t.identifier(DEFAULT_SELECTED), [
                         t.stringLiteral(defaultId),
                         pattern.right,
+                        ...(t.isIdentifier(pattern.left) &&
+                            isAnonymousFunctionDefinition(pattern.right)
+                            ? [t.stringLiteral(pattern.left.name)]
+                            : []),
                     ]);
                     entries.push(t.expressionStatement(t.callExpression(t.identifier(DEFAULT_ENTERED), [
                         t.stringLiteral(defaultId),
@@ -444,6 +621,8 @@ export function instrumentMcdc(code, file) {
     // return, break, continue, rejection, and throw paths remain observable.
     traverse(ast, {
         TryStatement(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const node = path.node;
             if (!node.loc || !node.handler)
                 return;
@@ -481,6 +660,8 @@ export function instrumentMcdc(code, file) {
             path.skip();
         },
         "ForInStatement|ForOfStatement"(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const node = path.node;
             if (!node.loc)
                 return;
@@ -542,6 +723,8 @@ export function instrumentMcdc(code, file) {
             const node = path.node;
             if (!node.loc || !node.body)
                 return;
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const id = stableId(file, "function", node);
             points.push({
                 id,
@@ -552,7 +735,7 @@ export function instrumentMcdc(code, file) {
                 source: sourceFor(code, node),
                 ...(functionLabel(path) ? { label: functionLabel(path) } : {}),
             });
-            const probe = hitStatement(id);
+            const probe = hitStatement(id, HIT);
             generatedStatements.add(probe);
             if (t.isBlockStatement(node.body)) {
                 node.body.body.unshift(probe);
@@ -580,14 +763,21 @@ export function instrumentMcdc(code, file) {
             kind,
         };
         decisions.push(meta);
-        const frameId = path.scope.generateUidIdentifier("supercovMcdcFrame");
         // A loop predicate's path scope may be represented by Babel as the loop
         // body's block. Declaring the frame there puts it after the predicate that
         // uses it (and is especially visible in async generators). Hoist scratch
         // frames to the nearest function/program scope instead.
-        const frameScope = path.scope.getFunctionParent() ?? path.scope.getProgramParent();
+        const evaluationScope = (path.isFunctionExpression() ||
+            path.isArrowFunctionExpression() ||
+            path.isClassExpression()) &&
+            path.scope.parent
+            ? path.scope.parent
+            : path.scope;
+        const frameScope = evaluationScope.getFunctionParent() ??
+            evaluationScope.getProgramParent();
+        const frameId = frameScope.generateUidIdentifier("supercovMcdcFrame");
         frameScope.push({ id: t.cloneNode(frameId), kind: "let" });
-        const instrumented = instrumentConditions(path.node, frameId, { value: 0 }, decisionLogicalNodes);
+        const instrumented = instrumentConditions(path.node, frameId, { value: 0 }, decisionLogicalNodes, CONDITION);
         const begin = t.callExpression(t.identifier(BEGIN), [
             t.stringLiteral(id),
             t.valueToNode(meta),
@@ -602,18 +792,28 @@ export function instrumentMcdc(code, file) {
     };
     traverse(ast, {
         IfStatement(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             instrumentDecision(path.get("test"), "if");
         },
         ConditionalExpression(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             instrumentDecision(path.get("test"), "ternary");
         },
         WhileStatement(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             instrumentDecision(path.get("test"), "while");
         },
         DoWhileStatement(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             instrumentDecision(path.get("test"), "do-while");
         },
         ForStatement(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const test = path.get("test");
             if (test.node)
                 instrumentDecision(test, "for");
@@ -625,6 +825,8 @@ export function instrumentMcdc(code, file) {
     traverse(ast, {
         LogicalExpression: {
             exit(path) {
+                if (isUnsafeInstrumentationContext(path))
+                    return;
                 const node = path.node;
                 if (!node.loc || decisionLogicalNodes.has(node))
                     return;
@@ -671,6 +873,8 @@ export function instrumentMcdc(code, file) {
     // can legally fall through to the end and must not be counted as no-match.
     traverse(ast, {
         SwitchStatement(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const node = path.node;
             if (!node.loc)
                 return;
@@ -684,7 +888,7 @@ export function instrumentMcdc(code, file) {
                 const label = switchCase.test
                     ? `case ${sourceFor(code, switchCase.test)}`
                     : "default";
-                const probe = hitStatement(alternativeId);
+                const probe = hitStatement(alternativeId, HIT);
                 generatedStatements.add(probe);
                 switchCase.consequent.unshift(...(enteredId
                     ? [
@@ -720,7 +924,7 @@ export function instrumentMcdc(code, file) {
                 switchStatement = t.labeledStatement(t.cloneNode(replacementPath.parentPath.node.label), switchStatement);
                 replacementPath = replacementPath.parentPath;
             }
-            const noMatchProbe = hitStatement(noMatchId);
+            const noMatchProbe = hitStatement(noMatchId, HIT);
             generatedStatements.add(noMatchProbe);
             replacementPath.replaceWith(t.blockStatement([
                 t.variableDeclaration("let", [
@@ -738,6 +942,8 @@ export function instrumentMcdc(code, file) {
     // instead of silently claiming 100% for only the surrounding file.
     traverse(ast, {
         CallExpression(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const callee = path.node.callee;
             if (!path.node.loc || !t.isIdentifier(callee, { name: "eval" }))
                 return;
@@ -752,6 +958,8 @@ export function instrumentMcdc(code, file) {
             });
         },
         NewExpression(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             if (!path.node.loc ||
                 !t.isIdentifier(path.node.callee, { name: "Function" }))
                 return;
@@ -855,6 +1063,8 @@ export function instrumentMcdc(code, file) {
     // let the runtime scan callback arguments for Fetch or Node request headers.
     traverse(ast, {
         CallExpression(path) {
+            if (isUnsafeInstrumentationContext(path))
+                return;
             const callee = path.node.callee;
             const property = (t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) &&
                 !callee.computed &&