supercov 0.0.41 → 0.0.43

package/analyzers/typescript/dist/native-frontend.js

@@ -0,0 +1,271 @@
+import { createRequire, isBuiltin } from "node:module";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { analysisPath } from "./compiler.js";
+import { selectedRootFiles, } from "./frontend.js";
+export function nativeFrontend(entry, projectRoot) {
+    const [major, minor] = process.versions.node.split(".").map(Number);
+    if (major < 22 || (major === 22 && minor < 12))
+        throw new Error("The TypeScript 7 frontend requires Node 22.12 or newer (Node 24 is tested)");
+    const require = createRequire(pathToFileURL(entry));
+    const ast = require("typescript/unstable/ast");
+    const native = require("typescript/unstable/sync");
+    const root = analysisPath(projectRoot);
+    const key = (file) => analysisPath(file).replaceAll("\\", "/");
+    const virtual = new Map();
+    let parseSerial = 0;
+    const opened = new Set();
+    const limitations = new Set();
+    let api;
+    let snapshot;
+    let closed = false;
+    function client() {
+        if (closed)
+            throw new Error("TypeScript 7 frontend is closed");
+        return (api ??= new native.API({
+            cwd: root,
+            fs: {
+                readFile: (file) => virtual.get(key(file)),
+                fileExists: (file) => virtual.has(key(file)) ? true : undefined,
+            },
+        }));
+    }
+    function update(config) {
+        const previous = snapshot;
+        snapshot = client().updateSnapshot({
+            ...(!opened.has(config) ? { openProjects: [config] } : {}),
+            fileChanges: { invalidateAll: true },
+        });
+        opened.add(config);
+        previous?.dispose();
+        const project = snapshot.getProject(config);
+        if (!project)
+            throw new Error(`TypeScript 7 did not open the analysis project: ${config}`);
+        return project;
+    }
+    function overlayConfig(path, config) {
+        if (existsSync(path))
+            throw new Error(`Reserved analysis config already exists: ${path}`);
+        virtual.set(key(path), JSON.stringify(config));
+    }
+    const kinds = ast.SyntaxKind;
+    const functionKinds = new Set([
+        "FunctionDeclaration",
+        "MethodDeclaration",
+        "Constructor",
+        "GetAccessor",
+        "SetAccessor",
+        "FunctionExpression",
+        "ArrowFunction",
+        "MethodSignature",
+        "CallSignature",
+        "JSDocSignature",
+        "ConstructSignature",
+        "IndexSignature",
+        "FunctionType",
+        "JSDocFunctionType",
+        "ConstructorType",
+    ]
+        .map((name) => kinds[name])
+        .filter((value) => typeof value === "number"));
+    const loopKinds = new Set([
+        "ForStatement",
+        "ForInStatement",
+        "ForOfStatement",
+        "WhileStatement",
+        "DoStatement",
+    ].map((name) => kinds[name]));
+    // These adapters preserve native nodes and native enum values. No TS5 predicate
+    // may inspect a TS7 node: syntax-kind numeric values are different.
+    const syntax = {
+        ...ast,
+        SymbolFlags: native.SymbolFlags,
+        forEachChild: (node, visit, visitArray) => node.forEachChild(visit, visitArray),
+        isFunctionLike: (node) => !!node && functionKinds.has(node.kind),
+        isIterationStatement: (node, lookInLabeledStatements) => !!node &&
+            (loopKinds.has(node.kind) ||
+                (lookInLabeledStatements &&
+                    node.kind === kinds.LabeledStatement &&
+                    syntax.isIterationStatement(node.statement, true))),
+        isMethodSignature: ast.isMethodSignatureDeclaration,
+        isParameter: ast.isParameterDeclaration,
+        isTypeAssertionExpression: ast.isTypeAssertion,
+        isStringLiteralLike: (node) => !!node &&
+            (node.kind === kinds.StringLiteral ||
+                node.kind === kinds.NoSubstitutionTemplateLiteral),
+        canHaveModifiers: (node) => !!node && "modifiers" in node,
+        getModifiers: (node) => node.modifiers?.filter((m) => m.kind !== kinds.Decorator),
+    };
+    for (const name of [
+        "isMethodSignature",
+        "isParameter",
+        "isTypeAssertionExpression",
+        "getLeadingCommentRanges",
+        "getTrailingCommentRanges",
+    ])
+        if (typeof syntax[name] !== "function")
+            throw new Error(`Unsupported TypeScript 7 syntax API: ${name}`);
+    const frontend = {
+        kind: "typescript-native-7",
+        version: "7.0.2",
+        syntax,
+        limitations,
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                snapshot?.dispose();
+            }
+            finally {
+                api?.close();
+            }
+        },
+        parseSource(file, text) {
+            const absolute = resolve(root, file);
+            virtual.set(key(absolute), text);
+            // Do not rely on 7.0.2 reloading an edited virtual config's root-file list.
+            const parseConfig = resolve(root, `.supercov-asserted-parse-${++parseSerial}.tsconfig.json`);
+            overlayConfig(parseConfig, {
+                files: [absolute],
+                compilerOptions: {
+                    allowJs: true,
+                    checkJs: true,
+                    noResolve: true,
+                    noLib: true,
+                    noEmit: true,
+                    types: [],
+                },
+            });
+            const project = update(parseConfig);
+            const source = project.program.getSourceFile(absolute);
+            if (!source || source.text !== text)
+                throw new Error(`Native parser source mismatch: ${file}`);
+            const errors = project.program.getSyntacticDiagnostics(absolute);
+            if (errors.length)
+                throw new Error(`Native parser rejected ${file}: ${JSON.stringify(errors)}`);
+            return source;
+        },
+        openProgram(options) {
+            const configPath = resolve(root, options.tsconfig ?? "tsconfig.json");
+            const hasConfig = existsSync(configPath);
+            if (!hasConfig && !options.sourceFiles)
+                throw new Error(`Missing TypeScript config: ${configPath}`);
+            const configured = hasConfig
+                ? client().parseConfigFile(configPath).fileNames
+                : [];
+            const files = selectedRootFiles(options, configured);
+            const overlay = resolve(dirname(configPath), ".supercov-asserted-query.tsconfig.json");
+            overlayConfig(overlay, {
+                ...(hasConfig ? { extends: configPath } : {}),
+                files,
+                include: [],
+                exclude: [],
+                compilerOptions: {
+                    ...(options.sourceFiles ? { allowJs: true, checkJs: true } : {}),
+                    noEmit: true,
+                },
+            });
+            const project = update(overlay);
+            const program = project.program;
+            const configErrors = program.getConfigFileParsingDiagnostics();
+            if (configErrors.length)
+                throw new Error(`TypeScript 7 configuration is invalid: ${JSON.stringify(configErrors)}`);
+            const checker = project.checker;
+            const symbols = new WeakMap();
+            const nativeSymbols = new WeakMap();
+            function wrapSymbol(symbol) {
+                if (!symbol)
+                    return undefined;
+                let wrapped = symbols.get(symbol);
+                if (!wrapped) {
+                    wrapped = {
+                        flags: symbol.flags,
+                        name: symbol.name,
+                        escapedName: symbol.escapedName,
+                        get valueDeclaration() {
+                            return symbol.valueDeclaration?.resolve(project);
+                        },
+                        get declarations() {
+                            return symbol.declarations.map((handle) => {
+                                const node = handle.resolve(project);
+                                if (!node)
+                                    throw new Error("TypeScript 7 declaration handle did not resolve");
+                                return node;
+                            });
+                        },
+                    };
+                    symbols.set(symbol, wrapped);
+                    nativeSymbols.set(wrapped, symbol);
+                }
+                return wrapped;
+            }
+            const allFiles = program
+                .getSourceFileNames()
+                .map((file) => {
+                const source = program.getSourceFile(file);
+                if (!source)
+                    throw new Error(`Native source disappeared: ${file}`);
+                return source;
+            });
+            const resolutionCache = new Map();
+            return {
+                files: allFiles,
+                checker: {
+                    getSymbolAtLocation: (node) => wrapSymbol(checker.getSymbolAtLocation(node)),
+                    getShorthandAssignmentValueSymbol: (node) => wrapSymbol(checker.getShorthandAssignmentValueSymbol(node)),
+                    getAliasedSymbol: (symbol) => {
+                        const original = nativeSymbols.get(symbol);
+                        if (!original)
+                            throw new Error("Symbol belongs to a different compiler session");
+                        return wrapSymbol(checker.getAliasedSymbol(original));
+                    },
+                    getResolvedSignature: (node) => {
+                        const signature = checker.getResolvedSignature(node);
+                        return signature
+                            ? {
+                                getParameters: () => signature.getParameters().map(wrapSymbol),
+                            }
+                            : undefined;
+                    },
+                },
+                resolveModule(specifier, from) {
+                    const cacheKey = `${key(from)}\0${specifier}`;
+                    if (resolutionCache.has(cacheKey))
+                        return resolutionCache.get(cacheKey);
+                    const source = program.getSourceFile(from);
+                    const paths = new Set();
+                    const visit = (node) => {
+                        if (syntax.isStringLiteralLike(node) && node.text === specifier) {
+                            // Ask the native checker about actual module-reference syntax. A
+                            // vi.mock string is not a TypeScript import and is not guessed.
+                            const p = node.parent;
+                            if (p &&
+                                (ast.isImportDeclaration(p) ||
+                                    ast.isExportDeclaration(p) ||
+                                    (ast.isCallExpression(p) &&
+                                        p.expression.kind === kinds.ImportKeyword))) {
+                                const symbol = checker.getSymbolAtLocation(node);
+                                for (const handle of symbol?.declarations ?? []) {
+                                    const declaration = handle.resolve(project);
+                                    if (declaration && syntax.isSourceFile(declaration))
+                                        paths.add(declaration.fileName);
+                                }
+                            }
+                        }
+                        node.forEachChild(visit);
+                    };
+                    if (source)
+                        visit(source);
+                    const result = paths.size === 1 ? [...paths][0] : undefined;
+                    if (!result && !isBuiltin(specifier))
+                        limitations.add(`native-module-resolution: ${key(from)} → ${specifier}`);
+                    resolutionCache.set(cacheKey, result);
+                    return result;
+                },
+            };
+        },
+    };
+    return frontend;
+}

