supercov 0.0.44 → 0.0.45

package/analyzers/typescript/dist/archive.js

@@ -1,337 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { analyzeWithFrontend } from "./analyze.js";
-import { analysisPath } from "./compiler.js";
-import { createFrontend } from "./frontend.js";
-export const PROTOCOL = {
-    abi: 1,
-    factsSchema: 1,
-    rules: "source-linked-v3/archive-3",
-    capabilities: [
-        "requiresTotal-v1",
-        "assertion-witness-issues-v1",
-        "complete-passed-test-inventory-v1",
-        "witnessed-callback-scope-v1",
-        "assertion-hints-v1",
-        "awaited-observation-sources-v1",
-        "first-test-call-omission-v1",
-        "closed-count-sensitivity-v1",
-        "closed-payload-sensitivity-v1",
-        "payload-native-predicates-v1",
-        "first-test-direct-return-v1",
-        "mock-observation-projections-v1",
-        "assertion-comparison-relations-v2",
-        "process-exit-source-v1",
-        "process-exit-consumer-v1",
-        "mock-count-lifetimes-v1",
-        "mock-count-factories-v1",
-        "mock-count-rows-v1",
-        "mock-count-array-projections-v1",
-        "primitive-decision-sensitivity-v1",
-    ],
-};
-function sameScope(a, b) {
-    return (!!a &&
-        !!b &&
-        a.version === b.version &&
-        a.runId === b.runId &&
-        a.workerId === b.workerId &&
-        a.testId === b.testId &&
-        a.testKey === b.testKey &&
-        a.retry === b.retry &&
-        a.attemptId === b.attemptId);
-}
-function serverSnapshot(records, scope) {
-    const hits = [], events = [];
-    const decisions = [];
-    for (const record of records) {
-        if (!sameScope(record.scope, scope))
-            continue;
-        const id = record.type === "decision" ? record.meta?.id : record.id;
-        if (!id)
-            throw new Error("Missing scoped server event identity");
-        if (record.type === "decision" && record.meta && record.vector)
-            decisions.push({ meta: record.meta, vectors: [record.vector] });
-        else if (record.type === "hit")
-            hits.push(id);
-        else
-            throw new Error("Invalid scoped server event");
-        events.push({
-            type: record.type,
-            id,
-            phaseId: record.phaseId,
-            statementId: record.statementId,
-        });
-    }
-    return { hits, events, decisions };
-}
-export function analyzeArchive(input, suppliedCompiler) {
-    const frontend = createFrontend(input.projectRoot, suppliedCompiler);
-    try {
-        return analyzeArchiveWithFrontend(input, frontend);
-    }
-    finally {
-        frontend.close();
-    }
-}
-function analyzeArchiveWithFrontend(input, frontend) {
-    const compiler = frontend.syntax;
-    if (input.protocol.abi !== PROTOCOL.abi ||
-        input.protocol.factsSchema !== PROTOCOL.factsSchema ||
-        input.protocol.rules !== PROTOCOL.rules ||
-        JSON.stringify(input.protocol.capabilities) !==
-            JSON.stringify(PROTOCOL.capabilities))
-        throw new Error("Unsupported assertion analyzer protocol/rule revision/capabilities");
-    const root = analysisPath(input.projectRoot);
-    const sources = new Map(input.sourceFiles.map((file) => [
-        file,
-        frontend.parseSource(file, readFileSync(resolve(root, file), "utf8")),
-    ]));
-    function offset(file, p) {
-        const sf = sources.get(file);
-        if (!sf || p.line < 1 || p.column < 1)
-            throw new Error(`Invalid site position in ${file}`);
-        const n = sf.getPositionOfLineAndCharacter(p.line - 1, p.column - 1);
-        if (n > sf.text.length)
-            throw new Error(`Site outside source: ${file}`);
-        return n;
-    }
-    const sites = input.effects.map((e) => ({
-        ...e,
-        kind: "effect",
-        fn: e.function,
-        pos: offset(e.file, e.start),
-        endPos: offset(e.file, e.end),
-    }));
-    // Decision atoms retain their archived decision id and index. Logical-value operands are not
-    // fabricated from truthiness: in particular ?? does not establish the truthiness of its left side.
-    for (const d of input.manifest.decisions) {
-        const sf = sources.get(d.file);
-        if (!sf)
-            continue;
-        const start = offset(d.file, d);
-        let expression;
-        function visit(n) {
-            if (n.getStart(sf) === start && n.getText(sf) === d.source)
-                expression ??= n;
-            compiler.forEachChild(n, visit);
-        }
-        visit(sf);
-        if (!expression)
-            throw new Error(`Archived decision no longer matches source: ${d.id}`);
-        const atoms = [];
-        function flatten(n) {
-            if (compiler.isParenthesizedExpression(n))
-                flatten(n.expression);
-            else if (compiler.isBinaryExpression(n) &&
-                [
-                    compiler.SyntaxKind.AmpersandAmpersandToken,
-                    compiler.SyntaxKind.BarBarToken,
-                ].includes(n.operatorToken.kind)) {
-                flatten(n.left);
-                flatten(n.right);
-            }
-            else
-                atoms.push(n);
-        }
-        flatten(expression);
-        if (atoms.length !== d.conditions.length)
-            throw new Error(`Unsupported decision atom layout: ${d.id}`);
-        atoms.forEach((n, i) => {
-            const begin = sf.getLineAndCharacterOfPosition(n.getStart(sf)), end = sf.getLineAndCharacterOfPosition(n.getEnd());
-            // This owner also participates in source-hint selection. Named arrow
-            // bindings must not be mislabeled <module> merely because they are not
-            // function declarations.
-            let parent = n.parent, owner = "<module>";
-            while (parent) {
-                if (compiler.isFunctionDeclaration(parent) && parent.name) {
-                    owner = parent.name.text;
-                    break;
-                }
-                if ((compiler.isArrowFunction(parent) ||
-                    compiler.isFunctionExpression(parent)) &&
-                    compiler.isVariableDeclaration(parent.parent) &&
-                    compiler.isIdentifier(parent.parent.name)) {
-                    owner = parent.parent.name.text;
-                    break;
-                }
-                parent = parent.parent;
-            }
-            sites.push({
-                id: `${d.id}#${i}`,
-                file: d.file,
-                kind: "decision",
-                category: "condition",
-                classification: "contractual",
-                start: { line: begin.line + 1, column: begin.character + 1 },
-                end: { line: end.line + 1, column: end.character + 1 },
-                pos: n.getStart(sf),
-                endPos: n.getEnd(),
-                text: n.getText(sf),
-                fn: owner,
-                owner,
-                exported: false,
-            });
-        });
-    }
-    const files = {
-        "inventory.json": JSON.stringify({ sites }),
-    };
-    const points = new Map(input.manifest.points.map((p) => [p.id, p]));
-    const decisions = new Map(input.manifest.decisions.map((d) => [d.id, d]));
-    const locations = new Map(points);
-    for (const b of input.manifest.branches)
-        for (const a of b.alternatives)
-            locations.set(a.id, b);
-    const key = (p) => `${p.file}:${p.line}:${p.column}`;
-    const index = [];
-    const executionLinks = [];
-    const attempts = [];
-    const limitations = new Set(input.limitations);
-    limitations.add("Candidate analysis: no site has a checked semantic proof; no assertion percentage is reported.");
-    limitations.add("Phase/statement execution is not data dependence. Candidate flow rules remain unverified; helper-name contracts and temporal value inference are disabled.");
-    limitations.add("Logical-value operand sites and type-dependent effect classifications are not yet a complete denominator.");
-    const accepted = input.records.filter((r) => r.role === "test" &&
-        r.status === "passed" &&
-        !r.flaky &&
-        r.expectedStatus !== "failed" &&
-        r.scope &&
-        r.scope.runId === input.runId &&
-        // Keep uncertain/retried/multiple records out instead of mixing their observations.
-        (r.retry ?? 0) === 0 &&
-        r.scope.retry === 0 &&
-        input.records.filter((other) => other.role === "test" &&
-            (other.testId ?? other.test) === (r.testId ?? r.test)).length === 1);
-    if (!accepted.length)
-        throw new Error("No uniquely attributed, passed, non-retried test attempts in archive");
-    for (const [i, r] of accepted.entries()) {
-        const id = `A${i + 1}`;
-        if (!r.testFile) {
-            // Dropping even one passing attempt could turn its executed/asserted sites
-            // into apparently certain gaps. Ordinary coverage can still be queried.
-            throw new Error("A passed test has no source file; assertion analysis requires test-source provenance. Recapture with a supported runner and stack formatter.");
-        }
-        if (r.browser.length)
-            limitations.add("Browser evidence is not joined in this archive adapter.");
-        if (r.server.some((record) => !sameScope(record.scope, r.scope)))
-            limitations.add("Server events with missing or foreign attempt scopes were excluded.");
-        const snapshots = [...r.runtime, serverSnapshot(r.server, r.scope)];
-        const marked = new Map();
-        function mark(p) {
-            if (!p || !sources.has(p.file))
-                return;
-            if (!marked.has(p.file))
-                marked.set(p.file, new Set());
-            marked.get(p.file).add(p.line);
-        }
-        const outcomes = {};
-        const events = snapshots.flatMap((s) => s.events ?? []);
-        for (const snap of snapshots) {
-            for (const h of snap.hits ?? []) {
-                if (!locations.has(h))
-                    throw new Error(`Unknown archived hit ${h}`);
-                mark(locations.get(h));
-            }
-            for (const d of snap.decisions ?? []) {
-                const meta = decisions.get(d.meta.id);
-                if (!meta)
-                    throw new Error(`Unknown archived decision ${d.meta.id}`);
-                mark(meta);
-                for (const v of d.vectors) {
-                    (outcomes[`${key(meta)}#d`] ??= [0, 0])[v.outcome ? 0 : 1] = 1;
-                    v.values.forEach((value, n) => {
-                        if (typeof value === "boolean")
-                            (outcomes[`${key(meta)}#${n}`] ??= [0, 0])[value ? 0 : 1] = 1;
-                    });
-                }
-            }
-        }
-        function describe(events) {
-            return {
-                fns: [
-                    ...new Set(events
-                        .filter((e) => e.type === "hit" && points.get(e.id)?.kind === "function")
-                        .map((e) => key(points.get(e.id)))),
-                ],
-                decs: [
-                    ...new Set(events
-                        .filter((e) => e.type === "decision" && decisions.has(e.id))
-                        .map((e) => key(decisions.get(e.id)))),
-                ],
-                stmts: events.filter((e) => e.type === "hit" && points.get(e.id)?.kind === "statement").length,
-            };
-        }
-        const phases = r.phases
-            .filter((p) => p.kind === "assertion" && p.source)
-            .map((p) => {
-            const evs = events.filter((e) => e.phaseId === p.id);
-            for (const e of p.status === "passed" ? evs : [])
-                executionLinks.push({
-                    attempt: id,
-                    point: e.id,
-                    location: points.get(e.id) ?? decisions.get(e.id) ?? locations.get(e.id),
-                    phase: p.id,
-                    statement: e.statementId,
-                    operation: p.operation,
-                    assertionSource: p.source,
-                    meaning: "execution-only",
-                });
-            return {
-                op: p.operation,
-                source: p.source,
-                status: p.status,
-                ...describe(evs),
-            };
-        });
-        const statements = {};
-        for (const e of events)
-            if (e.statementId && !statements[e.statementId])
-                statements[e.statementId] = describe(events.filter((other) => other.statementId === e.statementId));
-        const phaseLines = phases
-            .map((p) => /^(.*):(\d+):(\d+)$/.exec(p.source))
-            .filter((m) => m && m[1] === r.testFile)
-            .map((m) => Number(m[2]));
-        index.push({
-            id,
-            name: r.test,
-            title: r.title ?? r.test,
-            file: r.testFile,
-            line: 0,
-            ok: true,
-            phaseLines,
-            runner: r.provenance?.runner,
-        });
-        attempts.push({
-            id,
-            testId: r.testId,
-            name: r.test,
-            file: r.testFile,
-            retry: r.retry ?? 0,
-        });
-        files[`cov/${id}.lcov`] = [...marked]
-            .map(([file, lines]) => `SF:${file}\n${[...lines].map((l) => `DA:${l},1`).join("\n")}\nend_of_record\n`)
-            .join("");
-        files[`cov/${id}.outcomes.json`] = JSON.stringify(outcomes);
-        files[`cov/${id}.phases.json`] = JSON.stringify(phases);
-        files[`cov/${id}.statements.json`] = JSON.stringify(statements);
-    }
-    if (accepted.length !== input.records.filter((r) => r.role === "test").length)
-        limitations.add("Failed, flaky, retried, duplicate or unattributed test records were excluded; this is not whole-suite assertion coverage.");
-    files["cov/index.json"] = JSON.stringify(index);
-    const result = analyzeWithFrontend({
-        projectRoot: root,
-        evidenceFiles: files,
-        sourceFiles: input.sourceFiles,
-        testFiles: [
-            ...new Set(accepted.flatMap((r) => (r.testFile ? [r.testFile] : []))),
-        ],
-    }, frontend);
-    return {
-        protocol: PROTOCOL,
-        ...result,
-        inventory: sites,
-        executionLinks,
-        attempts,
-        limitations: [...limitations, ...frontend.limitations].sort(),
-    };
-}