@esportsplus/typescript 0.29.6 → 0.31.1

package/build/lsp/workspace.d.ts

@@ -0,0 +1,14 @@
+import type { AnalyzeResult } from '../probe/kernel/analyze.js';
+import type { AnalyzeConfig } from '../probe/kernel/types.js';
+declare class AnalyzeWorkspace {
+    private api;
+    private configPath;
+    private snapshot;
+    config: AnalyzeConfig | undefined;
+    constructor(tsconfigPath: string);
+    reloadConfig(): void;
+    refresh(changed: ReadonlyArray<string>): void;
+    analyze(): AnalyzeResult | undefined;
+    dispose(): void;
+}
+export { AnalyzeWorkspace };

package/build/lsp/workspace.js

@@ -0,0 +1,46 @@
+import * as NodePath from 'node:path';
+import { analyzeProgram } from '../probe/kernel/analyze.js';
+import { loadConfigFromTsconfig } from '../probe/kernel/config.js';
+import { open } from '../compiler/language-service.js';
+class AnalyzeWorkspace {
+    api;
+    configPath;
+    snapshot;
+    config;
+    constructor(tsconfigPath) {
+        this.configPath = NodePath.resolve(tsconfigPath);
+        this.config = loadConfigFromTsconfig(this.configPath);
+        let opened = open(this.configPath);
+        this.api = opened.api;
+        this.snapshot = opened.snapshot;
+    }
+    reloadConfig() {
+        this.config = loadConfigFromTsconfig(this.configPath);
+    }
+    refresh(changed) {
+        let previous = this.snapshot;
+        this.snapshot = this.api.updateSnapshot(changed.length === 0
+            ? { fileChanges: { invalidateAll: true } }
+            : { fileChanges: { changed: changed.map((fileName) => NodePath.resolve(fileName)) } });
+        if (previous && !previous.isDisposed()) {
+            previous.dispose();
+        }
+    }
+    analyze() {
+        if (!this.config || !this.snapshot) {
+            return undefined;
+        }
+        let project = this.snapshot.getProject(this.configPath);
+        if (!project) {
+            return undefined;
+        }
+        return analyzeProgram(project.program, project.checker, this.config);
+    }
+    dispose() {
+        if (this.snapshot && !this.snapshot.isDisposed()) {
+            this.snapshot.dispose();
+        }
+        this.api.close();
+    }
+}
+export { AnalyzeWorkspace };

package/build/probe/adapter.d.ts

@@ -0,0 +1,14 @@
+export * from 'typescript/unstable/ast';
+export * from 'typescript/unstable/ast/is';
+export * from 'typescript/unstable/sync';
+export { ModifierFlags } from 'typescript/unstable/sync';
+import { type Node, type SourceFile } from 'typescript/unstable/ast';
+import { type Checker, type Program, type Symbol, type Type } from 'typescript/unstable/sync';
+export type TypeChecker = Checker;
+declare function forEachChild<T>(node: Node, cb: (child: Node) => T | undefined): T | undefined;
+declare function isClassLike(node: Node): boolean;
+declare function getSourceFiles(program: Program): SourceFile[];
+declare function symbolDeclarations(symbol: Symbol): Node[];
+declare function symbolValueDeclaration(symbol: Symbol): Node | undefined;
+declare function unionTypes(type: Type): readonly Type[] | undefined;
+export { forEachChild, getSourceFiles, isClassLike, symbolDeclarations, symbolValueDeclaration, unionTypes };

package/build/probe/adapter.js

