@hydranium/core 1.0.0-next.10

package/lib/langium/scope/hydranium-scope-provider.d.ts

@@ -0,0 +1,411 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type Tracer, type ReferenceContext, type ReferenceRequest, type ReferenceSource, type SyntheticSource } from '@hydranium/protocol';
+import { type AstNode, type AstNodeDescription, type AstNodeLocator, DefaultScopeProvider, type LangiumDocuments, type ReferenceInfo, type Scope, type ScopeOptions, type URI, WorkspaceCache } from '@hydranium/langium';
+import { type LogNameOptions } from '../diagnostics/logger.js';
+import { type HydraniumLanguageServices } from '../language-module.js';
+import { type NameProvider } from '../naming/name-provider.js';
+import { type ScopeExtensionService } from './scope-extension-service.js';
+/**
+ * Construction-time options for {@link HydraniumScopeProvider}. Extends
+ * {@link LogNameOptions} so the standard `logName?` field
+ * carries through.
+ */
+export interface HydraniumScopeProviderOptions extends LogNameOptions {
+    /**
+     * When `true`, own-project `'public'`-tier descriptions are visible
+     * from within their owning project's resolution scope — i.e. the
+     * own-project canonical filter is relaxed for public-tier descriptions
+     * whose `projectId` matches the source's project.
+     *
+     * Adopters that use the project-qualified name as a reference form
+     * within their own project enable this. Default `false` matches the
+     * strict multi-tier emission pattern where the project-tier short name
+     * is the canonical reference within the owning project.
+     *
+     * This affects the **resolution** scope only. The completion pipeline's
+     * canonical filter (see `DefaultReferenceCandidateProvider` and
+     * `HydraniumCompletionProvider`) independently collapses tier-siblings
+     * to the canonical tier, so a user still sees one entry per node in
+     * dropdowns even when this option is `true`.
+     */
+    readonly includeOwnProjectPublic?: boolean;
+}
+/**
+ * Per-query context shared across the three sub-scope factory hooks of
+ * {@link HydraniumScopeProvider}. Built once per scope build by
+ * {@link HydraniumScopeProvider.makeScopeContext}, which walks the global
+ * scope exactly once and partitions it into per-tier buckets via
+ * {@link HydraniumScopeProvider.bucketFor}. The sub-scope hooks wrap their
+ * bucket (or re-read {@link descriptions} to widen) without re-walking
+ * the index.
+ */
+export interface ScopeContext {
+    /** Owning project id of the source URI. */
+    readonly sourceProjectId: string;
+    /** Visibility closure of {@link sourceProjectId} (includes itself). */
+    readonly visibleProjectIds: ReadonlySet<string>;
+    /** Materialised global-scope descriptions for the queried reference type. */
+    readonly descriptions: readonly AstNodeDescription[];
+    /** Descriptions routed to the own-project tier (single-pass partition). */
+    readonly ownProjectEntries: readonly AstNodeDescription[];
+    /** Descriptions routed to the dependency-projects tier. */
+    readonly dependencyEntries: readonly AstNodeDescription[];
+    /** Descriptions routed to the universal tier. */
+    readonly universalEntries: readonly AstNodeDescription[];
+}
+/**
+ * Per-language scope provider that owns the full scope chain in ONE
+ * class. Bridges the protocol-layer {@link ReferenceContext} to
+ * Langium's {@link ReferenceInfo}, layers per-context scope-extension
+ * contributions ({@link ScopeExtensionService}) at their declared tier,
+ * and composes the cached project-tier chain (own-project → dependency
+ * → universal) on top of Langium's unfiltered global index.
+ *
+ * ## Scope chain (high → low, inner shadows outer)
+ *
+ * ```
+ *   document-local (Langium precomputed)        [DefaultScopeProvider.getScope]
+ *     extension:local                           [layerLocalExtension, per-context]
+ *       own-project → dependency → universal-index   [createGlobalScope default, CACHED per ${project}::${refType}]
+ *         extension:universal                   [layerUniversalExtension, per-context, outermost]
+ * ```
+ *
+ * Implementation: Langium's `getScope` layers document-local on top of
+ * whatever `getGlobalScope` returns. The framework owns `getGlobalScope`
+ * and uses it to assemble everything *below* document-local, with the
+ * adopter-overridable {@link createGlobalScope} in the middle.
+ *
+ * ## Adopter override surface
+ *
+ * - **{@link createGlobalScope}** — the SINGLE level adopters override
+ *   to change the per-context global/project scope. Because extension
+ *   layering lives in framework-owned `getGlobalScope` outside
+ *   `createGlobalScope`, an adopter's bypass cannot hide the extension
+ *   layers.
+ * - Tier-walk hooks ({@link makeScopeContext}, {@link bucketFor},
+ *   {@link createOwnProjectScope}, {@link createDependencyScope},
+ *   {@link createUniversalScope}, {@link chainScopes},
+ *   {@link getProjectIdForDescription}) — override an individual tier
+ *   without re-implementing the whole project-tier walk.
+ * - Source-resolution hooks ({@link resolveSyntheticSource},
+ *   {@link resolveRootElement}, {@link resolveElementByName}) — override
+ *   individual cases of the `ReferenceSource` switch.
+ * - **{@link createScopeForNodes}** — inherited from Langium and re-keyed by
+ *   the framework to bare own-names, so it is the helper a `getScope`
+ *   override uses to resolve a dotted member reference against a container
+ *   the reference chain cannot reach.
+ *
+ * **Do NOT override `getGlobalScope` itself** — that is the framework's
+ * extension-assembly seam. Overriding it would hide the scope-extension
+ * layers behind your override.
+ *
+ * **Owns scope construction and reference resolution.** The complementary
+ * candidate-side pipeline (filter / sort / dedupe / build wire DTO) lives
+ * on `ReferenceCandidateProvider` in the sibling
+ * `reference-candidate-provider.ts` module.
+ */
+export declare class HydraniumScopeProvider extends DefaultScopeProvider {
+    protected readonly services: HydraniumLanguageServices;
+    protected readonly langiumDocuments: LangiumDocuments;
+    protected readonly astNodeLocator: AstNodeLocator;
+    protected readonly scopeExtensionService: ScopeExtensionService;
+    protected readonly options: HydraniumScopeProviderOptions;
+    /**
+     * Cache keyed by `${sourceProjectId}::${referenceType}`. Result is
+     * the chained `project → public → universal` scope built from one
+     * single-pass partition over the global index. Evicted by
+     * Langium's `DocumentBuilder.onUpdate` (the `WorkspaceCache` default)
+     * so any index change rebuilds.
+     *
+     * Per-language by design — the cache key already includes `refType`,
+     * which is language-specific, so nothing is shared across languages
+     * even though the `WorkspaceCache(services.shared)` instance evicts on
+     * the workspace-global `DocumentBuilder.onUpdate`.
+     */
+    protected readonly scopeCache: WorkspaceCache<string, Scope>;
+    protected readonly tracer: Tracer;
+    /**
+     * Narrows the inherited Langium {@link NameProvider} field to the framework's
+     * {@link NameProvider} so call sites read `this.nameProvider.nameSeparator`
+     * without a per-callsite cast. Bound by the framework's
+     * `createServerLanguageModule` to a `DefaultNameProvider` subclass instance.
+     */
+    protected readonly nameProvider: NameProvider;
+    constructor(services: HydraniumLanguageServices, options?: HydraniumScopeProviderOptions);
+    /**
+     * Framework-owned assembly seam. **Adopters do NOT override this** —
+     * override {@link createGlobalScope} instead. This method layers the
+     * scope-extension tiers around the adopter-overridable global scope.
+     *
+     * Langium's `DefaultScopeProvider.getScope` then layers document-local
+     * on top of this result, yielding the full chain documented on the
+     * class.
+     */
+    protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
+    /**
+     * The SINGLE adopter-overridable level of the project/global scope.
+     * Adopters override to change the per-context global scope for
+     * specific reference contexts — e.g. return `EMPTY_SCOPE` to suppress
+     * the global scope entirely (so only document-local + extension:local
+     * remain), or return a raw unfiltered scope to bypass the project-tier
+     * filter for specific reference types.
+     *
+     * Default: builds the cached project-tier chain (own-project →
+     * dependency → universal) on top of Langium's unfiltered global index,
+     * keyed `${sourceProjectId}::${refType}` and evicted on workspace
+     * update. Returns the input scope unchanged when:
+     * - The source URI has no owning project (URIs outside any registered
+     *   project folder).
+     * - `ProjectManager.isSingleProject` reports `true` — the project
+     *   filter would be a no-op in a single-project workspace (the
+     *   synthetic workspace project owns everything, every tier is the
+     *   source's own tier).
+     *
+     * Adopters bypassing the tier filter should call
+     * {@link getAllElementsGlobalScope} to obtain the complete global
+     * scope (every element of the requested type, regardless of tier
+     * visibility), or `super.getGlobalScope` directly when even the
+     * helper is too much indirection.
+     */
+    protected createGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
+    /**
+     * Layer scope-extension `local`-tier descriptions on top of `inner`.
+     * Returns `inner` unchanged when no extension contributes for the
+     * reference type (zero-cost common path).
+     */
+    protected layerLocalExtension(referenceType: string, context: ReferenceInfo, inner: Scope): Scope;
+    /**
+     * Layer scope-extension `universal`-tier descriptions BELOW `inner`
+     * (extensions appear last in the chain, shadowed by inner). Returns
+     * `inner` unchanged when no extension contributes for the reference
+     * type.
+     */
+    protected layerUniversalExtension(referenceType: string, context: ReferenceInfo, inner: Scope): Scope;
+    /**
+     * Project-tier scope filter. Given a source URI and a global scope,
+     * returns the subset of descriptions whose owning project is visible
+     * from the URI's owning project — the project-dependency visibility
+     * model. Cached per `${sourceProjectId}::${referenceType}`.
+     *
+     * `referenceType` is part of the cache key — separate scopes per
+     * cross-reference type so name collisions across types don't shadow
+     * each other in the chain.
+     *
+     * Public for adopter consumption: code outside the scope chain that
+     * wants to apply the same project-tier filter to a custom scope (e.g.
+     * a candidate provider's introspection mode) calls this method.
+     */
+    getProjectScope(sourceUri: URI, globalScope: Scope, referenceType: string): Scope;
+    /**
+     * The complete global scope — every element of the requested
+     * reference type that the workspace knows about, with no tier
+     * filtering and no extension-layer composition. Use from inside a
+     * {@link createGlobalScope} override when a specific context needs
+     * to bypass the framework's project-tier visibility filter (e.g.
+     * a self-referential cross-reference that must see all candidate
+     * projects, including those outside the source's visibility
+     * closure).
+     *
+     * Contrast {@link getGlobalScope}, which applies the framework's
+     * tier filter to this set, and `getScope` (Langium default), which
+     * additionally merges in the local scope.
+     */
+    protected getAllElementsGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
+    /**
+     * Build the chained project scope from three tier sub-scopes. The
+     * single scope walk happens once in {@link makeScopeContext}; the
+     * sub-scope hooks classify the materialised array via {@link bucketFor}
+     * (cheap in-memory filtering, no extra scope/index walk). Chained
+     * inner-first so a more specific tier shadows a less specific one of
+     * the same name: own-project → dependency-projects → universal.
+     */
+    protected buildProjectScope(sourceProjectId: string, globalScope: Scope): Scope;
+    /**
+     * Build the per-query {@link ScopeContext}. Walks `globalScope` exactly
+     * once (the one scope walk per cache miss) and partitions it into
+     * per-tier buckets via a single pass over {@link bucketFor}, so the
+     * untagged URI-lookup fallback runs at most once per description.
+     */
+    protected makeScopeContext(sourceProjectId: string, globalScope: Scope): ScopeContext;
+    /**
+     * Own-project sub-scope — descriptions in the source's own project.
+     * Includes own-project `'public'`-tier descriptions when
+     * {@link HydraniumScopeProviderOptions.includeOwnProjectPublic} is set
+     * (routed to the own-project bucket by {@link bucketFor}). Returns a
+     * {@link StreamScope} (not {@link MapScope}) so same-name siblings are
+     * preserved rather than collapsed.
+     */
+    protected createOwnProjectScope(context: ScopeContext): Scope;
+    /**
+     * Dependency-projects sub-scope — `'public'`-tier descriptions whose
+     * owning project is reachable through the source's dependency closure
+     * (own-project canonical filter applied by {@link bucketFor}).
+     */
+    protected createDependencyScope(context: ScopeContext): Scope;
+    /**
+     * Universal sub-scope — descriptions with no project association,
+     * visible everywhere unconditionally.
+     */
+    protected createUniversalScope(context: ScopeContext): Scope;
+    /**
+     * Chain three tier sub-scopes inner-first. The `outerScope` argument
+     * of {@link StreamScope} is consulted only when the inner stream has
+     * no match, so a more specific tier shadows a less specific one of
+     * the same name.
+     */
+    protected chainScopes(ownScope: Scope, dependencyScope: Scope, universalScope: Scope): Scope;
+    /**
+     * Classify a description into one of three sub-scope buckets, or
+     * `'hidden'` when it should not appear in the project-scope chain.
+     *
+     * Typed path (description carries `tier`):
+     * - `'local'` → hidden (defensive — locals belong to per-document map)
+     * - `'project'` → `'project'` iff `projectId === sourceProjectId`,
+     *   else hidden (equality check)
+     * - `'public'` → `'public'` iff `projectId !== sourceProjectId` AND
+     *   `projectId` in source's visibility closure; own-project public is
+     *   routed to `'project'` when
+     *   {@link HydraniumScopeProviderOptions.includeOwnProjectPublic} is
+     *   set, else hidden (own-project canonical filter + closure
+     *   membership)
+     * - `'universal'` → `'universal'` unconditionally
+     *
+     * Untagged path (no `tier` field) — preserved for backward-compat with
+     * third-party Langium services emitting plain descriptions: URI →
+     * project lookup via {@link getProjectIdForDescription}, then the same
+     * bucketing rule.
+     */
+    protected bucketFor(description: AstNodeDescription, sourceProjectId: string, visibleProjectIds: ReadonlySet<string>): 'project' | 'public' | 'universal' | 'hidden';
+    /**
+     * Map a description to its owning project's id. Default: look up via
+     * `ProjectManager.getProject(description.documentUri)`. A pure fallback
+     * path — consulted only for descriptions carrying no `tier` field.
+     */
+    protected getProjectIdForDescription(description: AstNodeDescription): string | undefined;
+    /**
+     * Keys the scope by {@link NameProvider.getOwnName} instead of Langium's
+     * `getName`. Same correction `HydraniumScopeComputation.addLocalSymbol`
+     * makes to the local-symbols pass, for the same reason: `getName` defaults
+     * to the project-qualified form here, so the base would key a member scope
+     * by the fully qualified `Container.member` while the reference text after
+     * the dot is the bare `member` — and nothing reports the mismatch, because
+     * the scope is non-empty and only the lookup misses.
+     *
+     * Callers building a member scope should leave `outerScope` unset: a
+     * reference to a member the container does not have must fail rather than
+     * fall through to a same-named member on an unrelated type.
+     */
+    protected createScopeForNodes(elements: Iterable<AstNode>, outerScope?: Scope, options?: ScopeOptions): Scope;
+    /**
+     * Convert a protocol-layer {@link ReferenceContext} into a Langium
+     * {@link ReferenceInfo} the rest of the scope/linking machinery accepts.
+     *
+     * Walks `syntheticPath` by FABRICATING a type-only stub per step, so a
+     * scope can be queried for an element that does not exist yet — which is
+     * what synthetic paths are for. The stubs carry no children, so a caller
+     * that needs to read a collection off the leaf wants
+     * {@link resolveReferenceSource} instead, which walks the same path into
+     * the real tree.
+     *
+     * Throws if the context references an unresolvable source; callers
+     * that prefer a soft failure should catch and fall back to
+     * `EMPTY_SCOPE`.
+     */
+    referenceContextToInfo(ctx: ReferenceContext): ReferenceInfo;
+    /**
+     * Resolve a protocol-layer {@link ReferenceRequest} via the scope built for
+     * its context. Returns `undefined` if the scope has no matching element or
+     * if the description can't be resolved to a node.
+     */
+    resolveReference(reference: ReferenceRequest): AstNode | undefined;
+    /**
+     * Resolve the SOURCE side of a reference — the element a query is asked
+     * *from* — to a real node. Given a bare {@link ReferenceSource} it resolves
+     * the anchor; given a whole {@link ReferenceContext} it continues along
+     * `syntheticPath`, descending into the anchor's real children, and answers
+     * the leaf.
+     *
+     * The counterpart to {@link resolveReference}, which resolves the other end:
+     * that one answers what a reference POINTS AT, this one what the reference
+     * is written ON. Distinct again from {@link referenceContextToInfo}, which
+     * walks the same path but FABRICATES a type-only stub per step — the right
+     * shape for a scope query, the wrong one for reading a collection off the
+     * leaf, because a fabricated node has no children.
+     *
+     * A step addressing an array slot must carry `index`; without one the walk
+     * stops rather than descending into the array itself, since an array is not
+     * an `AstNode` and continuing would fail later somewhere unrelated. A step's
+     * `type` is NOT verified against the child that was found — it names what
+     * the caller expects, and narrowing on it would reject trees a permissive
+     * adopter grammar allows.
+     *
+     * Answers `undefined` as soon as any step is missing.
+     */
+    resolveReferenceSource(source: ReferenceSource | ReferenceContext): AstNode | undefined;
+    /** Walk `syntheticPath` from the resolved anchor into real children. */
+    protected resolveContextLeaf(ctx: ReferenceContext): AstNode | undefined;
+    /**
+     * Build a transient AST-node stub for a {@link SyntheticSource} request.
+     * Default: looks up the document via `LangiumDocuments` and uses its parse
+     * root as the container; returns `undefined` if the document isn't loaded.
+     * Consumers that need to materialise an empty document on demand (e.g.
+     * to query the scope before a file exists) override this.
+     */
+    protected resolveSyntheticSource(source: SyntheticSource): AstNode | undefined;
+    /**
+     * Resolve the semantic root node of the document at `uri`. Default: looks
+     * up the document via `LangiumDocuments` and returns its parse-result root.
+     * Consumers with a custom "semantic root" notion (i.e. an inner element
+     * that is the meaningful root inside a wrapper grammar) override this.
+     */
+    protected resolveRootElement(uri: URI): AstNode | undefined;
+    /**
+     * Resolve a node by **name**, given an optional reference type for
+     * disambiguation.
+     *
+     * The contract on `name`:
+     *
+     * - It is a **qualified name** — the form a source-text writer would type,
+     *   normally `NameProvider.getProjectQualifiedName`. Not a bare own-name,
+     *   unless the adopter's naming scheme makes the two coincide.
+     * - It is **not rename-stable.** Renaming the element changes its name and
+     *   therefore this address. Callers holding an address across an edit must
+     *   re-derive it.
+     * - It is **distinct from the element key.** `ElementKeyProvider` produces a
+     *   handle that round-trips to a node *within one document* (used for GModel
+     *   ids and UI selection); this resolves a name against the whole workspace.
+     *   Neither substitutes for the other, and there is no framework identifier
+     *   that is both workspace-wide and rename-stable.
+     *
+     * Base implementation returns `undefined` — the framework does not decide
+     * which qualification level an adopter's names carry. Adopters override,
+     * typically by delegating to
+     * `HydraniumIndexManager.resolveElementByName`, which resolves against
+     * the `elementsByName` index that `HydraniumScopeComputation` populates.
+     */
+    protected resolveElementByName(_name: string, _type?: string): AstNode | undefined;
+    /**
+     * Sort key for the candidate provider's
+     * `ReferenceCandidateProvider.getCandidateScope` pipeline. Default
+     * prefixes the qualified-name segment count so local (bare-name)
+     * entries surface before nested (`a.b.c`) entries, then sorts
+     * lexicographically. Adopters whose name provider uses a non-default
+     * separator inherit the default behaviour; adopters wanting a
+     * different rank override.
+     *
+     * Public because the LSP `CompletionProvider` reads the same sort key
+     * directly when assembling completion items, and the sibling candidate
+     * provider in `reference-candidate-provider.ts` reads it during
+     * its sort stage. Lives on the scope provider so both callers share
+     * one implementation.
+     */
+    sortText(description: AstNodeDescription): string;
+}
+//# sourceMappingURL=hydranium-scope-provider.d.ts.map

package/lib/langium/scope/hydranium-scope-provider.d.ts.map

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