@esportsplus/typescript 0.32.0 → 0.33.1

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

@@ -1,6 +1,6 @@
 import * as ts from '../adapter.js';
 import { overlayThrows } from '../exceptions/channel.js';
-import { bodyOf, calleeSelectors, paramSymbols, unwrap } from '../kernel/ast.js';
+import { bodyOf, 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';
@@ -32,13 +32,13 @@ function refsSym(env, expr, sym) {
     }
     return env.checker.getSymbolAtLocation(e) === sym;
 }
-function containsMatch(node, pred) {
+function containsMatch(node, pred, descendIntoFunctions = false) {
     let found = false;
     const rec = (n) => {
         if (found) {
             return;
         }
-        if (n !== node && isFunctionLike(n)) {
+        if (n !== node && !descendIntoFunctions && isFunctionLike(n)) {
             return;
         }
         if (pred(n)) {
@@ -67,7 +67,7 @@ function callCanThrow(env, call) {
     if (res.targets.length > 0) {
         return res.targets.some((t) => env.peerThrows(t.id));
     }
-    return res.unresolved && env.dispatch === 'pessimist';
+    return res.unresolved;
 }
 function enclosingStatement(node) {
     let n = node;
@@ -79,24 +79,13 @@ function enclosingStatement(node) {
 function blockOf(stmt) {
     return stmt.parent && ts.isBlock(stmt.parent) ? stmt.parent : undefined;
 }
-function isDisposableType(env, type) {
+function hasDispose(env, type, includeAsync) {
     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')) {
+            (includeAsync && prop.name.startsWith('__@asyncDispose'))) {
             return true;
         }
     }
@@ -134,7 +123,19 @@ function acquireAt(env, call) {
             };
         }
     }
-    if (isDisposableType(env, env.checker.getTypeAtLocation(call))) {
+    const parent = bindingParentOf(call);
+    const target = parent.parent;
+    const isInitializer = bindingDeclOf(call) !== undefined ||
+        (ts.isPropertyDeclaration(target) && target.initializer === parent) ||
+        (ts.isBinaryExpression(target) &&
+            target.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            target.right === parent &&
+            ts.isPropertyAccessExpression(target.left) &&
+            target.left.expression.kind === ts.SyntaxKind.ThisKeyword);
+    if (!isInitializer) {
+        return undefined;
+    }
+    if (hasDispose(env, env.checker.getTypeAtLocation(call), true)) {
         return {
             kind: 'handle',
             releasedBy: undefined,
@@ -144,19 +145,24 @@ function acquireAt(env, call) {
     }
     return undefined;
 }
+function bindingDeclOf(call) {
+    const parent = bindingParentOf(call).parent;
+    return ts.isVariableDeclaration(parent) ? parent : undefined;
+}
+function bindingParentOf(call) {
+    let parent = call;
+    while (parent.parent &&
+        (ts.isParenthesizedExpression(parent.parent) ||
+            ts.isNonNullExpression(parent.parent) ||
+            ts.isAsExpression(parent.parent) ||
+            ts.isAwaitExpression(parent.parent))) {
+        parent = parent.parent;
+    }
+    return parent;
+}
 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)) {
+    const decl = bindingDeclOf(call);
+    if (!decl || !ts.isIdentifier(decl.name)) {
         return undefined;
     }
     const list = decl.parent;
@@ -168,7 +174,7 @@ function handleBinding(env, call) {
     const sym = env.checker.getSymbolAtLocation(decl.name);
     return sym ? { using: false, sym } : undefined;
 }
-function isDischargeOf(env, expr, sym, acq) {
+function isDischargeCall(expr, acq, refs) {
     if (!ts.isCallExpression(expr)) {
         return false;
     }
@@ -182,10 +188,10 @@ function isDischargeOf(env, expr, sym, acq) {
             return false;
         }
         const arg = expr.arguments?.[0];
-        return arg ? refsSym(env, arg, sym) : false;
+        return arg ? refs(arg) : false;
     }
     if (ts.isPropertyAccessExpression(callee)) {
-        if (!refsSym(env, callee.expression, sym)) {
+        if (!refs(callee.expression)) {
             return false;
         }
         const method = callee.name.text;
@@ -197,7 +203,7 @@ function isDischargeOf(env, expr, sym, acq) {
             acq.releasedBy.slice(1) === method);
     }
     if (ts.isElementAccessExpression(callee)) {
-        if (!refsSym(env, callee.expression, sym)) {
+        if (!refs(callee.expression)) {
             return false;
         }
         const argx = callee.argumentExpression;
@@ -207,6 +213,9 @@ function isDischargeOf(env, expr, sym, acq) {
     }
     return false;
 }
+function isDischargeOf(env, expr, sym, acq) {
+    return isDischargeCall(expr, acq, (e) => refsSym(env, e, sym));
+}
 function callOwnsArg(env, call, sym) {
     const args = call.arguments ? Array.from(call.arguments) : [];
     const indices = [];
@@ -218,13 +227,6 @@ function callOwnsArg(env, call, sym) {
     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)) {
@@ -273,8 +275,9 @@ function statementDischargesOrTransfers(env, s, sym, acq) {
     }
     return false;
 }
-function finallyDischarges(env, sym, acq, declStmt, body) {
+function finallyDischarges(env, sym, acq, declStmt, body, sf) {
     let found = false;
+    const declStart = declStmt.getStart(sf);
     const rec = (n) => {
         if (found) {
             return;
@@ -284,7 +287,7 @@ function finallyDischarges(env, sym, acq, declStmt, body) {
         }
         if (ts.isTryStatement(n) &&
             n.finallyBlock &&
-            declStmt.getStart() < n.finallyBlock.getStart()) {
+            declStart < n.finallyBlock.getStart(sf)) {
             const discharged = containsMatch(n.finallyBlock, (m) => (ts.isCallExpression(m) || ts.isNewExpression(m)) &&
                 isDischargeOf(env, m, sym, acq));
             if (discharged) {
@@ -356,7 +359,7 @@ function opaqueUseOf(env, sym, body) {
     return hit;
 }
 function handleOutcome(env, acq, sym, declStmt, block, body) {
-    if (finallyDischarges(env, sym, acq, declStmt, body)) {
+    if (finallyDischarges(env, sym, acq, declStmt, body, env.fn.sourceFile)) {
         return 'safe';
     }
     if (firstGuaranteed(env, sym, acq, declStmt, block)) {
@@ -367,7 +370,7 @@ function handleOutcome(env, acq, sym, declStmt, block, body) {
     }
     return 'leak';
 }
-function isReleaseCallForPair(node, acq, acquireCall) {
+function isReleaseCallForPair(node, acq, acquireCall, acquireExpressionText) {
     if (!ts.isCallExpression(node) || acq.releasedBy === undefined) {
         return false;
     }
@@ -380,7 +383,8 @@ function isReleaseCallForPair(node, acq, acquireCall) {
     if (callee.name.text !== acq.releasedBy) {
         return false;
     }
-    if (callee.expression.getText() !== acqCallee.expression.getText()) {
+    if (acquireExpressionText === undefined ||
+        callee.expression.getText() !== acquireExpressionText) {
         return false;
     }
     for (const i of acq.pairKey ?? []) {
@@ -397,7 +401,11 @@ function hasMatchingRelease(env, acquireCall, acq) {
     if (!body) {
         return false;
     }
-    return containsMatch(body, (n) => isReleaseCallForPair(n, acq, acquireCall));
+    const acqCallee = acquireCall.expression;
+    const acquireExpressionText = ts.isPropertyAccessExpression(acqCallee)
+        ? acqCallee.expression.getText()
+        : undefined;
+    return containsMatch(body, (n) => isReleaseCallForPair(n, acq, acquireCall, acquireExpressionText), true);
 }
 function classDischargesField(cls, field, acq) {
     const members = cls.members ?? [];
@@ -407,39 +415,7 @@ function classDischargesField(cls, field, acq) {
             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;
-    };
+    const dischargesHere = (n) => ts.isCallExpression(n) && isDischargeCall(n, acq, refsThisField);
     for (const member of members) {
         const body = member.body;
         if (body && containsMatch(body, dischargesHere)) {
@@ -494,30 +470,12 @@ function classFieldAcquires(env, cls, 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))) {
+    if (!hasDispose(env, env.checker.getTypeAtLocation(call), false)) {
         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)) {
+    const decl = bindingDeclOf(call);
+    if (!decl) {
         return undefined;
     }
     const list = decl.parent;
@@ -554,7 +512,7 @@ function releaseText(env, acq, name, call) {
             ? `${name}.${acq.releasedBy.slice(1)}()`
             : `${acq.releasedBy}(${name})`;
     }
-    if (hasSyncDispose(env, env.checker.getTypeAtLocation(call))) {
+    if (hasDispose(env, env.checker.getTypeAtLocation(call), false)) {
         return `${name}[Symbol.dispose]()`;
     }
     return undefined;
@@ -603,47 +561,16 @@ function tryFinallyFix(env, acq, sym, declStmt, block, call) {
         ],
     };
 }
-function leakDiagnostic(ctx, node, acq, why, fixes) {
+function leakDiagnostic(node, acq, why, fixes) {
     return {
         channel: 'resources',
         message: `\`${acq.label}\` resource can leak — ${why}`,
         location: locationOf(node, node.getSourceFile()),
-        related: relatedPath(ctx),
+        related: [],
         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);
+function makeEnv(checker, fn, summaryOf, resolveCall, resolveCallFor, peerSummaryValue, logDegrade, includeParamSymbols) {
     const resolveExceptions = (call) => resolveCallFor('exceptions', call);
     const peerThrows = (fnId) => {
         const value = peerSummaryValue('exceptions', fnId);
@@ -651,15 +578,13 @@ function makeEnv(checker, dispatch, fn, ownership, summaryOf, resolveCall, resol
     };
     return {
         checker,
-        dispatch,
         fn,
-        ownership,
         summaryOf,
         resolveCall,
         resolveExceptions,
         peerThrows,
         logDegrade,
-        paramSymbols: symbols,
+        paramSymbols: includeParamSymbols ? paramSymbols(checker, fn.node) : undefined,
     };
 }
 function ownsParam(env, sym, body) {
@@ -683,17 +608,17 @@ function computeOwnership(env) {
     if (!body) {
         return owned;
     }
-    for (const [sym, index] of env.paramSymbols) {
+    for (const [sym, index] of env.paramSymbols ?? []) {
         if (ownsParam(env, sym, body)) {
             owned.add(index);
         }
     }
     return owned;
 }
-function diagnoseAcquire(env, ctx, call, acq, out) {
+function diagnoseAcquire(env, 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`));
+            out.push(leakDiagnostic(call, acq, `no matching \`${acq.releasedBy ?? 'release'}\` on every path`));
         }
         return;
     }
@@ -719,23 +644,21 @@ function diagnoseAcquire(env, ctx, call, acq, out) {
             if (wrapped) {
                 fixes.push(wrapped);
             }
-            out.push(leakDiagnostic(ctx, call, acq, 'no release, transfer, or `using` on every path', fixes.length > 0 ? fixes : undefined));
+            out.push(leakDiagnostic(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),
-                });
-            }
+            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: [],
+            });
         }
         return;
     }
 }
-function diagnoseClassFields(env, ctx, out) {
+function diagnoseClassFields(env, out) {
     if (!ts.isConstructorDeclaration(env.fn.node)) {
         return;
     }
@@ -752,12 +675,11 @@ function diagnoseClassFields(env, ctx, out) {
             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),
+            related: [],
         });
     }
 }
-const createResourcesChannel = (channelConfig, onDegrade = () => { }) => {
-    const ownership = parseOwnership(channelConfig);
+const createResourcesChannel = (onDegrade = () => { }) => {
     return {
         name: 'resources',
         dependsOn: ['exceptions'],
@@ -765,16 +687,16 @@ const createResourcesChannel = (channelConfig, onDegrade = () => { }) => {
         equals,
         widen,
         transfer(ctx) {
-            const env = makeEnv(ctx.checker, ctx.dispatch, ctx.fn, ownership, ctx.summaryOf, ctx.resolveCall, ctx.resolveCallFor, ctx.peerSummaryValue, onDegrade);
+            const env = makeEnv(ctx.checker, ctx.fn, ctx.summaryOf, ctx.resolveCall, ctx.resolveCallFor, ctx.peerSummaryValue, onDegrade, true);
             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 env = makeEnv(ctx.checker, ctx.fn, ctx.summaryOf, ctx.resolveCall, ctx.resolveCallFor, ctx.peerSummaryValue, onDegrade, false);
             const out = [];
-            diagnoseClassFields(env, ctx, out);
+            diagnoseClassFields(env, out);
             const body = bodyOf(ctx.fn.node);
             if (body) {
                 const visit = (n) => {
@@ -784,7 +706,7 @@ const createResourcesChannel = (channelConfig, onDegrade = () => { }) => {
                     if (ts.isCallExpression(n) || ts.isNewExpression(n)) {
                         const acq = acquireAt(env, n);
                         if (acq) {
-                            diagnoseAcquire(env, ctx, n, acq, out);
+                            diagnoseAcquire(env, n, acq, out);
                         }
                     }
                     ts.forEachChild(n, visit);

package/build/{probe → guard}/resources/value.d.ts

@@ -3,7 +3,6 @@ type ResourcesValue = {
 };
 declare function bottom(): ResourcesValue;
 declare function fromParams(indices: Iterable<number>): ResourcesValue;
-declare function join(a: ResourcesValue, b: ResourcesValue): ResourcesValue;
 declare function equals(a: ResourcesValue, b: ResourcesValue): boolean;
 declare function widen(_prev: ResourcesValue, next: ResourcesValue, _round: number): ResourcesValue;
-export { bottom, equals, fromParams, join, type ResourcesValue, widen };
+export { bottom, equals, fromParams, type ResourcesValue, widen };

package/build/{probe → guard}/resources/value.js

@@ -6,19 +6,6 @@ function fromParams(indices) {
     const set = new Set(indices);
     return { ownsParams: set.size === 0 ? EMPTY : set };
 }
-function join(a, b) {
-    if (a.ownsParams.size === 0) {
-        return b;
-    }
-    if (b.ownsParams.size === 0) {
-        return a;
-    }
-    const set = new Set(a.ownsParams);
-    for (const i of b.ownsParams) {
-        set.add(i);
-    }
-    return { ownsParams: set };
-}
 function equals(a, b) {
     if (a.ownsParams.size !== b.ownsParams.size) {
         return false;
@@ -33,4 +20,4 @@ function equals(a, b) {
 function widen(_prev, next, _round) {
     return next;
 }
-export { bottom, equals, fromParams, join, widen };
+export { bottom, equals, fromParams, widen };

package/build/lsp/diagnostics.d.ts

@@ -1,10 +1,10 @@
 import { DiagnosticSeverity } from 'vscode-languageserver/node';
 import type { CodeAction, Diagnostic as LspDiagnostic, Hover } from 'vscode-languageserver/node';
 import type { TextDocument } from 'vscode-languageserver-textdocument';
-import type { Diagnostic as AnalyzeDiagnostic } from '../probe/kernel/types.js';
+import type { Diagnostic as AnalyzeDiagnostic } from '../guard/kernel/types.js';
 export type DocumentResolver = (fileName: string) => TextDocument | undefined;
 declare function toLspDiagnostic(diagnostic: AnalyzeDiagnostic, severity: DiagnosticSeverity, resolve: DocumentResolver, uriOf: (fileName: string) => string): LspDiagnostic;
-declare function groupByFile(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, severity: DiagnosticSeverity, resolve: DocumentResolver, uriOf: (fileName: string) => string): Map<string, LspDiagnostic[]>;
+declare function groupByFile(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, severityOf: (channel: string) => DiagnosticSeverity, resolve: DocumentResolver, uriOf: (fileName: string) => string): Map<string, LspDiagnostic[]>;
 declare function hoverAt(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, offset: number, document: TextDocument): Hover | undefined;
 declare function codeActionsAt(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, startOffset: number, endOffset: number, document: TextDocument, uriOf: (fileName: string) => string): CodeAction[];
 export { codeActionsAt, DiagnosticSeverity, groupByFile, hoverAt, toLspDiagnostic };

package/build/lsp/diagnostics.js

@@ -22,7 +22,7 @@ function toLspDiagnostic(diagnostic, severity, resolve, uriOf) {
         source: 'analyze',
     };
 }
-function groupByFile(diagnostics, severity, resolve, uriOf) {
+function groupByFile(diagnostics, severityOf, resolve, uriOf) {
     let grouped = new Map();
     for (let i = 0, n = diagnostics.length; i < n; i++) {
         let diagnostic = diagnostics[i], fileName = diagnostic.location.fileName, list = grouped.get(fileName);
@@ -30,7 +30,7 @@ function groupByFile(diagnostics, severity, resolve, uriOf) {
             list = [];
             grouped.set(fileName, list);
         }
-        list.push(toLspDiagnostic(diagnostic, severity, resolve, uriOf));
+        list.push(toLspDiagnostic(diagnostic, severityOf(diagnostic.channel), resolve, uriOf));
     }
     return grouped;
 }

package/build/lsp/server.js

@@ -9,6 +9,15 @@ function pathKey(fileName) {
     let resolved = NodePath.resolve(fileName);
     return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
 }
+function lspSeverity(severity) {
+    if (severity === 'warn') {
+        return DiagnosticSeverity.Warning;
+    }
+    if (severity === 'info') {
+        return DiagnosticSeverity.Information;
+    }
+    return DiagnosticSeverity.Error;
+}
 function findTsconfig(rootDir) {
     let candidate = NodePath.join(rootDir, 'tsconfig.json');
     return NodeFS.existsSync(candidate) ? candidate : undefined;
@@ -19,12 +28,38 @@ function rootFromInitialize(params) {
 }
 function createServer(connection) {
     let analyzed = new Map(), documents = new TextDocuments(TextDocument), pending = new Set(), published = new Set(), timer, workspace;
+    function publishConfigError() {
+        if (!workspace) {
+            return;
+        }
+        let uri = pathToFileURL(workspace.configPath).toString();
+        if (workspace.configError) {
+            connection.sendDiagnostics({
+                diagnostics: [{
+                        message: workspace.configError,
+                        range: { end: { character: 0, line: 0 }, start: { character: 0, line: 0 } },
+                        severity: DiagnosticSeverity.Error,
+                        source: 'analyze',
+                    }],
+                uri,
+            });
+            published.add(uri);
+        }
+        else if (published.has(uri)) {
+            connection.sendDiagnostics({ diagnostics: [], uri });
+            published.delete(uri);
+        }
+    }
     function runAnalysis() {
         timer = undefined;
-        if (!workspace || !workspace.config) {
+        if (!workspace) {
             return;
         }
-        let changed = [...pending];
+        publishConfigError();
+        if (!workspace.config) {
+            return;
+        }
+        let config = workspace.config, changed = [...pending];
         pending.clear();
         try {
             workspace.refresh(changed);
@@ -46,7 +81,10 @@ function createServer(connection) {
             }
             list.push(diagnostic);
         }
-        let openByPath = new Map(documents.all().map((document) => [pathKey(fileURLToPath(document.uri)), document])), resolve = (fileName) => openByPath.get(pathKey(fileName)), severity = workspace.config.severity === 'warning' ? DiagnosticSeverity.Warning : DiagnosticSeverity.Error, uriOf = (fileName) => openByPath.get(pathKey(fileName))?.uri ?? pathToFileURL(fileName).toString(), grouped = groupByFile(result.diagnostics, severity, resolve, uriOf), next = new Set();
+        let openByPath = new Map(documents.all().map((document) => [pathKey(fileURLToPath(document.uri)), document])), resolve = (fileName) => openByPath.get(pathKey(fileName)), severityOf = (channel) => lspSeverity(config.channels[channel]?.severity), uriOf = (fileName) => openByPath.get(pathKey(fileName))?.uri ?? pathToFileURL(fileName).toString(), grouped = groupByFile(result.diagnostics, severityOf, resolve, uriOf), next = new Set();
+        if (workspace.configError) {
+            next.add(pathToFileURL(workspace.configPath).toString());
+        }
         for (let [fileName, diagnostics] of grouped) {
             let uri = uriOf(fileName);
             next.add(uri);

package/build/lsp/workspace.d.ts

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