@esportsplus/typescript 0.31.0 → 0.32.0

package/build/probe/resources/channel.js

@@ -0,0 +1,798 @@
+import * as ts from '../adapter.js';
+import { overlayThrows } from '../exceptions/channel.js';
+import { bodyOf, calleeSelectors, paramSymbols, unwrap } from '../kernel/ast.js';
+import { isEmpty } from '../exceptions/value.js';
+import { isFunctionLike, locationOf } from '../kernel/ids.js';
+import { bottom, equals, fromParams, widen, } from './value.js';
+const FREE_RELEASERS = new Set([
+    'clearImmediate',
+    'clearInterval',
+    'clearTimeout',
+]);
+const DISPOSE_METHODS = new Set([
+    'close',
+    'destroy',
+    'disconnect',
+    'dispose',
+    'release',
+    'unsubscribe',
+]);
+const OPAQUE_METHODS = new Set([
+    'add',
+    'append',
+    'enqueue',
+    'push',
+    'set',
+    'unshift',
+]);
+function refsSym(env, expr, sym) {
+    const e = unwrap(expr, { assertions: true, awaits: true });
+    if (!ts.isIdentifier(e)) {
+        return false;
+    }
+    return env.checker.getSymbolAtLocation(e) === sym;
+}
+function containsMatch(node, pred) {
+    let found = false;
+    const rec = (n) => {
+        if (found) {
+            return;
+        }
+        if (n !== node && isFunctionLike(n)) {
+            return;
+        }
+        if (pred(n)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(n, rec);
+    };
+    rec(node);
+    return found;
+}
+function isExitStatement(n) {
+    return (ts.isReturnStatement(n) ||
+        ts.isThrowStatement(n) ||
+        ts.isBreakStatement(n) ||
+        ts.isContinueStatement(n));
+}
+function isCallLike(n) {
+    return ts.isCallExpression(n) || ts.isNewExpression(n);
+}
+function callCanThrow(env, call) {
+    const res = env.resolveExceptions(call);
+    if (res.overlay) {
+        return overlayThrows(res.overlay.entry);
+    }
+    if (res.targets.length > 0) {
+        return res.targets.some((t) => env.peerThrows(t.id));
+    }
+    return res.unresolved && env.dispatch === 'pessimist';
+}
+function enclosingStatement(node) {
+    let n = node;
+    while (n.parent && !ts.isBlock(n.parent) && !ts.isSourceFile(n.parent)) {
+        n = n.parent;
+    }
+    return n;
+}
+function blockOf(stmt) {
+    return stmt.parent && ts.isBlock(stmt.parent) ? stmt.parent : undefined;
+}
+function isDisposableType(env, type) {
+    if (!type) {
+        return false;
+    }
+    for (const prop of env.checker.getPropertiesOfType(type)) {
+        if (prop.name.startsWith('__@dispose') ||
+            prop.name.startsWith('__@asyncDispose')) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasSyncDispose(env, type) {
+    if (!type) {
+        return false;
+    }
+    for (const prop of env.checker.getPropertiesOfType(type)) {
+        if (prop.name.startsWith('__@dispose')) {
+            return true;
+        }
+    }
+    return false;
+}
+function parsePairKey(raw) {
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const out = [];
+    for (const v of raw) {
+        if (typeof v === 'number' && Number.isInteger(v)) {
+            out.push(v);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+function acquireAt(env, call) {
+    const res = env.resolveCall(call);
+    if (res.overlay) {
+        const entry = res.overlay.entry;
+        if (entry.informational) {
+            return undefined;
+        }
+        if (typeof entry.acquires === 'string') {
+            const releasedBy = typeof entry.releasedBy === 'string'
+                ? entry.releasedBy
+                : undefined;
+            const pairKey = parsePairKey(entry.pairKey);
+            return {
+                kind: pairKey ? 'pair' : 'handle',
+                releasedBy,
+                pairKey,
+                label: entry.acquires,
+            };
+        }
+    }
+    if (isDisposableType(env, env.checker.getTypeAtLocation(call))) {
+        return {
+            kind: 'handle',
+            releasedBy: undefined,
+            pairKey: undefined,
+            label: 'Disposable',
+        };
+    }
+    return undefined;
+}
+function handleBinding(env, call) {
+    let p = call;
+    while (p.parent &&
+        (ts.isParenthesizedExpression(p.parent) ||
+            ts.isNonNullExpression(p.parent) ||
+            ts.isAsExpression(p.parent) ||
+            ts.isAwaitExpression(p.parent))) {
+        p = p.parent;
+    }
+    const decl = p.parent;
+    if (!decl ||
+        !ts.isVariableDeclaration(decl) ||
+        !ts.isIdentifier(decl.name)) {
+        return undefined;
+    }
+    const list = decl.parent;
+    if (list &&
+        ts.isVariableDeclarationList(list) &&
+        (list.flags & ts.NodeFlags.Using) !== 0) {
+        return { using: true };
+    }
+    const sym = env.checker.getSymbolAtLocation(decl.name);
+    return sym ? { using: false, sym } : undefined;
+}
+function isDischargeOf(env, expr, sym, acq) {
+    if (!ts.isCallExpression(expr)) {
+        return false;
+    }
+    const callee = expr.expression;
+    if (ts.isIdentifier(callee)) {
+        const freeName = acq?.releasedBy !== undefined && !acq.releasedBy.startsWith('#')
+            ? acq.releasedBy
+            : undefined;
+        const isFree = FREE_RELEASERS.has(callee.text) || callee.text === freeName;
+        if (!isFree) {
+            return false;
+        }
+        const arg = expr.arguments?.[0];
+        return arg ? refsSym(env, arg, sym) : false;
+    }
+    if (ts.isPropertyAccessExpression(callee)) {
+        if (!refsSym(env, callee.expression, sym)) {
+            return false;
+        }
+        const method = callee.name.text;
+        if (DISPOSE_METHODS.has(method)) {
+            return true;
+        }
+        return (acq?.releasedBy !== undefined &&
+            acq.releasedBy.startsWith('#') &&
+            acq.releasedBy.slice(1) === method);
+    }
+    if (ts.isElementAccessExpression(callee)) {
+        if (!refsSym(env, callee.expression, sym)) {
+            return false;
+        }
+        const argx = callee.argumentExpression;
+        return (argx !== undefined &&
+            ts.isPropertyAccessExpression(argx) &&
+            (argx.name.text === 'dispose' || argx.name.text === 'asyncDispose'));
+    }
+    return false;
+}
+function callOwnsArg(env, call, sym) {
+    const args = call.arguments ? Array.from(call.arguments) : [];
+    const indices = [];
+    args.forEach((arg, i) => {
+        if (refsSym(env, arg, sym)) {
+            indices.push(i);
+        }
+    });
+    if (indices.length === 0) {
+        return false;
+    }
+    const selectors = calleeSelectors(call.expression);
+    for (const own of env.ownership) {
+        if (selectors.has(own.callee) &&
+            own.params.some((p) => indices.includes(p))) {
+            return true;
+        }
+    }
+    const res = env.resolveCall(call);
+    const entry = (res.overlay?.entry ?? undefined);
+    if (entry && Array.isArray(entry.ownsParams)) {
+        for (const p of entry.ownsParams) {
+            if (typeof p === 'number' && indices.includes(p)) {
+                return true;
+            }
+        }
+    }
+    for (const target of res.targets) {
+        const owned = env.summaryOf(target).value.ownsParams;
+        for (const i of indices) {
+            if (owned.has(i)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isTransferExpr(env, expr, sym) {
+    if (ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        const target = expr.left;
+        if ((ts.isPropertyAccessExpression(target) ||
+            ts.isElementAccessExpression(target)) &&
+            refsSym(env, expr.right, sym)) {
+            return true;
+        }
+    }
+    if (ts.isCallExpression(expr) || ts.isNewExpression(expr)) {
+        return callOwnsArg(env, expr, sym);
+    }
+    return false;
+}
+function statementDischargesOrTransfers(env, s, sym, acq) {
+    if (ts.isReturnStatement(s)) {
+        if (!s.expression) {
+            return false;
+        }
+        return (refsSym(env, s.expression, sym) ||
+            isTransferExpr(env, s.expression, sym));
+    }
+    if (ts.isExpressionStatement(s)) {
+        return (isDischargeOf(env, s.expression, sym, acq) ||
+            isTransferExpr(env, s.expression, sym));
+    }
+    return false;
+}
+function finallyDischarges(env, sym, acq, declStmt, body) {
+    let found = false;
+    const rec = (n) => {
+        if (found) {
+            return;
+        }
+        if (n !== body && isFunctionLike(n)) {
+            return;
+        }
+        if (ts.isTryStatement(n) &&
+            n.finallyBlock &&
+            declStmt.getStart() < n.finallyBlock.getStart()) {
+            const discharged = containsMatch(n.finallyBlock, (m) => (ts.isCallExpression(m) || ts.isNewExpression(m)) &&
+                isDischargeOf(env, m, sym, acq));
+            if (discharged) {
+                found = true;
+                return;
+            }
+        }
+        ts.forEachChild(n, rec);
+    };
+    rec(body);
+    return found;
+}
+function firstGuaranteed(env, sym, acq, declStmt, block) {
+    const stmts = block.statements;
+    const idx = stmts.findIndex((s) => s === declStmt);
+    if (idx < 0) {
+        return false;
+    }
+    for (let i = idx + 1; i < stmts.length; i += 1) {
+        const s = stmts[i];
+        if (statementDischargesOrTransfers(env, s, sym, acq)) {
+            return true;
+        }
+        if (containsMatch(s, isExitStatement)) {
+            return false;
+        }
+        if (containsMatch(s, (n) => isCallLike(n) &&
+            callCanThrow(env, n))) {
+            return false;
+        }
+    }
+    return false;
+}
+function opaqueUseOf(env, sym, body) {
+    let hit;
+    const rec = (n) => {
+        if (hit) {
+            return;
+        }
+        if (n !== body && isFunctionLike(n)) {
+            return;
+        }
+        if (ts.isCallExpression(n) &&
+            ts.isPropertyAccessExpression(n.expression) &&
+            OPAQUE_METHODS.has(n.expression.name.text)) {
+            for (const arg of n.arguments ?? []) {
+                if (refsSym(env, arg, sym)) {
+                    hit = n;
+                    return;
+                }
+            }
+        }
+        if (ts.isBinaryExpression(n) &&
+            n.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isIdentifier(n.left) &&
+            refsSym(env, n.right, sym)) {
+            hit = n;
+            return;
+        }
+        if (ts.isVariableDeclaration(n) &&
+            n.initializer &&
+            refsSym(env, n.initializer, sym)) {
+            hit = n;
+            return;
+        }
+        ts.forEachChild(n, rec);
+    };
+    rec(body);
+    return hit;
+}
+function handleOutcome(env, acq, sym, declStmt, block, body) {
+    if (finallyDischarges(env, sym, acq, declStmt, body)) {
+        return 'safe';
+    }
+    if (firstGuaranteed(env, sym, acq, declStmt, block)) {
+        return 'safe';
+    }
+    if (opaqueUseOf(env, sym, body)) {
+        return 'degrade';
+    }
+    return 'leak';
+}
+function isReleaseCallForPair(node, acq, acquireCall) {
+    if (!ts.isCallExpression(node) || acq.releasedBy === undefined) {
+        return false;
+    }
+    const callee = node.expression;
+    const acqCallee = acquireCall.expression;
+    if (!ts.isPropertyAccessExpression(callee) ||
+        !ts.isPropertyAccessExpression(acqCallee)) {
+        return false;
+    }
+    if (callee.name.text !== acq.releasedBy) {
+        return false;
+    }
+    if (callee.expression.getText() !== acqCallee.expression.getText()) {
+        return false;
+    }
+    for (const i of acq.pairKey ?? []) {
+        const a = node.arguments?.[i];
+        const b = acquireCall.arguments?.[i];
+        if (!a || !b || a.getText() !== b.getText()) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasMatchingRelease(env, acquireCall, acq) {
+    const body = bodyOf(env.fn.node);
+    if (!body) {
+        return false;
+    }
+    return containsMatch(body, (n) => isReleaseCallForPair(n, acq, acquireCall));
+}
+function classDischargesField(cls, field, acq) {
+    const members = cls.members ?? [];
+    const refsThisField = (expr) => {
+        const e = unwrap(expr, { assertions: true, awaits: true });
+        return (ts.isPropertyAccessExpression(e) &&
+            e.expression.kind === ts.SyntaxKind.ThisKeyword &&
+            e.name.text === field);
+    };
+    const dischargesHere = (n) => {
+        if (!ts.isCallExpression(n)) {
+            return false;
+        }
+        const callee = n.expression;
+        if (ts.isIdentifier(callee)) {
+            const freeName = acq?.releasedBy !== undefined && !acq.releasedBy.startsWith('#')
+                ? acq.releasedBy
+                : undefined;
+            if (!FREE_RELEASERS.has(callee.text) && callee.text !== freeName) {
+                return false;
+            }
+            const arg = n.arguments?.[0];
+            return arg ? refsThisField(arg) : false;
+        }
+        if (ts.isPropertyAccessExpression(callee) &&
+            refsThisField(callee.expression)) {
+            const method = callee.name.text;
+            return (DISPOSE_METHODS.has(method) ||
+                (acq?.releasedBy !== undefined &&
+                    acq.releasedBy.startsWith('#') &&
+                    acq.releasedBy.slice(1) === method));
+        }
+        if (ts.isElementAccessExpression(callee) &&
+            refsThisField(callee.expression)) {
+            const argx = callee.argumentExpression;
+            return (argx !== undefined &&
+                ts.isPropertyAccessExpression(argx) &&
+                (argx.name.text === 'dispose' ||
+                    argx.name.text === 'asyncDispose'));
+        }
+        return false;
+    };
+    for (const member of members) {
+        const body = member.body;
+        if (body && containsMatch(body, dischargesHere)) {
+            return true;
+        }
+    }
+    return false;
+}
+function className(cls) {
+    const name = cls.name;
+    return name && ts.isIdentifier(name) ? name.text : '<anonymous>';
+}
+function classFieldAcquires(env, cls, ctorBody) {
+    const out = [];
+    const members = cls.members ?? [];
+    for (const member of members) {
+        if (ts.isPropertyDeclaration(member) &&
+            member.initializer &&
+            ts.isIdentifier(member.name)) {
+            const init = unwrap(member.initializer, {
+                assertions: true,
+                awaits: true,
+            });
+            if (ts.isCallExpression(init) || ts.isNewExpression(init)) {
+                const acq = acquireAt(env, init);
+                if (acq && acq.kind === 'handle') {
+                    out.push({ field: member.name.text, node: member, acq });
+                }
+            }
+        }
+    }
+    if (ctorBody) {
+        const rec = (n) => {
+            if (n !== ctorBody && isFunctionLike(n)) {
+                return;
+            }
+            if (ts.isBinaryExpression(n) &&
+                n.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                ts.isPropertyAccessExpression(n.left) &&
+                n.left.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                const rhs = unwrap(n.right, { assertions: true, awaits: true });
+                if (ts.isCallExpression(rhs) || ts.isNewExpression(rhs)) {
+                    const acq = acquireAt(env, rhs);
+                    if (acq && acq.kind === 'handle') {
+                        out.push({ field: n.left.name.text, node: n, acq });
+                    }
+                }
+            }
+            ts.forEachChild(n, rec);
+        };
+        rec(ctorBody);
+    }
+    return out;
+}
+function relatedPath(ctx) {
+    const related = [];
+    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 usingFix(env, call) {
+    if (!hasSyncDispose(env, env.checker.getTypeAtLocation(call))) {
+        return undefined;
+    }
+    let p = call;
+    while (p.parent &&
+        (ts.isParenthesizedExpression(p.parent) ||
+            ts.isNonNullExpression(p.parent) ||
+            ts.isAsExpression(p.parent) ||
+            ts.isAwaitExpression(p.parent))) {
+        p = p.parent;
+    }
+    const decl = p.parent;
+    if (!decl || !ts.isVariableDeclaration(decl)) {
+        return undefined;
+    }
+    const list = decl.parent;
+    if (!list ||
+        !ts.isVariableDeclarationList(list) ||
+        (list.flags & ts.NodeFlags.Using) !== 0) {
+        return undefined;
+    }
+    const sf = call.getSourceFile();
+    const start = list.getStart(sf);
+    const keyword = (list.flags & ts.NodeFlags.Let) !== 0
+        ? 'let'
+        : (list.flags & ts.NodeFlags.Const) !== 0
+            ? 'const'
+            : undefined;
+    if (!keyword || sf.text.slice(start, start + keyword.length) !== keyword) {
+        return undefined;
+    }
+    return {
+        title: 'Convert to `using`',
+        edits: [
+            {
+                fileName: sf.fileName,
+                pos: start,
+                end: start + keyword.length,
+                newText: 'using',
+            },
+        ],
+    };
+}
+function releaseText(env, acq, name, call) {
+    if (acq.releasedBy) {
+        return acq.releasedBy.startsWith('#')
+            ? `${name}.${acq.releasedBy.slice(1)}()`
+            : `${acq.releasedBy}(${name})`;
+    }
+    if (hasSyncDispose(env, env.checker.getTypeAtLocation(call))) {
+        return `${name}[Symbol.dispose]()`;
+    }
+    return undefined;
+}
+function tryFinallyFix(env, acq, sym, declStmt, block, call) {
+    const release = releaseText(env, acq, sym.name, call);
+    if (!release) {
+        return undefined;
+    }
+    const stmts = block.statements;
+    const idx = stmts.findIndex((s) => s === declStmt);
+    if (idx < 0 || idx + 1 >= stmts.length) {
+        return undefined;
+    }
+    const sf = call.getSourceFile();
+    const text = sf.text;
+    const first = stmts[idx + 1];
+    const last = stmts[stmts.length - 1];
+    const declStart = declStmt.getStart(sf);
+    let lineStart = first.getStart(sf);
+    let declLineStart = declStart;
+    while (lineStart > 0 && text[lineStart - 1] !== '\n') {
+        lineStart -= 1;
+    }
+    while (declLineStart > 0 && text[declLineStart - 1] !== '\n') {
+        declLineStart -= 1;
+    }
+    const base = text.slice(declLineStart, declStart);
+    const unit = '    ';
+    const regionEnd = last.getEnd();
+    const region = text
+        .slice(lineStart, regionEnd)
+        .split('\n')
+        .map((line) => (line.length > 0 ? unit + line : line))
+        .join('\n');
+    const replacement = `${base}try {\n${region}\n${base}}\n${base}finally {\n${base}${unit}${release};\n${base}}`;
+    return {
+        title: 'Wrap in try/finally',
+        edits: [
+            {
+                fileName: sf.fileName,
+                pos: lineStart,
+                end: regionEnd,
+                newText: replacement,
+            },
+        ],
+    };
+}
+function leakDiagnostic(ctx, node, acq, why, fixes) {
+    return {
+        channel: 'resources',
+        message: `\`${acq.label}\` resource can leak — ${why}`,
+        location: locationOf(node, node.getSourceFile()),
+        related: relatedPath(ctx),
+        fixes,
+    };
+}
+function parseOwnership(channelConfig) {
+    if (typeof channelConfig !== 'object' || channelConfig === null) {
+        return [];
+    }
+    const raw = channelConfig['ownership'];
+    if (raw === undefined) {
+        return [];
+    }
+    if (!Array.isArray(raw)) {
+        throw new Error('resources: "ownership" must be an array');
+    }
+    return raw.map((item, index) => {
+        if (typeof item !== 'object' || item === null) {
+            throw new Error(`resources: ownership[${index}] must be an object`);
+        }
+        const obj = item;
+        if (typeof obj['callee'] !== 'string') {
+            throw new Error(`resources: ownership[${index}].callee must be a string`);
+        }
+        const params = obj['params'];
+        if (!Array.isArray(params) ||
+            params.some((v) => typeof v !== 'number' || !Number.isInteger(v))) {
+            throw new Error(`resources: ownership[${index}].params must be an array of integers`);
+        }
+        return {
+            callee: obj['callee'],
+            params: params,
+        };
+    });
+}
+function makeEnv(checker, dispatch, fn, ownership, summaryOf, resolveCall, resolveCallFor, peerSummaryValue, logDegrade) {
+    const symbols = paramSymbols(checker, fn.node);
+    const resolveExceptions = (call) => resolveCallFor('exceptions', call);
+    const peerThrows = (fnId) => {
+        const value = peerSummaryValue('exceptions', fnId);
+        return value !== undefined && !isEmpty(value);
+    };
+    return {
+        checker,
+        dispatch,
+        fn,
+        ownership,
+        summaryOf,
+        resolveCall,
+        resolveExceptions,
+        peerThrows,
+        logDegrade,
+        paramSymbols: symbols,
+    };
+}
+function ownsParam(env, sym, body) {
+    return containsMatch(body, (n) => {
+        if (ts.isCallExpression(n) || ts.isNewExpression(n)) {
+            if (ts.isCallExpression(n) &&
+                isDischargeOf(env, n, sym, undefined)) {
+                return true;
+            }
+            return isTransferExpr(env, n, sym);
+        }
+        if (ts.isBinaryExpression(n)) {
+            return isTransferExpr(env, n, sym);
+        }
+        return false;
+    });
+}
+function computeOwnership(env) {
+    const body = bodyOf(env.fn.node);
+    const owned = new Set();
+    if (!body) {
+        return owned;
+    }
+    for (const [sym, index] of env.paramSymbols) {
+        if (ownsParam(env, sym, body)) {
+            owned.add(index);
+        }
+    }
+    return owned;
+}
+function diagnoseAcquire(env, ctx, call, acq, out) {
+    if (acq.kind === 'pair') {
+        if (!hasMatchingRelease(env, call, acq)) {
+            out.push(leakDiagnostic(ctx, call, acq, `no matching \`${acq.releasedBy ?? 'release'}\` on every path`));
+        }
+        return;
+    }
+    const binding = handleBinding(env, call);
+    if (binding && binding.using) {
+        return;
+    }
+    if (binding && !binding.using) {
+        const declStmt = enclosingStatement(call);
+        const block = blockOf(declStmt);
+        const body = bodyOf(env.fn.node);
+        if (!block || !body) {
+            return;
+        }
+        const outcome = handleOutcome(env, acq, binding.sym, declStmt, block, body);
+        if (outcome === 'leak') {
+            const fixes = [];
+            const asUsing = usingFix(env, call);
+            const wrapped = tryFinallyFix(env, acq, binding.sym, declStmt, block, call);
+            if (asUsing) {
+                fixes.push(asUsing);
+            }
+            if (wrapped) {
+                fixes.push(wrapped);
+            }
+            out.push(leakDiagnostic(ctx, call, acq, 'no release, transfer, or `using` on every path', fixes.length > 0 ? fixes : undefined));
+        }
+        else if (outcome === 'degrade') {
+            env.logDegrade(`${acq.label} at ${env.fn.fileName}:${call.getStart()} flows to an opaque sink`);
+            if (env.dispatch === 'pessimist') {
+                out.push({
+                    channel: 'resources',
+                    message: `\`${acq.label}\` resource becomes untrackable — it flows to an opaque sink and release cannot be verified`,
+                    location: locationOf(call, call.getSourceFile()),
+                    related: relatedPath(ctx),
+                });
+            }
+        }
+        return;
+    }
+}
+function diagnoseClassFields(env, ctx, out) {
+    if (!ts.isConstructorDeclaration(env.fn.node)) {
+        return;
+    }
+    const cls = env.fn.node.parent;
+    if (!ts.isClassLike(cls)) {
+        return;
+    }
+    const ctorBody = bodyOf(env.fn.node);
+    for (const stored of classFieldAcquires(env, cls, ctorBody)) {
+        if (classDischargesField(cls, stored.field, stored.acq)) {
+            continue;
+        }
+        out.push({
+            channel: 'resources',
+            message: `\`${stored.acq.label}\` stored on \`this.${stored.field}\` can leak — class \`${className(cls)}\` has no release method that discharges it`,
+            location: locationOf(stored.node, stored.node.getSourceFile()),
+            related: relatedPath(ctx),
+        });
+    }
+}
+const createResourcesChannel = (channelConfig, onDegrade = () => { }) => {
+    const ownership = parseOwnership(channelConfig);
+    return {
+        name: 'resources',
+        dependsOn: ['exceptions'],
+        bottom,
+        equals,
+        widen,
+        transfer(ctx) {
+            const env = makeEnv(ctx.checker, ctx.dispatch, ctx.fn, ownership, ctx.summaryOf, ctx.resolveCall, ctx.resolveCallFor, ctx.peerSummaryValue, onDegrade);
+            return {
+                value: fromParams(computeOwnership(env)),
+                fromCallbacks: new Set(),
+            };
+        },
+        diagnose(ctx) {
+            const env = makeEnv(ctx.checker, ctx.dispatch, ctx.fn, ownership, ctx.summaryOf, ctx.resolveCall, ctx.resolveCallFor, ctx.peerSummaryValue, onDegrade);
+            const out = [];
+            diagnoseClassFields(env, ctx, out);
+            const body = bodyOf(ctx.fn.node);
+            if (body) {
+                const visit = (n) => {
+                    if (n !== body && isFunctionLike(n)) {
+                        return;
+                    }
+                    if (ts.isCallExpression(n) || ts.isNewExpression(n)) {
+                        const acq = acquireAt(env, n);
+                        if (acq) {
+                            diagnoseAcquire(env, ctx, n, acq, out);
+                        }
+                    }
+                    ts.forEachChild(n, visit);
+                };
+                visit(body);
+            }
+            return out;
+        },
+    };
+};
+export { createResourcesChannel };