@spyglassmc/core 0.2.0 → 0.3.0

package/lib/node/SymbolNode.d.ts

@@ -9,7 +9,7 @@ export interface SymbolOptions {
 }
 export interface SymbolBaseNode extends AstNode {
     readonly options: SymbolOptions;
-    readonly value: string;
+    value: string;
 }
 export interface SymbolNode extends SymbolBaseNode {
     readonly type: 'symbol';

package/lib/parser/resourceLocation.js

@@ -48,14 +48,6 @@ export function resourceLocation(options) {
             if (!ans.namespace && options.isPredicate) {
                 ctx.err.report(localize('parser.resource-location.namespace-expected'), ans);
             }
-            if (options.category) {
-                const fullRaw = ResourceLocation.lengthen(options.namespacePathSep === '.'
-                    ? raw.replace('.', ResourceLocation.NamespacePathSep)
-                    : raw);
-                ctx.symbols
-                    .query(ctx.doc, ans.isTag ? `tag/${options.category}` : options.category, fullRaw)
-                    .enter({ usage: { type: options.usageType, node: ans, accessType: options.accessType } });
-            }
         }
         return ans;
     };

package/lib/parser/string.d.ts

@@ -6,11 +6,11 @@ import type { Parser, Result, Returnable } from './Parser.js';
 export declare function string(options: StringOptions): InfallibleParser<StringNode>;
 export declare function parseStringValue<T extends Returnable>(parser: Parser<T>, value: string, map: IndexMap, ctx: ParserContext): Result<T>;
 export declare const BrigadierUnquotableCharacters: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "_", ".", "+", "-"];
-export declare const BrigadierUnquotableCharacterSet: Set<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "k" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+export declare const BrigadierUnquotableCharacterSet: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
 export declare const BrigadierUnquotablePattern: RegExp;
 export declare const BrigadierUnquotableOption: {
     allowEmpty: boolean;
-    allowList: Set<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "k" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+    allowList: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "w" | "x" | "y" | "z" | "_" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
 };
 export declare const BrigadierStringOptions: StringOptions;
 export declare const brigadierString: InfallibleParser<StringNode>;

package/lib/parser/symbol.js

