@esportsplus/typescript 0.31.0 → 0.32.0

package/build/probe/kernel/fixpoint.js

@@ -0,0 +1,206 @@
+const WIDEN_AFTER = 3;
+const MAX_ROUNDS = 12;
+function setsEqual(a, b) {
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const x of a) {
+        if (!b.has(x)) {
+            return false;
+        }
+    }
+    return true;
+}
+function tarjanSccs(nodes, successors) {
+    const index = new Map();
+    const low = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const sccs = [];
+    let counter = 0;
+    const open = (node) => {
+        index.set(node.id, counter);
+        low.set(node.id, counter);
+        counter += 1;
+        stack.push(node);
+        onStack.add(node.id);
+        return { node, succ: successors(node), i: 0 };
+    };
+    for (const start of nodes) {
+        if (index.has(start.id)) {
+            continue;
+        }
+        const work = [open(start)];
+        while (work.length > 0) {
+            const frame = work[work.length - 1];
+            const node = frame.node;
+            if (frame.i < frame.succ.length) {
+                const w = frame.succ[frame.i];
+                frame.i += 1;
+                if (!index.has(w.id)) {
+                    work.push(open(w));
+                }
+                else if (onStack.has(w.id)) {
+                    low.set(node.id, Math.min(low.get(node.id), index.get(w.id)));
+                }
+                continue;
+            }
+            if (low.get(node.id) === index.get(node.id)) {
+                const component = [];
+                for (;;) {
+                    const w = stack.pop();
+                    onStack.delete(w.id);
+                    component.push(w);
+                    if (w.id === node.id) {
+                        break;
+                    }
+                }
+                sccs.push(component);
+            }
+            work.pop();
+            const parent = work[work.length - 1];
+            if (parent) {
+                low.set(parent.node.id, Math.min(low.get(parent.node.id), low.get(node.id)));
+            }
+        }
+    }
+    return sccs;
+}
+function runChannel(analysis, channel, dispatch, channelConfig, peers) {
+    const graph = analysis.graph;
+    const reached = graph.reachedFunctions();
+    const reachedById = new Map();
+    for (const fn of reached) {
+        reachedById.set(fn.id, fn);
+    }
+    const calleesOf = (fn) => graph.calleesOf(fn).filter((c) => reachedById.has(c.id));
+    const summaries = new Map();
+    const bottomSummary = () => ({
+        value: channel.bottom(),
+        fromCallbacks: new Set(),
+    });
+    const summaryOf = (fn) => summaries.get(fn.id) ?? bottomSummary();
+    const makeTransferContext = (fn) => ({
+        checker: analysis.checker,
+        fn,
+        dispatch,
+        channelConfig,
+        sinks: analysis.config.sinks,
+        summaryOf,
+        resolveCall: (call) => graph.resolveCall(call, channel.name),
+        resolveCallFor: (peerChannel, call) => graph.resolveCall(call, peerChannel),
+        peerSummaryValue: (peerChannel, fnId) => peers.get(peerChannel)?.get(fnId).value,
+    });
+    const sccs = tarjanSccs(reached, calleesOf);
+    for (const scc of sccs) {
+        for (const fn of scc) {
+            summaries.set(fn.id, bottomSummary());
+        }
+        let round = 0;
+        for (;;) {
+            round += 1;
+            let changed = false;
+            for (const fn of scc) {
+                const prev = summaries.get(fn.id);
+                const computed = channel.transfer(makeTransferContext(fn));
+                const nextValue = round > WIDEN_AFTER
+                    ? channel.widen(prev.value, computed.value, round)
+                    : computed.value;
+                const next = {
+                    value: nextValue,
+                    fromCallbacks: computed.fromCallbacks,
+                };
+                summaries.set(fn.id, next);
+                if (!channel.equals(prev.value, next.value) ||
+                    !setsEqual(prev.fromCallbacks, next.fromCallbacks)) {
+                    changed = true;
+                }
+            }
+            if (!changed) {
+                break;
+            }
+            if (round >= MAX_ROUNDS) {
+                break;
+            }
+        }
+    }
+    const reverse = new Map();
+    for (const fn of reached) {
+        for (const callee of calleesOf(fn)) {
+            const callers = reverse.get(callee.id);
+            if (callers) {
+                callers.push(fn);
+            }
+            else {
+                reverse.set(callee.id, [fn]);
+            }
+        }
+    }
+    const boundaries = graph.boundaries();
+    const pathToBoundary = (fn) => {
+        if (boundaries.has(fn.id)) {
+            return [fn];
+        }
+        const parent = new Map();
+        const visited = new Set([fn.id]);
+        const queue = [fn];
+        let head = 0;
+        while (head < queue.length) {
+            const cur = queue[head];
+            head += 1;
+            for (const caller of reverse.get(cur.id) ?? []) {
+                if (visited.has(caller.id)) {
+                    continue;
+                }
+                visited.add(caller.id);
+                parent.set(caller.id, cur);
+                if (boundaries.has(caller.id)) {
+                    const rev = [];
+                    let node = caller;
+                    while (node) {
+                        rev.push(node);
+                        if (node.id === fn.id) {
+                            break;
+                        }
+                        node = parent.get(node.id);
+                    }
+                    return rev.toReversed();
+                }
+                queue.push(caller);
+            }
+        }
+        return [fn];
+    };
+    const roots = reached.filter((fn) => (reverse.get(fn.id) ?? []).length === 0);
+    const diagnostics = [];
+    const seen = new Set();
+    for (const fn of reached) {
+        const ctx = {
+            checker: analysis.checker,
+            fn,
+            dispatch,
+            channelConfig,
+            sinks: analysis.config.sinks,
+            isBoundary: boundaries.has(fn.id),
+            summaryOf,
+            resolveCall: (call) => graph.resolveCall(call, channel.name),
+            resolveCallFor: (peerChannel, call) => graph.resolveCall(call, peerChannel),
+            peerSummaryValue: (peerChannel, fnId) => peers.get(peerChannel)?.get(fnId).value,
+            pathToBoundary,
+            roots: () => roots,
+        };
+        for (const d of channel.diagnose(ctx)) {
+            const key = `${d.channel}\u0000${d.location.fileName}\u0000${d.location.pos}\u0000${d.message}`;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            diagnostics.push(d);
+        }
+    }
+    const store = {
+        get: (id) => summaries.get(id) ?? bottomSummary(),
+    };
+    return { store, diagnostics };
+}
+export { runChannel };

