@esportsplus/typescript 0.31.0 → 0.31.1

package/build/probe/exceptions/jsdoc.js

@@ -0,0 +1,34 @@
+import * as ts from '../../probe/adapter.js';
+import { bottom, join, single, top, TOP_KEY, typeRef, } from './value.js';
+function declaredExceptions(node, checker) {
+    let value = bottom();
+    let declared = false;
+    for (const tag of ts.getJSDocTags(node)) {
+        const name = tag.tagName.text;
+        if (name !== 'throws' && name !== 'exception')
+            continue;
+        declared = true;
+        const typeExpr = tag
+            .typeExpression;
+        if (typeExpr && typeExpr.type) {
+            const t = checker.getTypeAtLocation(typeExpr.type);
+            if (t)
+                value = join(value, refsToValue(typeRef(checker, t)));
+            continue;
+        }
+        const text = typeof tag.comment === 'string'
+            ? tag.comment
+            : ts.getTextOfJSDocComment(tag.comment);
+        const bare = (text ?? '').trim().split(/[\s,|]+/)[0];
+        if (bare)
+            value = join(value, single(bare, bare));
+    }
+    return { value, declared };
+}
+function refsToValue(refs) {
+    let v = bottom();
+    for (const r of refs)
+        v = join(v, r.key === TOP_KEY ? top() : single(r.key, r.display));
+    return v;
+}
+export { declaredExceptions };

package/build/probe/exceptions/value.d.ts

@@ -0,0 +1,39 @@
+import * as ts from '../../probe/adapter.js';
+type ExceptionOrigin = {
+    readonly fileName: string;
+    readonly pos: number;
+    readonly end: number;
+    readonly line: number;
+    readonly column: number;
+    readonly text: string;
+};
+type ExceptionsValue = {
+    readonly top: boolean;
+    readonly types: ReadonlyMap<string, string>;
+    readonly origins: ReadonlyMap<string, ReadonlyArray<ExceptionOrigin>>;
+};
+declare const TOP_KEY = "\0top";
+declare function bottom(): ExceptionsValue;
+declare function top(): ExceptionsValue;
+declare function single(key: string, display: string): ExceptionsValue;
+declare function withOrigin(v: ExceptionsValue, origin: ExceptionOrigin): ExceptionsValue;
+declare function originsOf(v: ExceptionsValue): ReadonlyArray<ExceptionOrigin>;
+declare function join(a: ExceptionsValue, b: ExceptionsValue): ExceptionsValue;
+declare function equals(a: ExceptionsValue, b: ExceptionsValue): boolean;
+declare function widen(prev: ExceptionsValue, next: ExceptionsValue, round: number): ExceptionsValue;
+declare function subtract(a: ExceptionsValue, keys: ReadonlySet<string>): ExceptionsValue;
+declare function isEmpty(v: ExceptionsValue): boolean;
+declare function render(v: ExceptionsValue): string;
+declare function constituentsOf(type: ts.Type): ReadonlyArray<ts.Type>;
+declare function refOfType(checker: ts.TypeChecker, t: ts.Type): {
+    top: true;
+} | {
+    top: false;
+    key: string;
+    display: string;
+};
+declare function typeRef(checker: ts.TypeChecker, type: ts.Type): ReadonlyArray<{
+    key: string;
+    display: string;
+}>;
+export { TOP_KEY, bottom, constituentsOf, equals, isEmpty, join, originsOf, refOfType, render, single, subtract, top, type ExceptionOrigin, type ExceptionsValue, typeRef, widen, withOrigin };

package/build/probe/exceptions/value.js