@@ -0,0 +1,42 @@
+export * from 'typescript/unstable/ast';
+export * from 'typescript/unstable/ast/is';
+export * from 'typescript/unstable/sync';
+export { ModifierFlags } from 'typescript/unstable/sync';
+import { SyntaxKind, } from 'typescript/unstable/ast';
+import { TypeFlags, } from 'typescript/unstable/sync';
+function forEachChild(node, cb) {
+    return node.forEachChild(cb);
+}
+function isClassLike(node) {
+    return (node.kind === SyntaxKind.ClassDeclaration ||
+        node.kind === SyntaxKind.ClassExpression);
+}
+function getSourceFiles(program) {
+    const out = [];
+    for (const name of program.getSourceFileNames()) {
+        const sf = program.getSourceFile(name);
+        if (sf) {
+            out.push(sf);
+        }
+    }
+    return out;
+}
+function symbolDeclarations(symbol) {
+    const out = [];
+    for (const handle of symbol.declarations ?? []) {
+        const node = handle.resolve();
+        if (node) {
+            out.push(node);
+        }
+    }
+    return out;
+}
+function symbolValueDeclaration(symbol) {
+    return symbol.valueDeclaration?.resolve();
+}
+function unionTypes(type) {
+    return (type.flags & TypeFlags.Union) !== 0
+        ? type.getTypes()
+        : undefined;
+}
+export { forEachChild, getSourceFiles, isClassLike, symbolDeclarations, symbolValueDeclaration, unionTypes };

package/build/probe/async/channel.d.ts

@@ -0,0 +1,4 @@
+import type { Channel } from '../kernel/types.js';
+import { type AsyncValue } from './value.js';
+declare function createAsyncChannel(channelConfig: unknown): Channel<AsyncValue>;
+export { createAsyncChannel };

package/build/probe/async/channel.js

