@esportsplus/typescript 0.31.1 → 0.33.0

package/build/{probe → guard}/exceptions/channel.d.ts

@@ -1,5 +1,6 @@
-import type { Channel } from '../kernel/types.js';
+import { type ThrowIndex } from './derive.js';
 import { type ExceptionsValue } from './value.js';
+import type { Channel } from '../kernel/types.js';
 declare function overlayThrows(entry: unknown): boolean;
-declare function createExceptionsChannel(): Channel<ExceptionsValue>;
+declare function createExceptionsChannel(throwIndex: ThrowIndex): Channel<ExceptionsValue>;
 export { createExceptionsChannel, overlayThrows };

package/build/{probe → guard}/exceptions/channel.js

@@ -1,18 +1,21 @@
 import * as NodeFS from 'node:fs';
-import * as ts from '../../probe/adapter.js';
-import { bodyOf, calleeSelectors, paramSymbols } from '../kernel/ast.js';
+import * as ts from '../adapter.js';
+import { bodyOf, constituents, isAwaited, paramSymbols } from '../kernel/ast.js';
 import { isFunctionLike, locationOf } from '../kernel/ids.js';
 import { declaredExceptions } from './jsdoc.js';
-import { bottom, constituentsOf, equals, isEmpty, join, originsOf, refOfType, render, single, subtract, top, TOP_KEY, widen, withOrigin, } from './value.js';
+import { deriveThrows } from './derive.js';
+import { bottom, equals, isEmpty, join, originOf, originsOf, refOfType, render, single, subtract, top, TOP_KEY, widen, withOrigin, } from './value.js';
 function overlayThrows(entry) {
     const e = (entry ?? {});
     return ((Array.isArray(e.exceptions) && e.exceptions.length > 0) ||
         (Array.isArray(e.exceptionsFromCallbacks) &&
             e.exceptionsFromCallbacks.length > 0));
 }