@@ -1,19 +1,13 @@
 import { Range } from '../source/index.js';
 export function symbol(param) {
     const options = getOptions(param);
-    return (src, ctx) => {
+    return (src, _ctx) => {
         const ans = {
             type: 'symbol',
             range: Range.create(src),
             options,
             value: src.readRemaining(),
         };
-        if (ans.value) {
-            const path = options.parentPath ? [...options.parentPath, ans.value] : [ans.value];
-            ctx.symbols
-                .query(ctx.doc, options.category, ...path)
-                .enter({ usage: { type: options.usageType, node: ans, accessType: options.accessType } });
-        }
         ans.range.end = src.cursor;
         return ans;
     };

package/lib/parser/util.js

@@ -7,7 +7,6 @@ export function attempt(parser, src, ctx) {
     const tmpCtx = {
         ...ctx,
         err: new ErrorReporter(),
-        symbols: ctx.symbols.clone(),
     };
     const result = parser(tmpSrc, tmpCtx);
     return {
@@ -17,7 +16,6 @@ export function attempt(parser, src, ctx) {
         updateSrcAndCtx: () => {
             src.innerCursor = tmpSrc.innerCursor;
             ctx.err.absorb(tmpCtx.err);
-            tmpCtx.symbols.applyDelayedEdits();
         },
     };
 }

package/lib/processor/InlayHintProvider.d.ts

@@ -1,8 +1,9 @@
+import type { DeepReadonly } from '../common/index.js';
 import type { AstNode } from '../node/index.js';
 import type { ProcessorContext } from '../service/index.js';
 export interface InlayHint {
     offset: number;
     text: string;
 }
-export declare type InlayHintProvider<N = AstNode> = (node: N, ctx: ProcessorContext) => readonly InlayHint[];
+export declare type InlayHintProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ProcessorContext) => readonly InlayHint[];
 //# sourceMappingURL=InlayHintProvider.d.ts.map

package/lib/processor/SignatureHelpProvider.d.ts

@@ -1,3 +1,4 @@
+import type { DeepReadonly } from '../common/index.js';
 import type { AstNode } from '../node/index.js';
 import type { SignatureHelpProviderContext } from '../service/index.js';
 export interface SignatureHelp {
@@ -14,5 +15,5 @@ export interface ParameterInfo {
     label: [number, number];
     documentation?: string;
 }
-export declare type SignatureHelpProvider<N = AstNode> = (node: N, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
+export declare type SignatureHelpProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
 //# sourceMappingURL=SignatureHelpProvider.d.ts.map

package/lib/processor/binder/Binder.d.ts

@@ -0,0 +1,26 @@
+import type { AstNode } from '../../node/index.js';
+import type { BinderContext } from '../../service/index.js';
+declare const IsAsync: unique symbol;
+export declare type Binder<N extends AstNode> = SyncBinder<N> | AsyncBinder<N>;
+export interface SyncBinderInitializer<N extends AstNode> {
+    (node: N, ctx: BinderContext): void;
+}
+export interface SyncBinder<N extends AstNode> extends SyncBinderInitializer<N> {
+    [IsAsync]?: never;
+}
+export declare const SyncBinder: Readonly<{
+    create<N extends AstNode>(binder: SyncBinderInitializer<N>): SyncBinder<N>;
+    is(binder: Binder<any>): binder is SyncBinder<any>;
+}>;
+interface AsyncBinderInitializer<N extends AstNode> {
+    (node: N, ctx: BinderContext): Promise<void>;
+}
+export interface AsyncBinder<N extends AstNode> extends AsyncBinderInitializer<N> {
+    [IsAsync]: true;
+}
+export declare const AsyncBinder: Readonly<{
+    create<N extends AstNode>(binder: AsyncBinderInitializer<N>): AsyncBinder<N>;
+    is(binder: Binder<any>): binder is AsyncBinder<any>;
+}>;
+export {};
+//# sourceMappingURL=Binder.d.ts.map

package/lib/processor/binder/Binder.js

@@ -0,0 +1,18 @@
+const IsAsync = Symbol('IsAsyncBinder');
+export const SyncBinder = Object.freeze({
+    create(binder) {
+        return binder;
+    },
+    is(binder) {
+        return !binder[IsAsync];
+    },
+});
+export const AsyncBinder = Object.freeze({
+    create(binder) {
+        return Object.assign(binder, { [IsAsync]: true });
+    },
+    is(binder) {
+        return binder[IsAsync];
+    },
+});
+//# sourceMappingURL=Binder.js.map

package/lib/processor/binder/builtin.d.ts

@@ -0,0 +1,27 @@
+import type { AstNode, SymbolBaseNode } from '../../node/index.js';
+import { ResourceLocationNode } from '../../node/index.js';
+import type { BinderContext, MetaRegistry } from '../../service/index.js';
+import type { Binder } from './Binder.js';
+import { AsyncBinder, SyncBinder } from './Binder.js';
+export declare type AttemptResult = {
+    errorAmount: number;
+    totalErrorSpan: number;
+    updateNodeAndCtx: () => void;
+};
+export declare function attempt<B extends Binder<never>>(binder: B, node: B extends Binder<infer N extends AstNode> ? N : never, ctx: BinderContext): B extends SyncBinder<any> ? AttemptResult : Promise<AttemptResult>;
+declare type ExtractBinder<B extends Binder<never>> = B extends Binder<infer N extends AstNode> ? N : never;
+export declare function any<Binders extends Binder<never>[]>(binders: Binders): Binders extends SyncBinder<never>[] ? SyncBinder<ExtractBinder<Binders[number]>> : AsyncBinder<ExtractBinder<Binders[number]>>;
+/**
+ * No operation.
+ */
+export declare const noop: SyncBinder<AstNode>;
+/**
+ * Use the shallowest children that have their own binder to validate.
+ */
+export declare const fallback: AsyncBinder<AstNode>;
+export declare const dispatchSync: SyncBinder<AstNode>;
+export declare const resourceLocation: SyncBinder<ResourceLocationNode>;
+export declare const symbol: SyncBinder<SymbolBaseNode>;
+export declare function registerBinders(meta: MetaRegistry): void;
+export {};
+//# sourceMappingURL=builtin.d.ts.map

package/lib/processor/binder/builtin.js

@@ -0,0 +1,116 @@
+import { localize } from '@spyglassmc/locales';
+import { ResourceLocation, StateProxy } from '../../common/index.js';
+import { ResourceLocationNode } from '../../node/index.js';
+import { ErrorReporter } from '../../service/index.js';
+import { traversePreOrder } from '../util.js';
+import { AsyncBinder, SyncBinder } from './Binder.js';
+export function attempt(binder, node, ctx) {
+    const tempCtx = {
+        ...ctx,
+        err: new ErrorReporter(),
+        symbols: ctx.symbols.clone(),
+    };
+    const processAfterBinder = () => {
+        StateProxy.undoChanges(node);
+        const totalErrorSpan = tempCtx.err.errors
+            .map(e => e.range.end - e.range.start)
+            .reduce((a, b) => a + b, 0);
+        return {
+            errorAmount: tempCtx.err.errors.length,
+            totalErrorSpan,
+            updateNodeAndCtx: () => {
+                ctx.err.absorb(tempCtx.err);
+                StateProxy.redoChanges(node);
+                tempCtx.symbols.applyDelayedEdits();
+            },
+        };
+    };
+    if (SyncBinder.is(binder)) {
+        binder(node, tempCtx);
+        return processAfterBinder();
+    }
+    else {
+        return (async () => {
+            await binder(node, tempCtx);
+            return processAfterBinder();
+        })();
+    }
+}
+export function any(binders) {
+    if (binders.length === 0) {
+        throw new Error('Expected at least one binder');
+    }
+    const attemptSorter = (a, b) => a.errorAmount - b.errorAmount || a.totalErrorSpan - b.totalErrorSpan;
+    if (binders.every(SyncBinder.is)) {
+        return SyncBinder.create((node, ctx) => {
+            const attempts = binders
+                .map(binder => attempt(binder, node, ctx))
+                .sort(attemptSorter);
+            attempts[0].updateNodeAndCtx();
+        });
+    }
+    else {
+        return AsyncBinder.create(async (node, ctx) => {
+            const attempts = (await Promise.all(binders.map(binder => attempt(binder, node, ctx))))
+                .sort(attemptSorter);
+            attempts[0].updateNodeAndCtx();
+        });
+    }
+}
+/**
+ * No operation.
+ */
+export const noop = SyncBinder.create(() => { });
+/**
+ * Use the shallowest children that have their own binder to validate.
+ */
+export const fallback = AsyncBinder.create(async (node, ctx) => {
+    const promises = [];
+    traversePreOrder(node, node => !ctx.meta.hasBinder(node.type), node => ctx.meta.hasBinder(node.type), node => {
+        const binder = ctx.meta.getBinder(node.type);
+        const result = binder(node, ctx);
+        if (result instanceof Promise) {
+            promises.push(result);
+        }
+    });
+    await Promise.all(promises);
+});
+export const dispatchSync = SyncBinder.create((node, ctx) => {
+    for (const child of node.children ?? []) {
+        if (ctx.meta.hasBinder(child.type)) {
+            const binder = ctx.meta.getBinder(child.type);
+            binder(child, ctx);
+        }
+    }
+});
+export const resourceLocation = SyncBinder.create((node, ctx) => {
+    if (node.options.category) {
+        const raw = ResourceLocationNode.toString(node, 'full');
+        const sanitizedRaw = ResourceLocation.lengthen(node.options.namespacePathSep === '.'
+            ? raw.replace('.', ResourceLocation.NamespacePathSep)
+            : raw);
+        ctx.symbols
+            .query(ctx.doc, node.isTag ? `tag/${node.options.category}` : node.options.category, sanitizedRaw)
+            .enter({ usage: { type: node.options.usageType, node, accessType: node.options.accessType } });
+    }
+    const full = ResourceLocationNode.toString(node, 'full');
+    if (node.options.pool) {
+        if (!node.options.pool.includes(full)) {
+            ctx.err.report(localize('expected', node.options.pool), node, 3 /* ErrorSeverity.Error */);
+        }
+        return;
+    }
+});
+export const symbol = SyncBinder.create((node, ctx) => {
+    if (node.value) {
+        const path = node.options.parentPath ? [...node.options.parentPath, node.value] : [node.value];
+        ctx.symbols
+            .query(ctx.doc, node.options.category, ...path)
+            .enter({ usage: { type: node.options.usageType, node: node, accessType: node.options.accessType } });
+    }
+});
+export function registerBinders(meta) {
+    meta.registerBinder('resource_location', resourceLocation);
+    meta.registerBinder('symbol', symbol);
+}
+//# sourceMappingURL=builtin.js.map

package/lib/processor/binder/index.d.ts

@@ -0,0 +1,3 @@
+export * as binder from './builtin.js';
+export * from './Binder.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/processor/binder/index.js

@@ -0,0 +1,3 @@
+export * as binder from './builtin.js';
+export * from './Binder.js';
+//# sourceMappingURL=index.js.map

package/lib/processor/checker/builtin.js

@@ -1,17 +1,17 @@
 import { localize } from '@spyglassmc/locales';
+import { StateProxy } from '../../common/index.js';
 import { ResourceLocationNode } from '../../node/index.js';
-import { ErrorReporter, Operations } from '../../service/index.js';
+import { ErrorReporter } from '../../service/index.js';
 import { traversePreOrder } from '../util.js';
 export function attempt(checker, node, ctx) {
     const tempCtx = {
         ...ctx,
         err: new ErrorReporter(),
-        ops: new Operations(),
         symbols: ctx.symbols.clone(),
     };
     // FIXME: await
     checker(node, tempCtx);
-    tempCtx.ops.undo();
+    StateProxy.undoChanges(node);
     const totalErrorSpan = tempCtx.err.errors
         .map(e => e.range.end - e.range.start)
         .reduce((a, b) => a + b, 0);
@@ -20,7 +20,7 @@ export function attempt(checker, node, ctx) {
         totalErrorSpan,
         updateNodeAndCtx: () => {
             ctx.err.absorb(tempCtx.err);
-            tempCtx.ops.redo();
+            StateProxy.redoChanges(node);
             tempCtx.symbols.applyDelayedEdits();
         },
     };
@@ -52,7 +52,7 @@ export const fallback = async (node, ctx) => {
             promises.push(result);
         }
     });
-    await Promise.allSettled(promises);
+    await Promise.all(promises);
 };
 export const dispatchSync = (node, ctx) => {
     for (const child of node.children ?? []) {

package/lib/processor/colorizer/Colorizer.d.ts

@@ -1,8 +1,9 @@
+import type { DeepReadonly } from '../../common/index.js';
 import type { AstNode } from '../../node/index.js';
 import type { ColorizerContext } from '../../service/index.js';
 import type { RangeLike } from '../../source/index.js';
 import { Range } from '../../source/index.js';
-export declare type Colorizer<N = AstNode> = (node: N, ctx: ColorizerContext) => readonly ColorToken[];
+export declare type Colorizer<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ColorizerContext) => readonly ColorToken[];
 export interface ColorToken {
     range: Range;
     type: ColorTokenType;

package/lib/processor/completer/Completer.d.ts

@@ -1,8 +1,9 @@
+import type { DeepReadonly } from '../../index.js';
 import type { AstNode } from '../../node/index.js';
 import type { CompleterContext } from '../../service/index.js';
 import type { RangeLike } from '../../source/index.js';
 import { Range } from '../../source/index.js';
-export declare type Completer<N = AstNode> = (node: N, ctx: CompleterContext) => CompletionItem[];
+export declare type Completer<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: CompleterContext) => CompletionItem[];
 export declare const enum CompletionKind {
     Text = 1,
     Method = 2,

package/lib/processor/completer/builtin.d.ts

@@ -1,3 +1,4 @@
+import type { DeepReadonly } from '../../common/index.js';
 import type { BooleanBaseNode } from '../../node/BooleanNode.js';
 import type { FileNode, LiteralBaseNode, PairNode, RecordBaseNode, ResourceLocationNode, StringBaseNode, SymbolBaseNode } from '../../node/index.js';
 import { AstNode } from '../../node/index.js';
@@ -18,8 +19,8 @@ export declare const file: Completer<FileNode<AstNode>>;
 export declare const literal: Completer<LiteralBaseNode>;
 export declare const noop: Completer<any>;
 interface RecordOptions<K extends AstNode, V extends AstNode, N extends RecordBaseNode<K, V>> {
-    key: (record: N, pair: PairNode<K, V> | undefined, ctx: CompleterContext, range: RangeLike, insertValue: boolean, insertPairEnd: boolean, existingKeys: K[]) => CompletionItem[];
-    value: (record: N, pair: PairNode<K, V>, ctx: CompleterContext) => CompletionItem[];
+    key: (record: DeepReadonly<N>, pair: DeepReadonly<PairNode<K, V>> | undefined, ctx: CompleterContext, range: RangeLike, insertValue: boolean, insertPairEnd: boolean, existingKeys: DeepReadonly<K>[]) => CompletionItem[];
+    value: (record: DeepReadonly<N>, pair: DeepReadonly<PairNode<K, V>>, ctx: CompleterContext) => CompletionItem[];
 }
 export declare function record<K extends AstNode, V extends AstNode, N extends RecordBaseNode<K, V>>(o: RecordOptions<K, V, N>): Completer<N>;
 export declare const resourceLocation: Completer<ResourceLocationNode>;

package/lib/processor/completer/builtin.js

@@ -9,7 +9,7 @@ import { CompletionItem } from './Completer.js';
  */
 export const dispatch = (node, ctx) => {
     const child = AstNode.findShallowestChild({
-        node,
+        node: node,
         needle: ctx.offset,
         endInclusive: true,
         predicate: n => ctx.meta.hasCompleter(n.type),

package/lib/processor/formatter/Formatter.d.ts

@@ -1,6 +1,7 @@
+import type { DeepReadonly } from '../../common/index.js';
 import type { AstNode } from '../../node/index.js';
 import type { FormatterContext } from '../../service/index.js';
-export declare type Formatter<N = AstNode> = (node: N, ctx: FormatterContext) => string;
+export declare type Formatter<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: FormatterContext) => string;
 export declare function formatterContextIndentation(ctx: FormatterContext, additionalLevels?: number): string;
 export declare function indentFormatter(ctx: FormatterContext, additionalLevels?: number): FormatterContext;
 //# sourceMappingURL=Formatter.d.ts.map

package/lib/processor/index.d.ts

@@ -1,3 +1,4 @@
+export * from './binder/index.js';
 export * from './checker/index.js';
 export * from './ColorInfoProvider.js';
 export * from './colorizer/index.js';

package/lib/processor/index.js

@@ -1,3 +1,4 @@
+export * from './binder/index.js';
 export * from './checker/index.js';
 export * from './ColorInfoProvider.js';
 export * from './colorizer/index.js';

package/lib/processor/linter/Linter.d.ts

@@ -1,4 +1,5 @@
+import type { StateProxy } from '../../index.js';
 import type { AstNode } from '../../node/index.js';
 import type { LinterContext } from '../../service/index.js';
-export declare type Linter<N extends AstNode> = (node: N, ctx: LinterContext) => void;
+export declare type Linter<N extends AstNode> = (node: StateProxy<N>, ctx: LinterContext) => void;
 //# sourceMappingURL=Linter.d.ts.map

package/lib/processor/linter/builtin.d.ts

@@ -1,5 +1,6 @@
+import type { Logger } from '../../common/index.js';
 import type { AstNode, StringBaseNode } from '../../node/index.js';
-import type { Logger, MetaRegistry } from '../../service/index.js';
+import type { MetaRegistry } from '../../service/index.js';
 import type { Linter } from './Linter.js';
 export declare const noop: Linter<AstNode>;
 /**

package/lib/processor/util.d.ts

@@ -1,17 +1,7 @@
+import type { DeepReadonly } from '../index.js';
 import type { AstNode } from '../node/index.js';
-import { Range } from '../source/index.js';
 declare type Callback<R> = (this: void, node: AstNode, parents: AstNode[]) => R;
-export declare function traversePreOrder(node: AstNode, shouldContinue: Callback<unknown>, shouldCallFn: Callback<unknown>, fn: Callback<unknown>): void;
-interface NodeResult {
-    node: AstNode | undefined;
-    /**
-     * Ordered from the closest parent to the root node.
-     */
-    parents: AstNode[];
-}
-/**
- * @returns The shallowest node that is fully contained within `range`.
- */
-export declare function findNode(node: AstNode, range: Range): NodeResult;
+export declare function traversePreOrder<CN extends AstNode>(node: DeepReadonly<AstNode>, shouldContinue: Callback<unknown>, shouldCallFn: (this: void, node: AstNode, parents: AstNode[]) => node is CN, fn: (this: void, node: CN, parents: AstNode[]) => void): void;
+export declare function traversePreOrder(node: DeepReadonly<AstNode>, shouldContinue: Callback<unknown>, shouldCallFn: Callback<unknown>, fn: Callback<void>): void;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/lib/processor/util.js

@@ -1,4 +1,3 @@
-import { Range } from '../source/index.js';
 export function traversePreOrder(node, shouldContinue, shouldCallFn, fn) {
     traversePreOrderImpl(node, shouldContinue, shouldCallFn, fn, []);
 }
@@ -15,13 +14,4 @@ function traversePreOrderImpl(node, shouldContinue, shouldCallFn, fn, parents) {
         parents.shift();
     }
 }
-/**
- * @returns The shallowest node that is fully contained within `range`.
- */
-export function findNode(node, range) {
-    let ans = { node: undefined, parents: [] };
-    // TODO: Binary search here.
-    traversePreOrder(node, (node) => ans.node === undefined && Range.intersects(node.range, range), (node) => Range.containsRange(range, node.range), (node, parents) => ans = { node, parents: [...parents] });
-    return ans;
-}
 //# sourceMappingURL=util.js.map

package/lib/service/CacheService.d.ts

@@ -1,3 +1,4 @@
+import type { TextDocument } from 'vscode-languageserver-textdocument';
 import { SymbolTable } from '../symbol/index.js';
 import type { RootUriString } from './fileUtil.js';
 import type { Project } from './Project.js';
@@ -48,6 +49,7 @@ export declare class CacheService {
      * @returns If the cache file was saved successfully.
      */
     save(): Promise<boolean>;
+    hasFileChangedSinceCache(doc: TextDocument): Promise<boolean>;
     reset(): void;
 }
 export {};

package/lib/service/CacheService.js

@@ -178,6 +178,9 @@ export class CacheService {
         }
         return false;
     }
+    async hasFileChangedSinceCache(doc) {
+        return this.checksums.files[doc.uri] !== await this.project.externals.crypto.getSha1(doc.getText());
+    }
     reset() {
         this.checksums = Checksums.create();
     }

package/lib/service/Context.d.ts

@@ -1,21 +1,18 @@
 import type { TextDocument } from 'vscode-languageserver-textdocument';
-import type { LinterErrorReporter } from './index.js';
+import type { Logger } from '../common/index.js';
 import type { Range } from '../source/index.js';
 import { ReadonlySource } from '../source/index.js';
-import type { SymbolTable, SymbolUtil } from '../symbol/index.js';
+import type { SymbolUtil } from '../symbol/index.js';
 import type { Config } from './Config.js';
 import { ErrorReporter } from './ErrorReporter.js';
 import type { FileService } from './FileService.js';
 import type { RootUriString } from './fileUtil.js';
-import type { Logger } from './Logger.js';
+import type { LinterErrorReporter } from './index.js';
 import type { MetaRegistry } from './MetaRegistry.js';
-import { Operations } from './Operations.js';
 import type { ProfilerFactory } from './Profiler.js';
-import type { DocAndNode, ProjectData } from './Project.js';
+import type { ProjectData } from './Project.js';
 export interface ContextBase {
     fs: FileService;
-    getDocAndNode: (uri: string) => DocAndNode | undefined;
-    global: SymbolTable;
     logger: Logger;
     meta: MetaRegistry;
     profilers: ProfilerFactory;
@@ -29,7 +26,6 @@ export interface ParserContext extends ContextBase {
     config: Config;
     doc: TextDocument;
     err: ErrorReporter;
-    symbols: SymbolUtil;
 }
 interface ParserContextOptions {
     doc: TextDocument;
@@ -69,14 +65,22 @@ interface ProcessorWithOffsetContextOptions extends ProcessorContextOptions {
 declare namespace ProcessorWithOffsetContext {
     function create(project: ProjectData, opts: ProcessorWithOffsetContextOptions): ProcessorWithOffsetContext;
 }
+export interface BinderContext extends ProcessorContext {
+    err: ErrorReporter;
+    ensureBindingStarted: (this: void, uri: string) => Promise<unknown>;
+}
+interface BinderContextOptions extends ProcessorContextOptions {
+    err?: ErrorReporter;
+}
+export declare namespace BinderContext {
+    function create(project: ProjectData, opts: BinderContextOptions): BinderContext;
+}
 export interface CheckerContext extends ProcessorContext {
     err: ErrorReporter;
-    ops: Operations;
-    ensureChecked: (this: void, uri: string) => Promise<unknown>;
+    ensureBindingStarted: (this: void, uri: string) => Promise<unknown>;
 }
 interface CheckerContextOptions extends ProcessorContextOptions {
     err?: ErrorReporter;
-    ops?: Operations;
 }
 export declare namespace CheckerContext {
     function create(project: ProjectData, opts: CheckerContextOptions): CheckerContext;
@@ -133,7 +137,6 @@ export declare namespace SignatureHelpProviderContext {
     function create(project: ProjectData, opts: SignatureHelpProviderContextOptions): SignatureHelpProviderContext;
 }
 export interface UriBinderContext extends ContextBase {
-    /** @deprecated */
     symbols: SymbolUtil;
 }
 export declare namespace UriBinderContext {

package/lib/service/Context.js

@@ -2,14 +2,11 @@
 import { formatterContextIndentation } from '../processor/index.js';
 import { ReadonlySource } from '../source/index.js';
 import { ErrorReporter } from './ErrorReporter.js';
-import { Operations } from './Operations.js';
 export var ContextBase;
 (function (ContextBase) {
     function create(project) {
         return {
             fs: project.fs,
-            getDocAndNode: project.get.bind(project),
-            global: project.symbols.global,
             logger: project.logger,
             meta: project.meta,
             profilers: project.profilers,
@@ -27,7 +24,6 @@ export var ParserContext;
             config: project.config,
             doc: opts.doc,
             err: opts.err ?? new ErrorReporter(),
-            symbols: project.symbols,
         };
     }
     ParserContext.create = create;
@@ -65,14 +61,24 @@ var ProcessorWithOffsetContext;
     }
     ProcessorWithOffsetContext.create = create;
 })(ProcessorWithOffsetContext || (ProcessorWithOffsetContext = {}));
+export var BinderContext;
+(function (BinderContext) {
+    function create(project, opts) {
+        return {
+            ...ProcessorContext.create(project, opts),
+            err: opts.err ?? new ErrorReporter(),
+            ensureBindingStarted: project.ensureBindingStarted?.bind(project),
+        };
+    }
+    BinderContext.create = create;
+})(BinderContext || (BinderContext = {}));
 export var CheckerContext;
 (function (CheckerContext) {
     function create(project, opts) {
         return {
             ...ProcessorContext.create(project, opts),
             err: opts.err ?? new ErrorReporter(),
-            ops: opts.ops ?? new Operations(),
-            ensureChecked: project.ensureParsedAndChecked?.bind(project),
+            ensureBindingStarted: project.ensureBindingStarted?.bind(project),
         };
     }
     CheckerContext.create = create;

package/lib/service/Downloader.d.ts

@@ -1,6 +1,5 @@
-import type { ExternalDownloaderOptions, Externals, RemoteUriString } from '../common/index.js';
+import type { ExternalDownloaderOptions, Externals, Logger, RemoteUriString } from '../common/index.js';
 import type { RootUriString } from './fileUtil.js';
-import type { Logger } from './Logger.js';
 export interface DownloaderDownloadOut {
     cacheUri?: string;
     checksum?: string;