@@ -0,0 +1,560 @@
+import * as ts from '../../probe/adapter.js';
+import { bodyOf, calleeSelectors, unwrap } from '../kernel/ast.js';
+import { isFunctionLike, locationOf } from '../kernel/ids.js';
+import { bottom, equals, promise, widen } from './value.js';
+const AGGREGATORS = new Set(['all', 'allSettled', 'race', 'any']);
+const CHAIN_METHODS = new Set(['catch', 'finally', 'then']);
+const OPAQUE_SINKS = new Set(['add', 'push', 'set', 'unshift']);
+const UNBOUNDED_TUPLE_FLAGS = 12;
+function fail(message) {
+    throw new Error(`async: ${message}`);
+}
+function parseOptions(raw) {
+    const obj = typeof raw === 'object' && raw !== null
+        ? raw
+        : {};
+    let fanOut = 'warn';
+    if (obj['fanOut'] !== undefined) {
+        if (obj['fanOut'] !== 'off' &&
+            obj['fanOut'] !== 'warn' &&
+            obj['fanOut'] !== 'error') {
+            fail(`"fanOut" must be "off", "warn", or "error"`);
+        }
+        fanOut = obj['fanOut'];
+    }
+    let allow = 16;
+    if (obj['fanOutAllowLiteralUpTo'] !== undefined) {
+        const n = obj['fanOutAllowLiteralUpTo'];
+        if (typeof n !== 'number' || !Number.isInteger(n) || n < 0) {
+            fail(`"fanOutAllowLiteralUpTo" must be a non-negative integer`);
+        }
+        allow = n;
+    }
+    let poolFunctions = [];
+    if (obj['poolFunctions'] !== undefined) {
+        const p = obj['poolFunctions'];
+        if (!Array.isArray(p) || p.some((v) => typeof v !== 'string')) {
+            fail(`"poolFunctions" must be an array of strings`);
+        }
+        poolFunctions = p;
+    }
+    return { fanOut, fanOutAllowLiteralUpTo: allow, poolFunctions };
+}
+function constituents(type) {
+    return ts.unionTypes(type) ?? [type];
+}
+function isPromiseType(checker, type) {
+    if (!type) {
+        return false;
+    }
+    for (const c of constituents(type)) {
+        const sym = c.getSymbol() ?? c.getAliasSymbol();
+        if (sym && sym.name === 'Promise') {
+            return true;
+        }
+        const apparent = checker.getApparentType(c) ?? c;
+        if (checker.getPropertyOfType(apparent, 'then')) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasAsyncModifier(node) {
+    const mods = node.modifiers;
+    return mods?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+}
+function enclosingAsync(node) {
+    let p = node.parent;
+    while (p) {
+        if (isFunctionLike(p)) {
+            return hasAsyncModifier(p);
+        }
+        p = p.parent;
+    }
+    return false;
+}
+function returnsPromise(checker, node) {
+    if (hasAsyncModifier(node)) {
+        return true;
+    }
+    const fnType = checker.getTypeAtLocation(node);
+    if (!fnType) {
+        return false;
+    }
+    const sig = checker.getSignaturesOfType(fnType, ts.SignatureKind.Call)[0];
+    if (!sig) {
+        return false;
+    }
+    return isPromiseType(checker, checker.getReturnTypeOfSignature(sig));
+}
+function producesPromise(env, call) {
+    const res = env.resolveCall(call);
+    if (res.targets.length > 0) {
+        return res.targets.some((t) => env.summaryOf(t).value.returnsPromise);
+    }
+    return isPromiseType(env.checker, env.checker.getTypeAtLocation(call));
+}
+function aggregatorOf(call) {
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) ||
+        !ts.isIdentifier(callee.expression)) {
+        return undefined;
+    }
+    if (callee.expression.text !== 'Promise' ||
+        !AGGREGATORS.has(callee.name.text)) {
+        return undefined;
+    }
+    return callee.name.text;
+}
+function isAggregatorCall(node) {
+    return ts.isCallExpression(node) && aggregatorOf(node) !== undefined;
+}
+function chainRoot(call) {
+    let cur = call;
+    while (ts.isPropertyAccessExpression(cur.expression) &&
+        CHAIN_METHODS.has(cur.expression.name.text)) {
+        const receiver = cur.expression.expression;
+        if (!ts.isCallExpression(receiver) && !ts.isNewExpression(receiver)) {
+            break;
+        }
+        cur = receiver;
+    }
+    return cur;
+}
+function calleeText(node) {
+    const call = chainRoot(node);
+    const callee = call.expression;
+    if (ts.isIdentifier(callee)) {
+        return callee.text;
+    }
+    if (ts.isPropertyAccessExpression(callee)) {
+        return callee.name.text;
+    }
+    return callee.getText(callee.getSourceFile());
+}
+function isChainContinuation(call) {
+    const parent = call.parent;
+    if (!parent ||
+        !ts.isPropertyAccessExpression(parent) ||
+        parent.expression !== call) {
+        return false;
+    }
+    return (CHAIN_METHODS.has(parent.name.text) &&
+        ts.isCallExpression(parent.parent) &&
+        parent.parent.expression === parent);
+}
+function chainHandlesRejection(call) {
+    let cur = call;
+    while (ts.isCallExpression(cur) &&
+        ts.isPropertyAccessExpression(cur.expression)) {
+        const member = cur.expression.name.text;
+        if (member === 'catch' && cur.arguments.length >= 1) {
+            return true;
+        }
+        if (member === 'then' && cur.arguments.length >= 2) {
+            return true;
+        }
+        cur = cur.expression.expression;
+    }
+    return false;
+}
+function isValueTransparent(node, child) {
+    if (ts.isParenthesizedExpression(node)) {
+        return true;
+    }
+    if (ts.isConditionalExpression(node)) {
+        return node.whenTrue === child || node.whenFalse === child;
+    }
+    if (ts.isBinaryExpression(node) && node.right === child) {
+        const k = node.operatorToken.kind;
+        return (k === ts.SyntaxKind.AmpersandAmpersandToken ||
+            k === ts.SyntaxKind.BarBarToken ||
+            k === ts.SyntaxKind.QuestionQuestionToken ||
+            k === ts.SyntaxKind.CommaToken);
+    }
+    return false;
+}
+function classifyOwnership(node) {
+    let child = node;
+    let parent = node.parent;
+    while (parent && isValueTransparent(parent, child)) {
+        child = parent;
+        parent = parent.parent;
+    }
+    if (!parent) {
+        return 'opaque';
+    }
+    if (ts.isAwaitExpression(parent) || ts.isVoidExpression(parent)) {
+        return 'owned';
+    }
+    if (ts.isReturnStatement(parent) || ts.isYieldExpression(parent)) {
+        return 'owned';
+    }
+    if (ts.isArrowFunction(parent) && parent.body === child) {
+        return 'owned';
+    }
+    if (ts.isVariableDeclaration(parent) && parent.initializer === child) {
+        return 'owned';
+    }
+    if (ts.isPropertyDeclaration(parent) && parent.initializer === child) {
+        return 'owned';
+    }
+    if (ts.isBinaryExpression(parent) &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        parent.right === child) {
+        return 'owned';
+    }
+    if (ts.isExpressionStatement(parent)) {
+        return 'orphan';
+    }
+    if (ts.isCallExpression(parent) || ts.isNewExpression(parent)) {
+        if (isAggregatorCall(parent)) {
+            return 'owned';
+        }
+        const callee = parent.expression;
+        if (ts.isPropertyAccessExpression(callee) &&
+            OPAQUE_SINKS.has(callee.name.text)) {
+            return 'opaque';
+        }
+        return 'owned';
+    }
+    if (ts.isArrayLiteralExpression(parent)) {
+        const gp = parent.parent;
+        if (gp && isAggregatorCall(gp)) {
+            return 'owned';
+        }
+        return 'opaque';
+    }
+    return 'opaque';
+}
+function isBoundedInput(env, arg) {
+    const e = unwrap(arg);
+    if (ts.isArrayLiteralExpression(e)) {
+        if (e.elements.some((el) => ts.isSpreadElement(el))) {
+            return false;
+        }
+        return e.elements.length <= env.options.fanOutAllowLiteralUpTo;
+    }
+    const type = env.checker.getTypeAtLocation(e);
+    if (type && type.isTupleType()) {
+        const flags = type.elementFlags ??
+            [];
+        if (flags.some((f) => (f & UNBOUNDED_TUPLE_FLAGS) !== 0)) {
+            return false;
+        }
+        const len = type.fixedLength;
+        return (typeof len === 'number' && len <= env.options.fanOutAllowLiteralUpTo);
+    }
+    return false;
+}
+function moduleMatches(env, call, pkg) {
+    let sym = env.checker.getSymbolAtLocation(call.expression);
+    if (sym && sym.flags & ts.SymbolFlags.Alias) {
+        sym = env.checker.getAliasedSymbol(sym);
+    }
+    if (!sym) {
+        return false;
+    }
+    for (const decl of ts.symbolDeclarations(sym)) {
+        const path = decl.getSourceFile().fileName.replace(/\\/g, '/');
+        if (path.includes(`node_modules/${pkg}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+function poolMatches(env, call) {
+    const names = calleeSelectors(call.expression);
+    for (const sel of env.options.poolFunctions) {
+        const hash = sel.indexOf('#');
+        if (hash >= 0) {
+            const obj = sel.slice(0, hash);
+            const method = sel.slice(hash + 1);
+            if (names.has(method) ||
+                names.has(`${obj}.${method}`) ||
+                names.has(`${obj}#${method}`)) {
+                return true;
+            }
+            continue;
+        }
+        if (names.has(sel) || moduleMatches(env, call, sel)) {
+            return true;
+        }
+    }
+    return false;
+}
+function routedThroughPool(env, arg) {
+    let found = false;
+    const visit = (n) => {
+        if (found) {
+            return;
+        }
+        if (ts.isCallExpression(n) && poolMatches(env, n)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(arg);
+    return found;
+}
+function isAbortSignalType(type) {
+    if (!type) {
+        return false;
+    }
+    for (const c of constituents(type)) {
+        const sym = c.getSymbol() ?? c.getAliasSymbol();
+        if (sym && sym.name === 'AbortSignal') {
+            return true;
+        }
+    }
+    return false;
+}
+function collectSignalNames(checker, name, out) {
+    if (ts.isIdentifier(name)) {
+        if (isAbortSignalType(checker.getTypeAtLocation(name))) {
+            out.add(name.text);
+        }
+        return;
+    }
+    if (ts.isObjectBindingPattern(name)) {
+        for (const el of name.elements) {
+            if (el.name) {
+                collectSignalNames(checker, el.name, out);
+            }
+        }
+    }
+}
+function heldSignalNames(checker, node) {
+    const out = new Set();
+    const params = node
+        .parameters ?? [];
+    for (const p of params) {
+        collectSignalNames(checker, p.name, out);
+    }
+    return out;
+}
+function overlayCancellable(env, call) {
+    const entry = env.resolveCall(call).overlay?.entry;
+    return entry?.cancellable === true;
+}
+function callRequiresSignal(env, call) {
+    if (overlayCancellable(env, call)) {
+        return true;
+    }
+    return env
+        .resolveCall(call)
+        .targets.some((t) => env.heldSignalNames(t).size > 0);
+}
+function isAwaited(call) {
+    let child = call;
+    let parent = call.parent;
+    while (parent &&
+        (ts.isParenthesizedExpression(parent) ||
+            ts.isAsExpression(parent) ||
+            ts.isNonNullExpression(parent)) &&
+        parent.expression === child) {
+        child = parent;
+        parent = parent.parent;
+    }
+    return parent !== undefined && ts.isAwaitExpression(parent);
+}
+function forwardsSignal(call, held) {
+    let found = false;
+    const visit = (n) => {
+        if (found) {
+            return;
+        }
+        if (ts.isIdentifier(n) && held.has(n.text)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    for (const arg of call.arguments) {
+        visit(arg);
+    }
+    return found;
+}
+function orphanFixes(call) {
+    const sf = call.getSourceFile();
+    const pos = call.getStart(sf);
+    const fixes = [
+        {
+            title: 'Ignore the result with `void`',
+            edits: [{ fileName: sf.fileName, pos, end: pos, newText: 'void ' }],
+        },
+    ];
+    if (enclosingAsync(call)) {
+        fixes.push({
+            title: 'Await the promise',
+            edits: [
+                { fileName: sf.fileName, pos, end: pos, newText: 'await ' },
+            ],
+        });
+    }
+    return fixes;
+}
+function orphanDiagnostic(call) {
+    return {
+        channel: 'async',
+        message: `result of \`${calleeText(call)}()\` is neither awaited nor voided — rejections will be unhandled`,
+        location: locationOf(call, call.getSourceFile()),
+        related: [],
+        fixes: orphanFixes(call),
+    };
+}
+function degradedDiagnostic(call) {
+    return {
+        channel: 'async',
+        message: `result of \`${calleeText(call)}()\` flows into an untracked structure — ownership cannot be verified`,
+        location: locationOf(call, call.getSourceFile()),
+        related: [],
+    };
+}
+function fanOutDiagnostic(call, aggregator) {
+    return {
+        channel: 'async',
+        message: `unbounded fan-out: \`Promise.${aggregator}\` over a dynamically-sized input — cap concurrency with a pool or bound the input`,
+        location: locationOf(call, call.getSourceFile()),
+        related: [],
+    };
+}
+function signalFix(env, call) {
+    if (!overlayCancellable(env, call)) {
+        return undefined;
+    }
+    const name = env.held.values().next().value;
+    if (!name) {
+        return undefined;
+    }
+    const sf = call.getSourceFile();
+    const prop = name === 'signal' ? 'signal' : `signal: ${name}`;
+    const last = call.arguments.length > 0
+        ? call.arguments[call.arguments.length - 1]
+        : undefined;
+    if (last && ts.isObjectLiteralExpression(last)) {
+        const at = last.getStart(sf) + 1;
+        const newText = last.properties.length > 0 ? ` ${prop},` : ` ${prop} `;
+        return [
+            {
+                title: 'Forward the AbortSignal',
+                edits: [{ fileName: sf.fileName, pos: at, end: at, newText }],
+            },
+        ];
+    }
+    const close = call.getEnd() - 1;
+    const newText = call.arguments.length > 0 ? `, { ${prop} }` : `{ ${prop} }`;
+    return [
+        {
+            title: 'Forward the AbortSignal',
+            edits: [{ fileName: sf.fileName, pos: close, end: close, newText }],
+        },
+    ];
+}
+function cancellationDiagnostic(call, fixes) {
+    return {
+        channel: 'async',
+        message: `\`${calleeText(call)}()\` is awaited without the AbortSignal this function holds — the work cannot be cancelled`,
+        location: locationOf(call, call.getSourceFile()),
+        related: [],
+        fixes,
+    };
+}
+function checkFanOut(env, call, out) {
+    if (env.options.fanOut === 'off') {
+        return;
+    }
+    const aggregator = aggregatorOf(call);
+    if (!aggregator) {
+        return;
+    }
+    const arg = call.arguments[0];
+    if (!arg || isBoundedInput(env, arg) || routedThroughPool(env, arg)) {
+        return;
+    }
+    out.push(fanOutDiagnostic(call, aggregator));
+}
+function checkOwnership(env, call, out) {
+    if (isChainContinuation(call) || !producesPromise(env, call)) {
+        return;
+    }
+    const ownership = classifyOwnership(call);
+    if (ownership === 'orphan') {
+        if (!chainHandlesRejection(call)) {
+            out.push(orphanDiagnostic(call));
+        }
+    }
+    else if (ownership === 'opaque' && env.dispatch === 'pessimist') {
+        out.push(degradedDiagnostic(call));
+    }
+}
+function checkCancellation(env, call, out) {
+    if (env.held.size === 0 ||
+        !callRequiresSignal(env, call) ||
+        !isAwaited(call)) {
+        return;
+    }
+    if (!forwardsSignal(call, env.held)) {
+        out.push(cancellationDiagnostic(call, signalFix(env, call)));
+    }
+}
+function walk(env, body, out) {
+    const visit = (n) => {
+        if (isFunctionLike(n)) {
+            return;
+        }
+        if (ts.isCallExpression(n)) {
+            checkFanOut(env, n, out);
+            checkCancellation(env, n, out);
+        }
+        if (ts.isCallExpression(n) || ts.isNewExpression(n)) {
+            checkOwnership(env, n, out);
+        }
+        ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(body, visit);
+}
+function createAsyncChannel(channelConfig) {
+    const options = parseOptions(channelConfig);
+    const heldByFunction = new Map();
+    const getHeldSignalNames = (checker, fn) => {
+        let held = heldByFunction.get(fn);
+        if (!held) {
+            held = heldSignalNames(checker, fn.node);
+            heldByFunction.set(fn, held);
+        }
+        return held;
+    };
+    return {
+        name: 'async',
+        bottom,
+        equals,
+        widen,
+        transfer(ctx) {
+            const value = returnsPromise(ctx.checker, ctx.fn.node)
+                ? promise()
+                : bottom();
+            return { value, fromCallbacks: new Set() };
+        },
+        diagnose(ctx) {
+            const body = bodyOf(ctx.fn.node);
+            if (!body) {
+                return [];
+            }
+            const env = {
+                checker: ctx.checker,
+                dispatch: ctx.dispatch,
+                options,
+                summaryOf: ctx.summaryOf,
+                resolveCall: ctx.resolveCall,
+                heldSignalNames: (fn) => getHeldSignalNames(ctx.checker, fn),
+                held: getHeldSignalNames(ctx.checker, ctx.fn),
+            };
+            const out = [];
+            walk(env, body, out);
+            return out;
+        },
+    };
+}
+export { createAsyncChannel };

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

@@ -0,0 +1,9 @@
+type AsyncValue = {
+    readonly returnsPromise: boolean;
+};
+declare function bottom(): AsyncValue;
+declare function promise(): AsyncValue;
+declare function join(a: AsyncValue, b: AsyncValue): AsyncValue;
+declare function equals(a: AsyncValue, b: AsyncValue): boolean;
+declare function widen(_prev: AsyncValue, next: AsyncValue, _round: number): AsyncValue;
+export { bottom, equals, join, promise, type AsyncValue, widen };