-function createExceptionsChannel() {
+function createExceptionsChannel(throwIndex) {
     let unhandledCache;
     const typeCache = new Map();
+    const importIndex = new Map();
+    const namedTypeCache = new Map();
     const typeAt = (checker, node) => {
         if (typeCache.has(node)) {
             return typeCache.get(node);
@@ -21,6 +24,69 @@ function createExceptionsChannel() {
         typeCache.set(node, type);
         return type;
     };
+    const importsFor = (sf) => {
+        let imports = importIndex.get(sf);
+        if (imports) {
+            return imports;
+        }
+        imports = new Map();
+        importIndex.set(sf, imports);
+        for (const statement of sf.statements) {
+            if (!ts.isImportDeclaration(statement) ||
+                !ts.isStringLiteral(statement.moduleSpecifier) ||
+                !statement.importClause) {
+                continue;
+            }
+            const specifier = statement.moduleSpecifier.text;
+            if (specifier.startsWith('.') || specifier.startsWith('/')) {
+                continue;
+            }
+            const clause = statement.importClause;
+            if (clause.name) {
+                imports.set(clause.name.text, {
+                    exportName: 'default',
+                    isNamespace: false,
+                    memberName: undefined,
+                    specifier,
+                });
+            }
+            if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                for (const element of clause.namedBindings.elements) {
+                    imports.set(element.name.text, {
+                        exportName: (element.propertyName ?? element.name).text,
+                        isNamespace: false,
+                        memberName: undefined,
+                        specifier,
+                    });
+                }
+            }
+            else if (clause.namedBindings &&
+                ts.isNamespaceImport(clause.namedBindings)) {
+                imports.set(clause.namedBindings.name.text, {
+                    exportName: '',
+                    isNamespace: true,
+                    memberName: undefined,
+                    specifier,
+                });
+            }
+        }
+        return imports;
+    };
+    const namedTypeAt = (checker, name, location) => {
+        const sf = location.getSourceFile();
+        let names = namedTypeCache.get(sf);
+        if (!names) {
+            names = new Map();
+            namedTypeCache.set(sf, names);
+        }
+        if (names.has(name)) {
+            return names.get(name);
+        }
+        const sym = checker.resolveName(name, ts.SymbolFlags.Type, location, false);
+        const type = sym ? checker.getDeclaredTypeOfSymbol(sym) : undefined;
+        names.set(name, type);
+        return type;
+    };
     const computeUnhandled = (ctx) => {
         if (unhandledCache)
             return unhandledCache;
@@ -39,7 +105,7 @@ function createExceptionsChannel() {
         equals,
         widen,
         transfer(ctx) {
-            const env = makeEnv(ctx.checker, ctx.dispatch, ctx.sinks, ctx.fn, ctx.summaryOf, ctx.resolveCall, typeAt);
+            const env = makeEnv(ctx.checker, throwIndex, ctx.fn, ctx.summaryOf, ctx.resolveCall, typeAt, undefined, undefined, importsFor, namedTypeAt);
             const body = bodyOf(ctx.fn.node);
             let value = body ? escapeOf(env, body, undefined) : bottom();
             const decl = declaredExceptions(ctx.fn.node, ctx.checker);
@@ -49,14 +115,14 @@ function createExceptionsChannel() {
         },
         diagnose(ctx) {
             const out = [];
-            const base = makeEnv(ctx.checker, ctx.dispatch, ctx.sinks, ctx.fn, ctx.summaryOf, ctx.resolveCall, typeAt);
-            const env = reportMode(ctx) === 'cross-module'
-                ? {
+            const mode = reportMode(ctx);
+            const base = makeEnv(ctx.checker, throwIndex, ctx.fn, ctx.summaryOf, ctx.resolveCall, typeAt, new Map(), new Map(), importsFor, namedTypeAt, mode);
+            const env = mode === 'all'
+                ? base
+                : {
                     ...base,
-                    escapeCache: new Map(),
                     unhandled: computeUnhandled(ctx),
-                }
-                : { ...base, escapeCache: new Map() };
+                };
             const body = bodyOf(ctx.fn.node);
             const decl = declaredExceptions(ctx.fn.node, ctx.checker);
             if (decl.declared && body) {
@@ -72,28 +138,33 @@ function createExceptionsChannel() {
                     });
                 }
             }
-            if (errorCauseEnabled(ctx) && body)
+            if (body) {
                 checkErrorCause(body, out);
-            if (ctx.isBoundary && body)
+            }
+            if (body) {
                 walkDiagnostics(env, ctx, body, undefined, undefined, out);
+            }
             return out;
         },
     };
 }
-function makeEnv(checker, dispatch, sinks, fn, summaryOf, resolveCall, typeAt) {
+function makeEnv(checker, throwIndex, fn, summaryOf, resolveCall, typeAt, escapeCache, callCache, importsFor, namedTypeAt, report = undefined) {
     const symbols = paramSymbols(checker, fn.node);
     return {
         checker,
-        dispatch,
-        sinks,
+        throwIndex,
         fn,
         summaryOf,
         resolveCall,
-        escapeCache: undefined,
+        escapeCache,
+        callCache,
+        importsFor,
+        namedTypeAt: (name, location) => namedTypeAt(checker, name, location),
         typeTable: new Map(),
         typeAt: (node) => typeAt(checker, node),
         paramSymbols: symbols,
         fromCallbacks: new Set(),
+        reportMode: report,
     };
 }
 function escapeOf(env, node, binding) {
@@ -112,7 +183,7 @@ function escapeOf(env, node, binding) {
         if (ts.isThrowStatement(n)) {
             if (n.expression && !isBindingRef(env, n.expression, binding)) {
                 const thrown = valueOfType(env, env.typeAt(n.expression));
-                acc = join(acc, withOrigin(thrown, originOf(n)));
+                acc = join(acc, withOrigin(thrown, originOf(n, n.getSourceFile())));
             }
             if (n.expression)
                 ts.forEachChild(n.expression, visit);
@@ -310,6 +381,10 @@ function isSubclassOf(c, base, seen = new Set()) {
     return false;
 }
 function callEscape(env, call) {
+    const cached = env.callCache?.get(call);
+    if (cached) {
+        return cached;
+    }
     detectParamCall(env, call);
     const res = env.resolveCall(call);
     let v = bottom();
@@ -321,15 +396,59 @@ function callEscape(env, call) {
                 v = join(v, env.summaryOf(f).value);
         }
     }
-    if (res.overlay)
+    if (res.overlay) {
         v = join(v, overlayValue(env, res, call));
-    if (res.unresolved && !res.overlay && env.dispatch === 'pessimist')
-        v = join(v, top());
-    const sink = matchSink(env, call);
-    if (sink)
-        v = applySink(v, sink);
+    }
+    else if (res.targets.length === 0) {
+        const derived = deriveForCall(env, call);
+        if (derived)
+            v = join(v, derived);
+    }
+    env.callCache?.set(call, v);
+    return v;
+}
+function deriveForCall(env, call) {
+    const info = importInfoForCall(env, call);
+    if (!info) {
+        return undefined;
+    }
+    const summary = deriveThrows(env.throwIndex, {
+        awaited: ts.isCallExpression(call) && isAwaited(call),
+        exportName: info.exportName,
+        importerFileName: call.getSourceFile().fileName,
+        memberName: info.memberName,
+        specifier: info.specifier,
+    });
+    if (!summary) {
+        return undefined;
+    }
+    let v = bottom();
+    for (const [cls, origins] of summary.classes) {
+        let cv = namedValue(env, cls, call);
+        for (const origin of origins) {
+            cv = withOrigin(cv, origin);
+        }
+        v = join(v, cv);
+    }
     return v;
 }
+function importInfoForCall(env, call) {
+    const imports = env.importsFor(call.getSourceFile());
+    const callee = call.expression;
+    if (ts.isIdentifier(callee)) {
+        return imports.get(callee.text);
+    }
+    if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression)) {
+        const imported = imports.get(callee.expression.text);
+        return imported?.isNamespace
+            ? {
+                ...imported,
+                exportName: callee.name.text,
+            }
+            : undefined;
+    }
+    return undefined;
+}
 function overlayValue(env, res, call) {
     const entry = (res.overlay?.entry ?? {});
     let v = bottom();
@@ -349,11 +468,9 @@ function overlayValue(env, res, call) {
     return v;
 }
 function namedValue(env, name, location) {
-    const sym = env.checker.resolveName(name, ts.SymbolFlags.Type, location, false);
-    if (sym) {
-        const t = env.checker.getDeclaredTypeOfSymbol(sym);
-        if (t)
-            return valueOfType(env, t);
+    const type = env.namedTypeAt(name, location);
+    if (type) {
+        return valueOfType(env, type);
     }
     return single(name, name);
 }
@@ -367,33 +484,6 @@ function detectParamCall(env, call) {
     if (idx !== undefined)
         env.fromCallbacks.add(idx);
 }
-function matchSink(env, call) {
-    if (!ts.isCallExpression(call))
-        return undefined;
-    const names = calleeSelectors(call.expression);
-    for (const s of env.sinks)
-        if (names.has(s.callee))
-            return s;
-    return undefined;
-}
-function applySink(v, sink) {
-    if (!sink.absorbs)
-        return bottom();
-    if (v.top)
-        return v;
-    const absorb = new Set(sink.absorbs);
-    const kept = new Map();
-    const keptOrigins = new Map();
-    for (const [k, d] of v.types) {
-        if (absorb.has(d))
-            continue;
-        kept.set(k, d);
-        const o = v.origins.get(k);
-        if (o)
-            keptOrigins.set(k, o);
-    }
-    return { top: false, types: kept, origins: keptOrigins };
-}
 function reportMode(ctx) {
     const cc = ctx.channelConfig;
     if (typeof cc === 'object' && cc !== null) {
@@ -403,15 +493,8 @@ function reportMode(ctx) {
     }
     return 'consumers';
 }
-function consumersOnly(ctx) {
-    const mode = reportMode(ctx);
-    return mode === 'consumers' || mode === 'cross-module';
-}
-function errorCauseEnabled(ctx) {
-    const cc = ctx.channelConfig;
-    return (typeof cc === 'object' &&
-        cc !== null &&
-        cc['errorCause'] === true);
+function consumersOnly(env) {
+    return env.reportMode === 'consumers' || env.reportMode === 'cross-module';
 }
 function hasCauseArg(node) {
     for (const arg of node.arguments ?? []) {
@@ -482,12 +565,15 @@ function packageRootOf(fileName) {
     }
     return root;
 }
-function crossesModuleBoundary(env, ctx, call) {
+function normalizeSlashes(fileName) {
+    return fileName.replace(/\\/g, '/');
+}
+function crossesBoundary(env, ctx, call, homeOf) {
     const res = env.resolveCall(call);
     if (res.targets.length === 0)
         return true;
-    const home = packageRootOf(ctx.fn.fileName);
-    return res.targets.some((t) => packageRootOf(t.fileName) !== home);
+    const home = homeOf(ctx.fn.fileName);
+    return res.targets.some((t) => homeOf(t.fileName) !== home);
 }
 function reachesTop(env, rem) {
     const u = env.unhandled;
@@ -499,6 +585,9 @@ function reachesTop(env, rem) {
     return false;
 }
 function walkDiagnostics(env, ctx, node, binding, remainder, out) {
+    const homeOf = env.reportMode === 'cross-module'
+        ? normalizeSlashes
+        : packageRootOf;
     const visit = (n) => {
         if (isFunctionLike(n))
             return;
@@ -508,7 +597,7 @@ function walkDiagnostics(env, ctx, node, binding, remainder, out) {
         }
         if (ts.isThrowStatement(n)) {
             if (n.expression) {
-                if (!consumersOnly(ctx)) {
+                if (!consumersOnly(env)) {
                     if (isBindingRef(env, n.expression, binding)) {
                         if (remainder && !isEmpty(remainder))
                             out.push(throwDiagnostic(ctx, n, remainder));
@@ -525,8 +614,11 @@ function walkDiagnostics(env, ctx, node, binding, remainder, out) {
         }
         if (ts.isCallExpression(n) || ts.isNewExpression(n)) {
             const rem = callEscape(env, n);
-            const report = reportMode(ctx) !== 'cross-module' ||
-                (crossesModuleBoundary(env, ctx, n) && reachesTop(env, rem));
+            const mode = env.reportMode;
+            const report = mode === 'all'
+                ? true
+                : crossesBoundary(env, ctx, n, homeOf) &&
+                    reachesTop(env, rem);
             if (!isEmpty(rem) && report)
                 out.push(callDiagnostic(env, ctx, n, rem));
             ts.forEachChild(n, visit);
@@ -550,22 +642,8 @@ function handleTry(env, ctx, n, binding, remainder, out) {
     if (n.finallyBlock)
         walkDiagnostics(env, ctx, n.finallyBlock, binding, remainder, out);
 }
-function originOf(node) {
-    const sf = node.getSourceFile();
-    const start = node.getStart(sf);
-    const { line, character } = sf.getLineAndCharacterOfPosition(start);
-    const raw = node.getText(sf).replace(/\s+/g, ' ').trim();
-    return {
-        fileName: sf.fileName,
-        pos: start,
-        end: node.getEnd(),
-        line: line + 1,
-        column: character + 1,
-        text: raw.length > 120 ? `${raw.slice(0, 117)}…` : raw,
-    };
-}
 function relatedFromOrigins(origins) {
-    return origins.slice(0, 8).map((o) => ({
+    return origins.map((o) => ({
         message: o.text,
         location: {
             fileName: o.fileName,
@@ -587,7 +665,7 @@ function callDiagnostic(env, ctx, call, rem) {
         location: locationOf(call, call.getSourceFile()),
         related: origins.length > 0
             ? relatedFromOrigins(origins)
-            : buildRelated(ctx, res.targets),
+            : buildRelated(res.targets),
     };
 }
 function throwDiagnostic(ctx, node, rem) {
@@ -595,7 +673,7 @@ function throwDiagnostic(ctx, node, rem) {
         channel: 'exceptions',
         message: `Throw may throw ${render(rem)} with no catch on the path to \`${ctx.fn.name}\``,
         location: locationOf(node, node.getSourceFile()),
-        related: buildRelated(ctx, []),
+        related: [],
     };
 }
 function calleeDisplay(res, call) {
@@ -603,16 +681,16 @@ function calleeDisplay(res, call) {
         return res.overlay.symbol;
     if (res.targets[0])
         return res.targets[0].name;
-    const callee = ts.isCallExpression(call) || ts.isNewExpression(call)
-        ? call.expression
-        : undefined;
-    if (callee && ts.isPropertyAccessExpression(callee))
+    const callee = call.expression;
+    if (ts.isPropertyAccessExpression(callee)) {
         return callee.getText();
-    if (callee && ts.isIdentifier(callee))
+    }
+    if (ts.isIdentifier(callee)) {
         return callee.text;
+    }
     return undefined;
 }
-function buildRelated(ctx, targets) {
+function buildRelated(targets) {
     const related = [];
     for (const t of targets) {
         related.push({
@@ -620,19 +698,13 @@ function buildRelated(ctx, targets) {
             location: locationOf(t.node, t.sourceFile),
         });
     }
-    for (const f of ctx.pathToBoundary(ctx.fn)) {
-        related.push({
-            message: `on the path to boundary via ${f.name}`,
-            location: locationOf(f.node, f.sourceFile),
-        });
-    }
     return related;
 }
 function valueOfType(env, type) {
     let v = bottom();
     if (!type)
         return v;
-    for (const t of constituentsOf(type)) {
+    for (const t of constituents(type)) {
         const r = refOfType(env.checker, t);
         if (r.top) {
             v = join(v, top());

package/build/guard/exceptions/derive.d.ts

@@ -0,0 +1,49 @@
+import * as ts from '../adapter.js';
+import { API } from 'typescript/unstable/sync';
+import type { ExceptionOrigin } from './value.js';
+type ImportTarget = {
+    readonly exportName: string;
+    readonly specifier: string;
+};
+type FileIndex = {
+    readonly classes: Map<string, ts.Node>;
+    readonly exportsByName: Map<string, ts.Node>;
+    readonly fns: Map<string, ts.Node>;
+    readonly imports: Map<string, ImportTarget>;
+    readonly namespaces: Map<string, string>;
+    readonly reexportAll: string | undefined;
+    readonly reexports: Map<string, ImportTarget>;
+};
+type ParsedFile = {
+    readonly fileIndex: FileIndex | null;
+    readonly mtimeMs: number;
+    readonly size: number;
+    readonly sourceFile: ts.SourceFile | null;
+};
+type Cached = {
+    readonly async: boolean;
+    readonly classes: Map<string, ExceptionOrigin[]>;
+} | null;
+type ThrowIndex = {
+    api: API | null;
+    readonly contents: Map<string, string>;
+    nextProject: number;
+    readonly parsed: Map<string, ParsedFile>;
+    readonly resolved: Map<string, string | undefined>;
+    readonly snapshots: ReturnType<API['updateSnapshot']>[];
+    readonly summaries: Map<string, Cached>;
+};
+type DerivedSummary = {
+    readonly classes: ReadonlyMap<string, ReadonlyArray<ExceptionOrigin>>;
+};
+type DeriveParams = {
+    readonly awaited: boolean;
+    readonly exportName: string;
+    readonly importerFileName: string;
+    readonly memberName: string | undefined;
+    readonly specifier: string;
+};
+declare function createThrowIndex(): ThrowIndex;
+declare function disposeThrowIndex(index: ThrowIndex): void;
+declare function deriveThrows(index: ThrowIndex, params: DeriveParams): DerivedSummary | undefined;
+export { createThrowIndex, deriveThrows, disposeThrowIndex, type DerivedSummary, type ThrowIndex };