package/analyzers/typescript/dist/pragmas.js

@@ -0,0 +1,143 @@
+export function assertionWitnessIssue(phases, source, method) {
+    const matches = (phases ?? []).filter((p) => p.source === source && p.op.split(".").pop() === method);
+    if (source && matches.length && matches.every((p) => p.status === "passed"))
+        return undefined;
+    const statuses = new Set(matches.map((p) => p.status ?? "unknown"));
+    return !phases
+        ? "capture-unavailable"
+        : !source
+            ? "uninstrumented-observation"
+            : !matches.length
+                ? "call-not-recorded"
+                : statuses.size > 1
+                    ? "mixed-call-outcomes"
+                    : statuses.has("failed")
+                        ? "call-failed"
+                        : "call-incomplete";
+}
+/** Source hints are kept OUT of observations. A comment never adds a boundary. */
+export function collectPragmas(compiler, files, relativeFile, sites) {
+    const comments = new Map();
+    const key = (sf, pos) => `${relativeFile(sf)}:${pos}`;
+    const location = (sf, pos) => {
+        const p = sf.getLineAndCharacterOfPosition(pos);
+        return `${relativeFile(sf)}:${p.line + 1}:${p.character + 1}`;
+    };
+    for (const sf of files) {
+        const collect = (ranges) => {
+            for (const range of ranges ?? []) {
+                const raw = sf.text.slice(range.pos, range.end);
+                if (!/^\/\/\s*observes:/.test(raw) || comments.has(key(sf, range.pos)))
+                    continue;
+                const parsed = /^\/\/\s*observes:\s*(\S+?)#(\S+)(?:\s+(.+?))?\s*$/.exec(raw);
+                const suffix = parsed?.[3]?.split(/(?:^|\s+)via\s+/);
+                const target = parsed
+                    ? {
+                        file: parsed[1],
+                        function: parsed[2],
+                        snippet: suffix?.[0]?.trim() || undefined,
+                        via: suffix?.slice(1).join(" via ").trim() || undefined,
+                    }
+                    : undefined;
+                const validPath = target &&
+                    !/[\\:]/.test(target.file) &&
+                    target.file
+                        .split("/")
+                        .every((part) => part && part !== "." && part !== "..");
+                const candidates = validPath
+                    ? sites
+                        .filter((s) => s.file === target.file &&
+                        (s.owner === target.function || s.fn === target.function) &&
+                        (!target.snippet || s.text.includes(target.snippet)))
+                        .map((s) => s.id)
+                    : [];
+                comments.set(key(sf, range.pos), {
+                    id: location(sf, range.pos),
+                    where: location(sf, range.pos),
+                    raw,
+                    target,
+                    candidateSites: candidates,
+                    issue: !target
+                        ? "invalid-syntax"
+                        : !validPath
+                            ? "invalid-target-path"
+                            : !candidates.length
+                                ? "target-not-in-inventory"
+                                : candidates.length > 1
+                                    ? "ambiguous-target"
+                                    : undefined,
+                    attachments: [],
+                });
+            }
+        };
+        const visit = (node) => {
+            collect(compiler.getLeadingCommentRanges(sf.text, node.getFullStart()));
+            collect(compiler.getTrailingCommentRanges(sf.text, node.getEnd()));
+            compiler.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    return {
+        register(node, method, testKey, inert) {
+            let statement = node;
+            while (statement.parent && !compiler.isStatement(statement))
+                statement = statement.parent;
+            // A comment on an if/block/declaration is not a claim about every assertion inside it.
+            if (!compiler.isExpressionStatement(statement))
+                return;
+            const sf = node.getSourceFile();
+            for (const range of compiler.getLeadingCommentRanges(sf.text, statement.getFullStart()) ?? []) {
+                const comment = comments.get(key(sf, range.pos));
+                if (!comment)
+                    continue;
+                const attachment = {
+                    testKey,
+                    source: location(sf, node.getStart(sf)),
+                    method,
+                    inert,
+                };
+                if (!comment.attachments.some((a) => a.testKey === testKey &&
+                    a.source === attachment.source &&
+                    a.method === method))
+                    comment.attachments.push(attachment);
+            }
+        },
+        finish(bindings) {
+            return [...comments.values()].flatMap(({ attachments, ...comment }) => {
+                const sources = new Set(attachments.map((a) => `${a.source}#${a.method}`));
+                const issue = comment.issue ??
+                    (sources.size > 1
+                        ? "ambiguous-assertion"
+                        : !sources.size
+                            ? "unattached-assertion"
+                            : undefined);
+                const matched = bindings.flatMap((b) => attachments
+                    .filter((a) => a.testKey === b.testKey && !a.inert)
+                    .map((a) => ({ a, b })));
+                if (sources.size !== 1 || !matched.length)
+                    return [
+                        {
+                            ...comment,
+                            issue: issue ?? "no-owning-passed-test",
+                            witness: "unavailable",
+                        },
+                    ];
+                return matched.map(({ a, b }) => {
+                    const witnessIssue = assertionWitnessIssue(b.phases, a.source, a.method);
+                    return {
+                        ...comment,
+                        id: `${comment.id}@${b.id}`,
+                        issue,
+                        test: b.id,
+                        assertionSource: a.source,
+                        assertionMethod: a.method,
+                        witness: witnessIssue
+                            ? "unavailable"
+                            : "passed",
+                        witnessIssue,
+                    };
+                });
+            });
+        },
+    };
+}

package/analyzers/typescript/dist/types.js

@@ -0,0 +1 @@
+export {};

package/analyzers/typescript/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@supercov/asserted-typescript",
+  "version": "0.0.0",
+  "private": true,
+  "description": "TypeScript assertion and value-flow facts for Supercov's language-neutral join",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "src",
+    "tsconfig.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node node_modules/typescript/bin/tsc -p tsconfig.json && node bin/identity.mjs",
+    "test": "npm run build && node --test tests/*.test.mjs",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "24.0.0",
+    "typescript": "5.8.3",
+    "typescript-native": "npm:typescript@7.0.2"
+  }
+}