@hydranium/core 1.0.0-next.39 → 1.0.0-next.390

package/lib/langium/integrity/integrity-service.d.ts

@@ -7,11 +7,11 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 import { Logger, type ProfileSession, type Tracer } from '@hydranium/protocol';
-import { type AstNode, DocumentState, type LangiumDocument } from '@hydranium/langium';
-import { type CancellationToken, type Disposable } from 'vscode-languageserver';
+import { type AstNode, DocumentState, type LangiumDocument, type URI } from '@hydranium/langium';
+import { CancellationToken, type Disposable } from 'vscode-languageserver';
 import { type HydraniumDocumentBuilder } from '../document-builder/document-builder.js';
 import { type TextDocument } from 'vscode-languageserver-textdocument';
-import { type WritableFileSystemProvider } from '../../documents/ast-document-manager.js';
+import { type WritableFileSystemProvider } from '../workspace/file-system-provider.js';
 import { type LogNameOptions } from '../diagnostics/logger.js';
 import { type HydraniumTextDocuments } from '../../documents/hydranium-text-documents.js';
 import { Registry } from '../../util/registry.js';
@@ -67,11 +67,21 @@ export declare namespace IntegrityService {
      * at `DocumentState.Validated` and delivered separately via `publishDiagnostics`
      * or the `onModelUpdated` event.
      *
+     * A document whose parse lacks some of its text reaches this state
+     * unrepaired: no rule runs on it until it parses.
+     *
      * The AST is what this guarantees, not the text. For a closed document whose
      * repair was STAGED rather than written (`'editor'` sync mode),
      * `textDocument` still mirrors disk — read the repair off the AST, or from
      * the staged content the next open consumes.
      *
+     * A `Linked`-phase repair settles the documents that reference the repaired
+     * one in the same build against what the repair replaced. A build after it
+     * relinks them, and they settle again. Past `maxRelinkChain` such builds in
+     * a row they keep stale links. A closed `'editor'` document whose CST was
+     * shed re-reads its unrepaired text in that build and repeats the repair,
+     * so they resolve a renamed element by its old name until the next change.
+     *
      * Invariant: integrity rules only register at Parsed or Linked, so the build
      * is guaranteed post-integrity once it advances past `onBuildPhase(Linked)`
      * into `IndexedReferences`. {@link IntegrityService.register} enforces this at
@@ -93,6 +103,24 @@ export interface IntegrityServiceOptions extends LogNameOptions {
      * to `'silent'`. See {@link IntegritySyncMode}.
      */
     readonly syncMode?: IntegritySyncMode;
+    /**
+     * How many builds in a row may relink the dependents of `Linked`-phase
+     * repairs before a repair only warns. A rule that settles within it gets
+     * every build it needs. An integer of at least 1, 3 by default.
+     */
+    readonly maxRelinkChain?: number;
+}
+/** The text a `Linked`-phase repair was computed from, and the text it produced. */
+export interface IntegrityRepairTexts {
+    readonly from: string;
+    readonly to: string;
+}
+/** The build a repaired document has requested to relink its dependents. */
+export interface DependentRelink {
+    /** The repaired document, whose dependents the build relinks. */
+    readonly document: LangiumDocument;
+    /** Its place in a chain of such builds, each requested by a repair of a document the one before relinked. */
+    readonly chain: number;
 }
 /**
  * Default {@link IntegrityService} implementation. Enforces rules,
@@ -118,15 +146,16 @@ export declare class DefaultIntegrityService<TRoot extends AstNode = AstNode> im
     /** One logger per rule, created at registration and dropped on unregister. */
     protected ruleLoggers: Map<string, Logger>;
     /**
-     * Rules bucketed by the phase they target, preserving the registry's
-     * priority order within each bucket. Rebuilt lazily on the first
-     * `enforceIntegrity` call after a registry mutation — staleness is detected
-     * via reference identity of the registry's cached array (see
-     * {@link Registry.all}). Filtering the rule list per call would instead
-     * allocate one transient array per document per phase, which a workspace
-     * whose documents all settle at the same phase pays on every build.
+     * Rules bucketed by the phase they target, then by each `$type` from
+     * {@link nodeTypesFor}, preserving the registry's priority order within
+     * each bucket. Rebuilt lazily on the first `enforceIntegrity` call after a
+     * registry mutation — staleness is detected via reference identity of the
+     * registry's cached array (see {@link Registry.all}). Filtering the rule
+     * list per call would instead allocate one transient array per document per
+     * phase, which a workspace whose documents all settle at the same phase pays
+     * on every build.
      */
-    protected phaseBuckets: Map<DocumentState, readonly IntegrityRule<AstNode>[]>;
+    protected phaseBuckets: Map<DocumentState, ReadonlyMap<string, readonly IntegrityRule<AstNode>[]>>;
     protected phaseBucketsFor: readonly IntegrityRule[] | undefined;
     /** Controls how corrections are persisted for closed files. See {@link IntegritySyncMode}. */
     protected readonly syncMode: IntegritySyncMode;
@@ -135,11 +164,31 @@ export declare class DefaultIntegrityService<TRoot extends AstNode = AstNode> im
     protected readonly tracer: Tracer;
     /**
      * The framework document builder, used to re-parse + re-link a document in place after a
-     * Linked-phase correction (see {@link resyncDocument}). The framework binds
-     * `shared.workspace.DocumentBuilder` to {@link HydraniumDocumentBuilder}; the narrowing
-     * cast surfaces its single-document phase runner.
+     * Linked-phase correction (see {@link resyncDocument}).
      */
     protected readonly documentBuilder: HydraniumDocumentBuilder;
+    /** Each document's {@link DependentRelink}, from its request until it settles. See {@link relinkDependents}. */
+    protected readonly relinkBuilds: WeakMap<LangiumDocument<AstNode>, DependentRelink>;
+    /** The {@link replayKey} of the latest repair of each document that {@link stagesRepairs}, with the hash of the text it came from. */
+    protected readonly replayKeys: WeakMap<LangiumDocument<AstNode>, {
+        readonly key: string;
+        readonly fromHash: string;
+    }>;
+    /** The relinks the check inside the lock found needed, until their build starts. */
+    protected readonly scheduledRelinks: WeakSet<DependentRelink>;
+    /** The relinks of every language whose build runs, from its start until it settles or the next build starts. */
+    protected readonly runningRelinks: Set<DependentRelink>;
+    /** The rules of a repair while a relink's build waited or ran. Only one while it ran gets the next build in the chain. */
+    protected readonly repairedAgain: WeakMap<DependentRelink, readonly IntegrityRule<AstNode>[]>;
+    /**
+     * Marks {@link scheduledRelinks} running as their builds start. Set on the
+     * first request only so it subscribes once, and never disposed.
+     */
+    protected relinkStarts?: Disposable;
+    /** See {@link IntegrityServiceOptions.maxRelinkChain}. */
+    protected readonly maxRelinkChain: number;
+    /** The rules that mutated each document in its latest `Linked`-phase {@link enforceIntegrity} pass, so a warning can name them. */
+    protected readonly mutatingRules: WeakMap<LangiumDocument<AstNode>, Set<IntegrityRule<AstNode>>>;
     constructor(services: ServerLanguageServices, options?: IntegrityServiceOptions);
     /**
      * Enforce all rules for `phase` across a batch of documents that have
@@ -160,6 +209,12 @@ export declare class DefaultIntegrityService<TRoot extends AstNode = AstNode> im
     register<T extends AstNode>(rule: IntegrityRule<T>): Disposable;
     /** Remove a rule by id. Returns `true` if a rule was removed. Useful for adopters that want to swap a built-in rule. */
     unregister(id: string): boolean;
+    /**
+     * Seam: does the parse of `document` lack some of its text? {@link enforceBatch}
+     * runs no rule on such a document, because a repair is written back by
+     * serializing the AST, and a recovered AST lacks what the parser skipped.
+     */
+    protected isStructurallyBroken(document: LangiumDocument): boolean;
     /**
      * Run all rules for the given phase against matching AST nodes. Returns
      * `true` if any rule mutated the AST.
@@ -178,41 +233,166 @@ export declare class DefaultIntegrityService<TRoot extends AstNode = AstNode> im
      * full rule sweep) — coarser than per (node × rule) to avoid a microtask
      * per inner iteration, finer than per-document so a long-running rule set
      * on a large file can still interrupt mid-stream. Throws
-     * `OperationCancelled` when the token is cancelled; Langium's build
-     * pipeline absorbs the throw at the lock-holder.
+     * `OperationCancelled` when the token is cancelled before any rule mutated
+     * the AST; Langium's build pipeline absorbs the throw at the lock-holder.
+     * After a mutation it stops the sweep and returns `true` instead, so the
+     * caller can resync what was mutated before the cancellation unwinds.
      */
     enforceIntegrity(document: LangiumDocument, phase: DocumentState, cancelToken?: CancellationToken, session?: ProfileSession): Promise<boolean>;
     /**
      * Re-serialise the document text after AST mutations, propagate corrections,
      * and re-parse at Parsed phase (safe because linking hasn't occurred yet).
      *
-     * `cancelToken` is checked at entry so a preempted build skips the
-     * serialise / disk-write atomic; the steps inside resync are not further
-     * subdivided because each is a single fast operation that does not yield
-     * a natural interruption point.
+     * Runs to the end whatever `cancelToken` says: the AST is already mutated,
+     * and skipping the resync leaves it against unchanged text that the next
+     * build does not re-parse. `cancelToken` reaches only the re-parse.
      */
     protected resyncDocument(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Bring `document` back into agreement with the text it is supposed to
+     * describe, after a rule has mutated its AST.
+     *
+     * Used for a correction that was applied and for one that was abandoned,
+     * because the document is left inconsistent either way: applied, the text
+     * moved under the CST; abandoned, the AST carries a mutation the text never
+     * had. Both are the same question — re-read and re-derive — and the phase is
+     * what decides how far that has to go.
+     */
+    protected reconcileDocument(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+    /**
+     * Relink the documents that reference `document` in a build after this
+     * one, where it counts as changed. They were linked before the repair, so
+     * they hold nodes a re-parse replaced, or names the repair changed.
+     *
+     * Each document has at most one such build, its {@link DependentRelink},
+     * which goes through four steps.
+     *
+     * 1. Requested here, and kept in {@link relinkBuilds}. A repair while it
+     *    waits is relinked by it.
+     * 2. Checked inside the lock, which skips it unless {@link isRelinkNeeded}.
+     *    A needed one joins {@link scheduledRelinks}. While a build outside the
+     *    lock runs, it is requested again once that build ends.
+     * 3. Started, when `onUpdate` reports its build. An explicit `build` starts
+     *    none. It is in {@link runningRelinks} until it settles or the next
+     *    build starts that overlaps no other. A repair while it runs is kept in
+     *    {@link repairedAgain} and gets the next build.
+     * 4. Settled, when its request resolves, which drops it from every record.
+     *
+     * A repair of a document that a running build relinked continues that
+     * build's chain, which {@link maxRelinkChain} bounds. A repair with the
+     * {@link replayKey} of the one before requests none.
+     */
+    protected relinkDependents(document: LangiumDocument, repair: IntegrityRepairTexts): void;
+    /**
+     * Whether a build where `changed` counts as changed relinks `document`, as
+     * Langium's `shouldRelink` decides. Read from the document's links, because
+     * its build has dropped its indexed references until it indexes again.
+     */
+    protected isRelinkedBy(document: LangiumDocument, changed: LangiumDocument): boolean;
+    /**
+     * Request the build at `chain`, or warn naming `rules` past
+     * {@link maxRelinkChain} and drop the {@link replayKey} of `document`.
+     * Returns whether it requested the build.
+     */
+    protected relinkInChain(document: LangiumDocument, chain: number, rules: readonly IntegrityRule[]): boolean;
+    /** Request the build {@link relinkInChain} decided on, skipped unless {@link isRelinkNeeded}. */
+    protected requestRelink(document: LangiumDocument, chain: number): void;
+    /** Mark the {@link scheduledRelinks} of the `changed` documents running, as the build that carries them starts. */
+    protected startRelinks(changed: readonly URI[]): void;
+    /**
+     * Whether a build where `document` counts as changed relinks another
+     * document, by the builder's own test, which counts a document a cancelled
+     * build left unindexed as relinked.
+     */
+    protected isRelinkNeeded(document: LangiumDocument): boolean;
+    /**
+     * Whether `document` stages its repairs rather than writing them, as a
+     * closed document does in `'editor'` mode, so its source keeps the
+     * unrepaired text.
+     */
+    protected stagesRepairs(document: LangiumDocument): boolean;
+    /**
+     * What tells `repair` made again from the same text apart from a new one,
+     * for a document that {@link stagesRepairs}, which reads the unrepaired
+     * text again in every build that re-parses it after its CST was shed. Such
+     * a repair requests no build, because the build that re-parsed the
+     * document relinked its dependents, and another would replay it again.
+     * Hashes, so the record keeps no text the shed freed.
+     */
+    protected replayKey(document: LangiumDocument, repair: IntegrityRepairTexts): string | undefined;
+    /**
+     * Drop the {@link replayKey} of `document` once it was parsed from other
+     * text than its repair came from, such as a save and a revert. A repair of
+     * that text again is a new one, whose dependents need their build.
+     */
+    protected forgetReplayOfOtherText(document: LangiumDocument): void;
     /**
      * Propagate a correction to disk and/or the editor. The corrected text is
      * already in the synced store (in-place in {@link resyncDocument}); this
      * method routes the out-of-band part by document registration:
      *
-     * - **Open in the language client** → nothing to push here. The AST mutation
-     *   rode the current build, so `ModelService.syncToLanguageClient` (the
-     *   persistent integrity-settled listener) mirrors the corrected text to the
-     *   client by *content* (shadow diff) — no authorship rewrite, no second
-     *   rebuild.
+     * - **Open in the language client** → nothing to push here. The AST
+     *   mutation rode the current build, so
+     *   `DefaultModelService.syncToLanguageClient` (the persistent
+     *   integrity-settled listener) mirrors it to the client by
+     *   *content* (shadow diff), and the editor shows it as an unsaved change.
+     * - **Held only through the data or GLSP head**, or waiting out the release
+     *   grace after its last client's connection was lost → the store is the
+     *   authority, and those heads read the correction from the settled build.
+     *   In silent mode it is also written to disk when the text it was computed
+     *   from is what disk holds, since the repair is then the only difference;
+     *   otherwise it waits for the next save. Editor mode always waits, and the
+     *   repair leaves the document dirty until a save.
      * - **Closed, silent mode** → write to disk directly (disk is authoritative).
-     * - **Closed, editor mode** → stage so the next open picks it up via applyEdit.
+     * - **Closed, editor mode** → stage, so the next open takes the correction
+     *   over the disk text.
+     *
+     * A held URI is not closed. Writing it as one persists the holder's unsaved
+     * edits with the repair, and staging it leaves text no open reads, because
+     * only a first open consumes the stage.
+     *
+     * `parsedFrom` is the text the repaired AST was parsed from. Without it a
+     * held URI's repair is left to the next save.
+     */
+    protected syncCorrections(document: TextDocument, parsedFrom?: string): Promise<void>;
+    /**
+     * Write the repair in `document` to disk when disk still holds `parsedFrom`,
+     * the text the repair was computed from — so the write carries the repair
+     * and nothing a holder could still discard.
+     *
+     * The read, the compare and the write run as one task in the file's task
+     * queue, so no save of the file lands between them. The store is compared
+     * again once the read returns, and the write is skipped if it no longer
+     * holds the repair: an edit does not wait for the queue, and writing the
+     * older repair then puts text on disk that no participant holds. The
+     * skipped repair loses nothing: the edit drives a build of its own, and a
+     * save writes the store's text. A file that cannot be read is left alone
+     * too: there is no evidence it matches. So is a file an editor opened in the
+     * meantime: the editor receives the repair as an unsaved change, and writing
+     * it would change the file under the editor.
+     */
+    protected persistIfDiskMatches(document: TextDocument, parsedFrom: string): Promise<void>;
+    /**
+     * Hand the first repair written to disk in `'silent'` sync mode to
+     * {@link reportSilentWrite}. Once per server, whichever language writes,
+     * rather than per file: a workspace-wide repair pass would otherwise log a
+     * line per document.
+     */
+    protected noteSilentWrite(uri: string): void;
+    /**
+     * Log a server's first silent write-back, so an adopter learns that
+     * integrity rules edit their files and which setting controls it.
      */
-    protected syncCorrections(document: TextDocument): Promise<void>;
+    protected reportSilentWrite(uri: string): void;
     /**
      * Format a rule's name for inclusion in user-facing diagnostic strings
-     * (error messages thrown during registration). Defaults to
+     * (error messages thrown during registration, and log lines). Defaults to
      * `label ?? id`. Adopters override when their error reporting needs
      * richer rule context.
      */
     protected formatRule(rule: IntegrityRule): string;
+    /** `rules` as the subject of a log line, or a rule left unnamed when an override recorded none. */
+    protected formatRules(rules: readonly IntegrityRule[]): string;
     /**
      * Format an AST node for the per-mutation `trace` log line. Returns
      * `'TypeName'` or `"TypeName('label')"` when the node carries a string
@@ -221,6 +401,14 @@ export declare class DefaultIntegrityService<TRoot extends AstNode = AstNode> im
      * domain-specific context.
      */
     protected formatNode(node: AstNode): string;
-    protected getPhaseBucket(phase: DocumentState): readonly IntegrityRule[];
+    /**
+     * The `$type`s `rule` runs on. Defaults to its `nodeType` and every subtype,
+     * as Langium's validation registry does: no node carries an abstract or union
+     * type as its `$type`, so an exact match never runs a rule keyed on one.
+     * Read only when the phase buckets rebuild after a registration change, so an
+     * override must not depend on anything else.
+     */
+    protected nodeTypesFor(rule: IntegrityRule): Iterable<string>;
+    protected getPhaseBucket(phase: DocumentState): ReadonlyMap<string, readonly IntegrityRule[]>;
 }
 //# sourceMappingURL=integrity-service.d.ts.map

package/lib/langium/integrity/integrity-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrity-service.d.ts","sourceRoot":"","sources":["../../../src/langium/integrity/integrity-service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"integrity-service.d.ts","sourceRoot":"","sources":["../../../src/langium/integrity/integrity-service.ts"],"names":[],"mappings":"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"}