package/build/probe/kernel/format.d.ts

@@ -0,0 +1,4 @@
+import type { Diagnostic } from './types.js';
+declare function formatDiagnostic(diagnostic: Diagnostic, projectRoot: string): string;
+declare function formatDiagnostics(diagnostics: ReadonlyArray<Diagnostic>, projectRoot: string): string;
+export { formatDiagnostic, formatDiagnostics };

package/build/probe/kernel/format.js

@@ -0,0 +1,32 @@
+import * as NodePath from 'node:path';
+function rel(projectRoot, fileName) {
+    const r = NodePath.relative(projectRoot, fileName);
+    return r === '' || r.startsWith('..')
+        ? fileName
+        : r.split(NodePath.sep).join('/');
+}
+function formatDiagnostic(diagnostic, projectRoot) {
+    const loc = diagnostic.location;
+    const head = `${rel(projectRoot, loc.fileName)}:${loc.line}:${loc.column} — ${diagnostic.message}`;
+    if (diagnostic.related.length === 0) {
+        return head;
+    }
+    const chain = diagnostic.related
+        .map((r) => {
+        const l = r.location;
+        return `    ↳ ${rel(projectRoot, l.fileName)}:${l.line}:${l.column} — ${r.message}`;
+    })
+        .join('\n');
+    return `${head}\n${chain}`;
+}
+function formatDiagnostics(diagnostics, projectRoot) {
+    if (diagnostics.length === 0) {
+        return 'analyze: no findings.';
+    }
+    const body = diagnostics
+        .map((d) => formatDiagnostic(d, projectRoot))
+        .join('\n\n');
+    const noun = diagnostics.length === 1 ? 'finding' : 'findings';
+    return `${body}\n\nanalyze: ${diagnostics.length} ${noun}.`;
+}
+export { formatDiagnostic, formatDiagnostics };

package/build/probe/kernel/graph.d.ts

@@ -0,0 +1,4 @@
+import * as ts from '../adapter.js';
+import type { CallGraph, OverlaySet, AnalyzeConfig } from './types.js';
+declare function buildCallGraph(program: ts.Program, checker: ts.TypeChecker, config: AnalyzeConfig, overlays: OverlaySet): CallGraph;
+export { buildCallGraph };