@@ -0,0 +1,158 @@
+import * as ts from '../../probe/adapter.js';
+const TOP_KEY = '\u0000top';
+const TOP_DISPLAY = 'an unknown error';
+const WIDEN_CAP = 8;
+const ORIGIN_CAP = 4;
+const NO_ORIGINS = new Map();
+function originId(o) {
+    return `${o.fileName}:${o.pos}`;
+}
+function mergeOrigins(a, b) {
+    const m = new Map(a);
+    for (const [k, list] of b) {
+        const prev = m.get(k);
+        if (!prev) {
+            m.set(k, list.slice(0, ORIGIN_CAP));
+            continue;
+        }
+        const seen = new Set(prev.map(originId));
+        const out = [...prev];
+        for (const o of list) {
+            if (!seen.has(originId(o)) && out.length < ORIGIN_CAP) {
+                seen.add(originId(o));
+                out.push(o);
+            }
+        }
+        m.set(k, out);
+    }
+    return m;
+}
+function bottom() {
+    return { top: false, types: new Map(), origins: NO_ORIGINS };
+}
+function top() {
+    return { top: true, types: new Map(), origins: NO_ORIGINS };
+}
+function single(key, display) {
+    return {
+        top: false,
+        types: new Map([[key, display]]),
+        origins: NO_ORIGINS,
+    };
+}
+function withOrigin(v, origin) {
+    if (v.top)
+        return v;
+    const origins = new Map(v.origins);
+    for (const k of v.types.keys()) {
+        const prev = origins.get(k) ?? [];
+        if (prev.some((o) => originId(o) === originId(origin)))
+            continue;
+        origins.set(k, prev.length < ORIGIN_CAP ? [...prev, origin] : prev);
+    }
+    return { top: false, types: v.types, origins };
+}
+function originsOf(v) {
+    const out = [];
+    const seen = new Set();
+    for (const list of v.origins.values()) {
+        for (const o of list) {
+            if (!seen.has(originId(o))) {
+                seen.add(originId(o));
+                out.push(o);
+            }
+        }
+    }
+    return out;
+}
+function join(a, b) {
+    if (a.top || b.top)
+        return top();
+    const m = new Map(a.types);
+    for (const [k, d] of b.types)
+        if (!m.has(k))
+            m.set(k, d);
+    if (m.size > WIDEN_CAP)
+        return top();
+    return {
+        top: false,
+        types: m,
+        origins: mergeOrigins(a.origins, b.origins),
+    };
+}
+function equals(a, b) {
+    if (a.top || b.top)
+        return a.top === b.top;
+    if (a.types.size !== b.types.size)
+        return false;
+    for (const k of a.types.keys())
+        if (!b.types.has(k))
+            return false;
+    return true;
+}
+function widen(prev, next, round) {
+    if (next.top)
+        return next;
+    if (next.types.size > WIDEN_CAP)
+        return top();
+    if (round >= 3 && !prev.top && next.types.size > prev.types.size)
+        return top();
+    return next;
+}
+function subtract(a, keys) {
+    if (a.top)
+        return a;
+    const m = new Map();
+    const origins = new Map();
+    for (const [k, d] of a.types) {
+        if (keys.has(k))
+            continue;
+        m.set(k, d);
+        const o = a.origins.get(k);
+        if (o)
+            origins.set(k, o);
+    }
+    return { top: false, types: m, origins };
+}
+function isEmpty(v) {
+    return !v.top && v.types.size === 0;
+}
+function render(v) {
+    if (v.top)
+        return TOP_DISPLAY;
+    return Array.from(v.types.values()).sort().join(' | ');
+}
+function constituentsOf(type) {
+    return ts.unionTypes(type) ?? [type];
+}
+function basename(p) {
+    const i = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
+    return i >= 0 ? p.slice(i + 1) : p;
+}
+function refOfType(checker, t) {
+    if ((t.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)
+        return { top: true };
+    const sym = t.getAliasSymbol() ?? t.getSymbol();
+    if (sym) {
+        const decl = ts.symbolDeclarations(sym)[0];
+        const file = decl ? basename(decl.getSourceFile().fileName) : '?';
+        const name = sym.name;
+        const qname = name && name !== '__type' ? name : checker.typeToString(t);
+        const display = name && name !== '__type' ? name : checker.typeToString(t);
+        return { top: false, key: `${file}:${qname}`, display };
+    }
+    const s = checker.typeToString(t);
+    return { top: false, key: s, display: s };
+}
+function typeRef(checker, type) {
+    const out = [];
+    for (const t of constituentsOf(type)) {
+        const r = refOfType(checker, t);
+        if (r.top)
+            out.push({ key: TOP_KEY, display: TOP_DISPLAY });
+        else
+            out.push({ key: r.key, display: r.display });
+    }
+    return out;
+}
+export { TOP_KEY, bottom, constituentsOf, equals, isEmpty, join, originsOf, refOfType, render, single, subtract, top, typeRef, widen, withOrigin };

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

@@ -0,0 +1,8 @@
+import * as ts from '../../probe/adapter.js';
+import type { Diagnostic, AnalyzeConfig } from './types.js';
+type AnalyzeResult = {
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+};
+declare function analyzeProgram(program: ts.Program, checker: ts.TypeChecker, config: AnalyzeConfig): AnalyzeResult;
+declare function analyze(config: AnalyzeConfig): AnalyzeResult;
+export { analyze, analyzeProgram, type AnalyzeResult };

package/build/probe/kernel/analyze.js

@@ -0,0 +1,68 @@
+import { channelFor } from '../channels.js';
+import { buildCallGraph } from './graph.js';
+import { buildProgram } from './program.js';
+import { runChannel } from './fixpoint.js';
+import { loadOverlays } from '../overlay/load.js';
+function analyzeProgram(program, checker, config) {
+    const overlays = loadOverlays(config);
+    const effectiveConfig = {
+        ...config,
+        handlerBoundaries: [
+            ...config.handlerBoundaries,
+            ...overlays.boundariesFromPresets(),
+        ],
+    };
+    const graph = buildCallGraph(program, checker, effectiveConfig, overlays);
+    const analysis = {
+        program,
+        checker,
+        config: effectiveConfig,
+        overlays,
+        graph,
+    };
+    const diagnostics = [];
+    const runnable = new Map();
+    for (const [name, channelConfig] of Object.entries(effectiveConfig.channels)) {
+        if (!channelConfig.enabled) {
+            continue;
+        }
+        runnable.set(name, {
+            config: channelConfig,
+            channel: channelFor(name, channelConfig.options),
+        });
+    }
+    const ordered = [];
+    const placed = new Set();
+    const place = (name, stack) => {
+        if (placed.has(name) || !runnable.has(name) || stack.has(name)) {
+            return;
+        }
+        const next = new Set(stack).add(name);
+        for (const dep of runnable.get(name).channel.dependsOn ?? []) {
+            place(dep, next);
+        }
+        placed.add(name);
+        ordered.push(name);
+    };
+    for (const name of runnable.keys()) {
+        place(name, new Set());
+    }
+    const peers = new Map();
+    for (const name of ordered) {
+        const { config, channel } = runnable.get(name);
+        const result = runChannel(analysis, channel, config.dispatch, config.options, peers);
+        peers.set(name, result.store);
+        diagnostics.push(...result.diagnostics);
+    }
+    return { diagnostics };
+}
+function analyze(config) {
+    const built = buildProgram(config.tsconfigPath);
+    try {
+        return analyzeProgram(built.program, built.checker, config);
+    }
+    finally {
+        built.dispose();
+    }
+}
+export { analyze, analyzeProgram };

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

@@ -0,0 +1,11 @@
+import * as ts from '../../probe/adapter.js';
+import type { FunctionLike } from './types.js';
+type UnwrapOptions = {
+    assertions?: boolean;
+    awaits?: boolean;
+};
+declare const bodyOf: (node: FunctionLike) => ts.Node | undefined;
+declare const calleeSelectors: (callee: ts.Expression) => Set<string>;
+declare const paramSymbols: (checker: ts.TypeChecker, fn: FunctionLike) => Map<ts.Symbol, number>;
+declare const unwrap: (expr: ts.Expression, options?: UnwrapOptions) => ts.Expression;
+export { bodyOf, calleeSelectors, paramSymbols, unwrap };

package/build/probe/kernel/ast.js

@@ -0,0 +1,49 @@
+import * as ts from '../../probe/adapter.js';
+function shouldUnwrap(expr, options) {
+    return (ts.isParenthesizedExpression(expr) ||
+        (options.assertions === true &&
+            (ts.isAsExpression(expr) || ts.isNonNullExpression(expr))) ||
+        (options.awaits === true && ts.isAwaitExpression(expr)));
+}
+const bodyOf = (node) => {
+    return node.body;
+};
+const calleeSelectors = (callee) => {
+    let selectors = new Set();
+    if (ts.isIdentifier(callee)) {
+        selectors.add(callee.text);
+    }
+    else if (ts.isPropertyAccessExpression(callee)) {
+        let member = callee.name.text;
+        selectors.add(member);
+        if (ts.isIdentifier(callee.expression)) {
+            selectors.add(`${callee.expression.text}.${member}`);
+            selectors.add(`${callee.expression.text}#${member}`);
+        }
+    }
+    return selectors;
+};
+const paramSymbols = (checker, fn) => {
+    let symbols = new Map();
+    let params = fn
+        .parameters;
+    if (params) {
+        params.forEach((param, index) => {
+            if (ts.isIdentifier(param.name)) {
+                let symbol = checker.getSymbolAtLocation(param.name);
+                if (symbol) {
+                    symbols.set(symbol, index);
+                }
+            }
+        });
+    }
+    return symbols;
+};
+const unwrap = (expr, options = {}) => {
+    let unwrapped = expr;
+    while (shouldUnwrap(unwrapped, options)) {
+        unwrapped = unwrapped.expression;
+    }
+    return unwrapped;
+};
+export { bodyOf, calleeSelectors, paramSymbols, unwrap };

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

@@ -0,0 +1,5 @@
+import type { AnalyzeConfig } from './types.js';
+declare function parseConfig(text: string, projectRoot: string): AnalyzeConfig;
+declare function configFromObject(raw: unknown, projectRoot: string): AnalyzeConfig;
+declare function loadConfigFromTsconfig(tsconfigPath: string): AnalyzeConfig | undefined;
+export { configFromObject, loadConfigFromTsconfig, parseConfig };

package/build/probe/kernel/config.js

@@ -0,0 +1,209 @@
+import * as NodePath from 'node:path';
+import { readPlugins } from '../../tsconfig.js';
+import { stripJsonc } from '../../jsonc.js';
+const CHANNEL_NAMES = ['exceptions', 'resources', 'async'];
+const DEFAULT_ENABLED = {
+    exceptions: true,
+    resources: false,
+    async: false,
+};
+function fail(message) {
+    throw new Error(`analyze config: ${message}`);
+}
+function legacyStripJsonc(text) {
+    let out = '';
+    let i = 0;
+    const n = text.length;
+    let inString = false;
+    let quote = '';
+    while (i < n) {
+        const ch = text[i];
+        const next = i + 1 < n ? text[i + 1] : '';
+        if (inString) {
+            out += ch;
+            if (ch === '\\') {
+                out += next;
+                i += 2;
+                continue;
+            }
+            if (ch === quote) {
+                inString = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            quote = ch;
+            out += ch;
+            i += 1;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            while (i < n && text[i] !== '\n') {
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i += 2;
+            while (i < n && !(text[i] === '*' && text[i + 1] === '/')) {
+                i += 1;
+            }
+            i += 2;
+            continue;
+        }
+        out += ch;
+        i += 1;
+    }
+    return out.replace(/,(\s*[}\]])/g, '$1');
+}
+void legacyStripJsonc;
+function asStringArray(value, field) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) || value.some((v) => typeof v !== 'string')) {
+        fail(`"${field}" must be an array of strings`);
+    }
+    return value;
+}
+function parseHandlerBoundaries(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        fail(`"handlerBoundaries" must be an array`);
+    }
+    return value.map((raw, index) => {
+        if (typeof raw !== 'object' || raw === null) {
+            fail(`handlerBoundaries[${index}] must be an object`);
+        }
+        const entry = raw;
+        if (typeof entry['callee'] !== 'string') {
+            fail(`handlerBoundaries[${index}].callee must be a string`);
+        }
+        const callbackArgs = entry['callbackArgs'];
+        if (!Array.isArray(callbackArgs) ||
+            callbackArgs.some((v) => typeof v !== 'number' || !Number.isInteger(v))) {
+            fail(`handlerBoundaries[${index}].callbackArgs must be an array of integers`);
+        }
+        return {
+            callee: entry['callee'],
+            callbackArgs: callbackArgs,
+        };
+    });
+}
+function parseSinks(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        fail(`"sinks" must be an array`);
+    }
+    return value.map((raw, index) => {
+        if (typeof raw !== 'object' || raw === null) {
+            fail(`sinks[${index}] must be an object`);
+        }
+        const entry = raw;
+        if (typeof entry['callee'] !== 'string') {
+            fail(`sinks[${index}].callee must be a string`);
+        }
+        let absorbs;
+        if (entry['absorbs'] !== undefined) {
+            absorbs = asStringArray(entry['absorbs'], `sinks[${index}].absorbs`);
+        }
+        return { callee: entry['callee'], absorbs };
+    });
+}
+function parseDispatch(value, channel) {
+    if (value === undefined) {
+        return 'optimist';
+    }
+    if (value !== 'optimist' && value !== 'pessimist') {
+        fail(`channels.${channel}.dispatch must be "optimist" or "pessimist"`);
+    }
+    return value;
+}
+function parseChannels(value) {
+    const channels = {};
+    const raw = value === undefined ? {} : value;
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        fail(`"channels" must be an object`);
+    }
+    for (const key of Object.keys(raw)) {
+        if (!CHANNEL_NAMES.includes(key)) {
+            fail(`unknown channel "${key}" (known: ${CHANNEL_NAMES.join(', ')})`);
+        }
+    }
+    for (const name of CHANNEL_NAMES) {
+        const entry = (raw[name] ?? {});
+        if (typeof entry !== 'object' ||
+            entry === null ||
+            Array.isArray(entry)) {
+            fail(`channels.${name} must be an object`);
+        }
+        const enabled = entry['enabled'] === undefined
+            ? DEFAULT_ENABLED[name]
+            : entry['enabled'];
+        if (typeof enabled !== 'boolean') {
+            fail(`channels.${name}.enabled must be a boolean`);
+        }
+        const { enabled: _e, dispatch: _d, ...options } = entry;
+        channels[name] = {
+            enabled,
+            dispatch: parseDispatch(entry['dispatch'], name),
+            options,
+        };
+    }
+    return channels;
+}
+function normalizeConfig(raw, projectRoot) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        fail(`root must be a JSON object`);
+    }
+    const tsconfig = raw.tsconfig === undefined ? 'tsconfig.json' : raw.tsconfig;
+    if (typeof tsconfig !== 'string') {
+        fail(`"tsconfig" must be a string`);
+    }
+    return {
+        projectRoot,
+        tsconfigPath: NodePath.resolve(projectRoot, tsconfig),
+        entryPoints: asStringArray(raw.entryPoints, 'entryPoints'),
+        handlerBoundaries: parseHandlerBoundaries(raw.handlerBoundaries),
+        sinks: parseSinks(raw.sinks),
+        presets: asStringArray(raw.presets, 'presets'),
+        overlays: asStringArray(raw.overlays, 'overlays').map((p) => NodePath.resolve(projectRoot, p)),
+        channels: parseChannels(raw.channels),
+        failOnFindings: raw.failOnFindings === true,
+        severity: raw.severity === 'warn' || raw.severity === 'warning'
+            ? 'warning'
+            : 'error',
+    };
+}
+function parseConfig(text, projectRoot) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripJsonc(text));
+    }
+    catch (error) {
+        fail(`invalid JSONC: ${error.message}`);
+    }
+    return normalizeConfig(parsed, projectRoot);
+}
+function configFromObject(raw, projectRoot) {
+    return normalizeConfig(raw, projectRoot);
+}
+function loadConfigFromTsconfig(tsconfigPath) {
+    const resolved = NodePath.resolve(tsconfigPath);
+    const plugins = readPlugins(resolved) ?? [];
+    const entry = plugins.find((p) => p !== null && typeof p === 'object' && p.name === 'ts-probe');
+    if (!entry) {
+        return undefined;
+    }
+    return {
+        ...configFromObject(entry, NodePath.dirname(resolved)),
+        tsconfigPath: resolved,
+    };
+}
+export { configFromObject, loadConfigFromTsconfig, parseConfig };

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

@@ -0,0 +1,6 @@
+import type { Analysis, Channel, Diagnostic, Dispatch, SummaryStore } from './types.js';
+declare function runChannel<V>(analysis: Analysis, channel: Channel<V>, dispatch: Dispatch, channelConfig: unknown, peers: ReadonlyMap<string, SummaryStore<unknown>>): {
+    store: SummaryStore<V>;
+    diagnostics: Diagnostic[];
+};
+export { runChannel };