xq-lsp 1.8.2 → 1.8.3-next.428

package/README.md

@@ -12,7 +12,7 @@ Language Server Protocol implementation for XQuery, providing autocompletion, ho
 - **Signature help** — active parameter hints inside function calls
 - **Go to definition** — jump to function or variable declarations, including across imported files
 - **Document symbols** — file outline of all declared functions and variables
-- **Diagnostics** — syntax errors, undeclared namespace prefixes, type mismatches, and unused symbols
+- **Diagnostics** — syntax errors, undeclared namespace prefixes, type mismatches, and unused symbols — pushed on change, and also available on request via LSP 3.17 pull diagnostics (`textDocument/diagnostic`), including for files that are not open
 
 ## Configuration
 
@@ -148,14 +148,6 @@ map {
 - **Context-depending completion** — which prevent syntactical errors
 - **Treesitter parser** — should improve performance and scalability for huge files
 - **XQuery 4** — the parser already supports this. Just make it work
-- **Arity checks** — report when one calls `fn:document('too', 'many', 'arguments')`
-- **Register or discover known prefix/namespace combinations** — if you have the `tei` namespace
-  declared in another file, you might mean that when you type `tei:TEI` in another file
-- **Context items** — doing `declare function xx () { bla };` is an error: there is no context
-  item. Check if there is a context item available when you use the context item expression (`.`) or
-  a step expression.
-- **Unused functions and variables** — no one likes those. Except when prefixed with `_`, then they
-  make sense
 - More of the (static) errors in the spec at [The spec at section F Error
   Conditions](https://www.w3.org/TR/xquery-31/#id-errors), whichever are easy to implement
 
@@ -193,6 +185,12 @@ Open any `.xq` file and eglot starts the server automatically. Run `M-x eglot` t
 | Document symbols | `M-x imenu`                           |
 | Diagnostics      | `M-x flymake-show-buffer-diagnostics` |
 
+**Inlay hints** (inferred types after untyped `let`/`for`/`declare variable` names, and
+parameter names before call arguments) are shown by `eglot-inlay-hints-mode`, which eglot
+turns on automatically since Emacs 29.1. If they don't appear, check that `:inlayHintProvider`
+isn't listed in `eglot-ignored-server-capabilities`, or toggle them with
+`M-x eglot-inlay-hints-mode`.
+
 ### With lsp-mode
 
 ```elisp
@@ -209,6 +207,15 @@ Open any `.xq` file and eglot starts the server automatically. Run `M-x eglot` t
 (add-hook 'xquery-mode-hook #'lsp)
 ```
 
+lsp-mode does not show inlay hints unless asked to:
+
+```elisp
+(setq lsp-inlay-hint-enable t)
+```
+
+The reference counts above each function and module variable are code lenses; lsp-mode shows
+them by default (`lsp-lens-enable`). Eglot does not support code lenses.
+
 ## VS Code
 
 A minimal VS Code extension lives in [`editors/vscode/`](./editors/vscode/).

package/builtins/builtins-fn.xq

@@ -193,7 +193,7 @@ declare function fn:format-number($value as xs:numeric?, $picture as xs:string)
 declare function fn:format-number(
 	$value as xs:numeric?,
 	$picture as xs:string,
-	$decimal-format-name as xs:string
+	$decimal-format-name as xs:string?
 ) as xs:string external;
 
 (: ── String functions ───────────────────────────────────────────────────────── :)

package/dist/analyzer.d.ts

@@ -7,6 +7,7 @@ export declare const XMLNS_XSI = "http://www.w3.org/2001/XMLSchema-instance";
 export declare const XMLNS_MATH = "http://www.w3.org/2005/xpath-functions/math";
 export declare const XMLNS_MAP = "http://www.w3.org/2005/xpath-functions/map";
 export declare const XMLNS_ARRAY = "http://www.w3.org/2005/xpath-functions/array";
+export declare const BUILTIN_PREFIXES: Record<string, string>;
 /**
  * Resolve a namespace prefix to its URI given the namespace context of a file.
  * Unprefixed calls (prefix="") resolve to the file's default function namespace.

package/dist/analyzer.js

@@ -12,7 +12,7 @@ export const XMLNS_ARRAY = "http://www.w3.org/2005/xpath-functions/array";
 // context, independent of any runtime/library configuration. math/map/array
 // aren't spec-mandated but are universally available in practice (they back
 // the 3.1 map/array/math core function libraries), so they're predeclared here too.
-const BUILTIN_PREFIXES = {
+export const BUILTIN_PREFIXES = {
     fn: XMLNS_FN,
     local: XMLNS_LOCAL,
     xs: XMLNS_XS,
@@ -160,7 +160,10 @@ function findPrecedingDoc(comments, text, offset) {
 }
 // ── Namespace helpers ────────────────────────────────────────────────────────
 function extractModuleNamespace(text) {
-    const m = text.match(/module\s+namespace\s+([\w\-]+)\s*=\s*["']([^"']*)["']/);
+    // The negative lookbehind excludes `import module namespace ...` — a module
+    // import, not this file's own `module namespace` declaration — which would
+    // otherwise match the same pattern and be mistaken for it.
+    const m = text.match(/(?<!import\s+)\bmodule\s+namespace\s+([\w\-]+)\s*=\s*["']([^"']*)["']/);
     return m ? { prefix: m[1], uri: m[2] } : undefined;
 }
 function extractDefaultFunctionNamespace(text) {
@@ -180,6 +183,23 @@ function buildPrefixMap(moduleNs, imports, namespaceDecls) {
 function resolveNamespaceUri(prefix, prefixMap) {
     return prefixMap.get(prefix) ?? `urn:xq-lsp:undeclared:${prefix}`;
 }
+const PREDEFINED_ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+/**
+ * A BracedURILiteral's content may contain PredefinedEntityRef (&amp; &lt; &gt;
+ * &quot; &apos;) and CharRef (&#DDDD; / &#xHHHH;) escapes, same as string content —
+ * e.g. `Q{http:&#x2F;&#x2F;example.com}` names the URI "http://example.com". The
+ * parser's terminal value is the raw, un-decoded source slice, so this decoding
+ * has to happen here rather than being assumed already done.
+ */
+function decodeCharRefs(text) {
+    return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, (match, ref) => {
+        if (ref[0] === "#") {
+            const codePoint = ref[1] === "x" ? parseInt(ref.slice(2), 16) : parseInt(ref.slice(1), 10);
+            return Number.isNaN(codePoint) ? match : String.fromCodePoint(codePoint);
+        }
+        return PREDEFINED_ENTITIES[ref] ?? match;
+    });
+}
 /**
  * Per the BracedURILiteral grammar, whitespace inside `Q{...}` is insignificant:
  * leading/trailing whitespace is trimmed and internal runs are collapsed to a
@@ -187,7 +207,7 @@ function resolveNamespaceUri(prefix, prefixMap) {
  * This does not decode percent-escapes — `Q{foo%20bar}` stays distinct from `Q{foo bar}`.
  */
 function normalizeBracedUri(uri) {
-    return uri.trim().replace(/\s+/g, " ");
+    return decodeCharRefs(uri).trim().replace(/\s+/g, " ");
 }
 /**
  * Split a raw EQName terminal into its components, handling both the
@@ -218,6 +238,19 @@ export function sequenceTypeText(text, node) {
         return undefined;
     return text.slice(node.start, node.end ?? undefined).trim() || undefined;
 }
+// A %public/%private annotation on an AnnotatedDecl controls whether the
+// declaration is visible to modules that import it (XQuery 3.0+). Returns
+// undefined when neither annotation is present; callers treat that as public,
+// same as FunctionSymbol.visibility's own default.
+function extractVisibility(annotated) {
+    for (const ann of directChildrenOf(annotated, "Annotation")) {
+        const eqname = directChildOf(ann, "EQName");
+        const raw = eqname ? firstTerminalValue(eqname) : null;
+        if (raw === "private" || raw === "public")
+            return raw;
+    }
+    return undefined;
+}
 function extractFunctions(ast, sourceUri, comments, text, prefixMap, defaultFnNs) {
     const results = [];
     // Use AnnotatedDecl (starts at 'declare') so the comment lookup clears the 'declare' keyword
@@ -261,6 +294,7 @@ function extractFunctions(ast, sourceUri, comments, text, prefixMap, defaultFnNs
             doc,
             sourceUri,
             sourceOffset: annotated.start,
+            visibility: extractVisibility(annotated),
         });
     }
     return results;
@@ -278,12 +312,15 @@ function extractModuleVariables(ast, sourceUri, prefixMap, comments, text) {
         if (!name)
             continue;
         const doc = findPrecedingDoc(comments, text, annotated.start);
+        const typeDecl = directChildOf(varDecl, "TypeDeclaration");
+        const seqType = typeDecl ? directChildOf(typeDecl, "SequenceType") : undefined;
         results.push({
             qname: makeVarQName(name, prefixMap),
             offset: varDecl.start,
             isModuleLevel: true,
             sourceUri,
             doc: doc?.description || undefined,
+            type: seqType ? sequenceTypeText(text, seqType) : undefined,
         });
     }
     return results;
@@ -417,12 +454,15 @@ function analyzeRegex(text, sourceUri) {
     RE_VAR_DECL.lastIndex = 0;
     while ((m = RE_VAR_DECL.exec(text)) !== null) {
         const doc = findPrecedingDocInText(text, m.index);
+        // `declare variable $x as T := …` / `… as T external` — T runs up to `:=` or `external`.
+        const typeMatch = /^\s+as\s+([^;]{1,200}?)\s*(?::=|\bexternal\b)/.exec(text.slice(m.index + m[0].length));
         moduleVariables.push({
             qname: makeVarQName(m[1], prefixMap),
             offset: m.index,
             isModuleLevel: true,
             sourceUri,
             doc: doc?.description || undefined,
+            type: typeMatch?.[1],
         });
     }
     RE_LET.lastIndex = 0;

package/dist/ast-nodes.d.ts

@@ -28,6 +28,33 @@ export interface FunctionDeclShape {
 }
 /** Inner shape of a FunctionDecl node: name, resolved params, and function body. */
 export declare function asFunctionDecl(node: Node, analysis: FileAnalysis): FunctionDeclShape | null;
+/** The version string of `xquery version "x"` (quotes stripped) and its literal node; null when only an encoding is given. */
+export declare function asVersionDecl(node: Node): {
+    version: string;
+    versionNode: Node;
+} | null;
+/** Resolved QName and name node of a `declare option` OptionDecl. */
+export declare function asOptionDecl(node: Node, analysis: FileAnalysis): {
+    qname: QName;
+    nameNode: Node;
+} | null;
+/** Prefix bound by a `declare namespace p = "uri"` NamespaceDecl. */
+export declare function asNamespaceDecl(node: Node): {
+    prefix: string;
+} | null;
+/** Which default namespace a `declare default element|function namespace` DefaultNamespaceDecl sets. */
+export declare function asDefaultNamespaceDecl(node: Node): {
+    kind: "element" | "function";
+} | null;
+export interface DecimalFormatDeclShape {
+    /** Expanded name of the format; "" for the default decimal format. */
+    key: string;
+    properties: Array<{
+        nameNode: Node;
+        name: string;
+    }>;
+}
+export declare function asDecimalFormatDecl(node: Node, analysis: FileAnalysis): DecimalFormatDeclShape | null;
 export interface InlineFunctionExprShape {
     params: Array<{
         nameNode: Node;

package/dist/ast-nodes.js

@@ -113,6 +113,59 @@ export function asFunctionDecl(node, analysis) {
     const params = extractParamsFromParamList(directChildOf(node, "ParamList"), analysis);
     return { nameNode, qname: { prefix, localName, namespaceUri }, params, body: directChildOf(node, "FunctionBody") ?? null };
 }
+// ── Prolog declarations ───────────────────────────────────────────────────────
+/** The version string of `xquery version "x"` (quotes stripped) and its literal node; null when only an encoding is given. */
+export function asVersionDecl(node) {
+    if (node.type !== "VersionDecl" || !directChildOf(node, "'version'"))
+        return null;
+    const versionNode = directChildOf(node, "StringLiteral");
+    const raw = versionNode ? firstTerminalValue(versionNode) : null;
+    if (!versionNode || !raw)
+        return null;
+    // String literals may contain character references, e.g. '1.0'
+    const version = raw
+        .slice(1, -1)
+        .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
+        .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(parseInt(dec, 10)));
+    return { version, versionNode };
+}
+/** Resolved QName and name node of a `declare option` OptionDecl. */
+export function asOptionDecl(node, analysis) {
+    if (node.type !== "OptionDecl")
+        return null;
+    const nameNode = directChildOf(node, "EQName");
+    const qname = nameNode ? qnameFromRawTerminal(nameNode, analysis) : null;
+    return nameNode && qname ? { qname, nameNode } : null;
+}
+/** Prefix bound by a `declare namespace p = "uri"` NamespaceDecl. */
+export function asNamespaceDecl(node) {
+    if (node.type !== "NamespaceDecl")
+        return null;
+    const prefixNode = directChildOf(node, "NCName");
+    const prefix = prefixNode ? firstTerminalValue(prefixNode) : null;
+    return prefix === null ? null : { prefix };
+}
+/** Which default namespace a `declare default element|function namespace` DefaultNamespaceDecl sets. */
+export function asDefaultNamespaceDecl(node) {
+    if (node.type !== "DefaultNamespaceDecl")
+        return null;
+    if (directChildOf(node, "'element'"))
+        return { kind: "element" };
+    if (directChildOf(node, "'function'"))
+        return { kind: "function" };
+    return null;
+}
+export function asDecimalFormatDecl(node, analysis) {
+    if (node.type !== "DecimalFormatDecl")
+        return null;
+    const eqname = directChildOf(node, "EQName");
+    const qname = eqname ? qnameFromRawTerminal(eqname, analysis) : null;
+    const properties = directChildrenOf(node, "DFPropertyName").flatMap((nameNode) => {
+        const name = firstTerminalValue(nameNode);
+        return name ? [{ nameNode, name }] : [];
+    });
+    return { key: qname ? `${qname.namespaceUri}#${qname.localName}` : "", properties };
+}
 export function asInlineFunctionExpr(node, analysis) {
     if (node.type !== "InlineFunctionExpr")
         return null;

package/dist/diagnostics.js

@@ -4,6 +4,7 @@ import { findUndeclaredPrefixUsages } from "./namespace-diagnostics.js";
 import { checkContextItemUsage } from "./context-item-diagnostics.js";
 import { checkUndeclaredVariables } from "./variable-diagnostics.js";
 import { checkDuplicateFunctions } from "./duplicate-function-diagnostics.js";
+import { checkDuplicatePrologDecls } from "./prolog-diagnostics.js";
 import { checkModuleImportTargets } from "./module-import-diagnostics.js";
 import { checkUnused } from "./unused-diagnostics.js";
 import { checkBracedUriWhitespace } from "./braced-uri-diagnostics.js";
@@ -21,6 +22,7 @@ export function runDiagnostics(ast, text, analysis, imports) {
         ...checkContextItemUsage(ast),
         ...checkUndeclaredVariables(ast, analysis, imports),
         ...checkDuplicateFunctions(ast, analysis, imports),
+        ...checkDuplicatePrologDecls(ast, analysis),
         ...checkModuleImportTargets(analysis, imports),
     ];
 }

package/dist/functioncall-diagnostics.d.ts

@@ -4,9 +4,12 @@ import type { TypeDiagnostic, FileAnalysis } from "./types.ts";
  * Walk all FunctionCall, NamedFunctionRef, and ArrowExpr nodes in the AST
  * and report XPST0017 for any call where the argument count does not match
  * any known overload, or where the function name is not declared in a
- * namespace we have analysis for.
+ * namespace this file can call into.
  *
- * If the function's namespace is entirely unknown (no analysis loaded for it),
- * the call is silently skipped — it could be a runtime-only library.
+ * A namespace is only skipped (left unchecked) when it's the target of an
+ * import we couldn't resolve to any analysis, or when the prefix itself is
+ * undeclared (that's findUndeclaredPrefixUsages's concern) — see
+ * accessibleFunctions and checkArity. Every other namespace is closed-world:
+ * not finding a matching declaration there means one doesn't exist.
  */
 export declare function checkFunctionCalls(ast: Node, analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): TypeDiagnostic[];

package/dist/functioncall-diagnostics.js

@@ -1,23 +1,81 @@
 import { formatQName } from "./types.js";
-import { findAll, isTerminal, directChildrenOf, firstTerminalValue, parseEQName, resolvePrefix } from "./analyzer.js";
+import { findAll, isTerminal, directChildrenOf, firstTerminalValue, parseEQName, resolvePrefix, XMLNS_LOCAL, XMLNS_FN, XMLNS_XS, XMLNS_MATH, XMLNS_MAP, XMLNS_ARRAY, } from "./analyzer.js";
 import { asFunctionCall, asNamedFunctionRef } from "./ast-nodes.js";
-function allFunctionsFlat(analysis, importedAnalyses) {
+// Namespaces that are always in scope without an explicit import: the
+// spec-mandated predeclared ones, plus whatever this file declares of its own
+// (local: functions, its own module namespace, and its default function
+// namespace) — we have complete, closed-world knowledge of all of these.
+function alwaysAccessibleNamespaceUris(analysis) {
+    const uris = new Set([XMLNS_LOCAL, XMLNS_FN, XMLNS_XS, XMLNS_MATH, XMLNS_MAP, XMLNS_ARRAY, analysis.defaultFunctionNamespace]);
+    if (analysis.moduleNamespaceUri)
+        uris.add(analysis.moduleNamespaceUri);
+    return uris;
+}
+/**
+ * Gather every function symbol this file can legally call, plus the set of
+ * imported namespace URIs we couldn't resolve to any analysis (unresolvable
+ * "at" path, or an unresolvable bare import — genuinely unknown, so calls
+ * into them are left unchecked to avoid false positives).
+ *
+ * A namespace not covered by any of the above (not declared, not imported,
+ * not predeclared) has zero accessible functions by construction: nothing in
+ * this module's static scope could have brought a function from it into
+ * view, regardless of what happens to be sitting in `importedAnalyses` (the
+ * QT4 harness, for instance, loads catalog modules that were never actually
+ * imported by the query under test, specifically to verify this isn't enough
+ * to make their functions callable).
+ */
+function accessibleFunctions(analysis, importedAnalyses) {
     const fns = [...analysis.functions];
-    for (const a of importedAnalyses.values())
-        fns.push(...a.functions);
-    return fns;
+    const alwaysOpen = alwaysAccessibleNamespaceUris(analysis);
+    const importedNamespaceUris = new Set(analysis.imports.map((i) => i.namespaceUri));
+    // Runtime-predeclared namespaces (e.g. eXist-db's util:, xmldb:) are merged into
+    // namespaceDecls with offset -1 — see withPredeclaredNs — marking them as
+    // implicitly available without a written import. The QT4 harness uses the same
+    // offset -1 convention for <environment><namespace> bindings, which name a
+    // namespace without providing (or requiring) any declaration of what's in it.
+    const predeclaredUris = new Set(analysis.namespaceDecls.filter((nd) => nd.offset === -1).map((nd) => nd.namespaceUri));
+    // Namespaces we might have real knowledge of — but only once we find a matching
+    // entry in importedAnalyses below. Until then, stay silent about them rather
+    // than treating "no analysis available" as "no such function". Namespaces
+    // already in alwaysOpen are excluded: they're already guaranteed accessible
+    // (e.g. builtins arrive under a "builtin:" map key, not one matching their own
+    // namespace URI), so redundantly re-declaring one — as the QT4 harness's
+    // <environment><namespace prefix="map" uri=".../map"/> does — must not make it
+    // look unresolved.
+    const candidateUris = new Set([...importedNamespaceUris, ...predeclaredUris].filter((u) => !alwaysOpen.has(u)));
+    const resolvedUris = new Set();
+    for (const [key, a] of importedAnalyses) {
+        if (key.startsWith("builtin:") || alwaysOpen.has(key)) {
+            fns.push(...a.functions);
+            continue;
+        }
+        if (candidateUris.has(key)) {
+            // A %private function/variable is only visible within its own declaring
+            // module — filter it out for anything reached through an import.
+            fns.push(...a.functions.filter((f) => f.visibility !== "private"));
+            resolvedUris.add(key);
+        }
+    }
+    const unresolvedImportUris = new Set([...candidateUris].filter((u) => !resolvedUris.has(u)));
+    return { fns, unresolvedImportUris };
 }
 function arityDescription(overloads) {
     const arities = [...new Set(overloads.map((f) => f.arity))].sort((a, b) => a - b);
     return overloads.some((f) => f.variadic) ? `${arities[0]} or more` : arities.length === 1 ? `${arities[0]}` : arities.join(" or ");
 }
-function checkArity(qname, arity, nodeStart, allFns, knownNamespaceUris, errors) {
+function checkArity(qname, arity, nodeStart, allFns, unresolvedImportUris, errors) {
     const { namespaceUri, localName } = qname;
+    // A prefix that resolves to nothing at all is a separate diagnostic's
+    // concern (findUndeclaredPrefixUsages) — don't pile on here.
+    if (namespaceUri.startsWith("urn:xq-lsp:undeclared:"))
+        return;
+    // An import we couldn't resolve to any analysis: genuinely unknown, stay silent.
+    if (unresolvedImportUris.has(namespaceUri))
+        return;
     const overloads = allFns.filter((f) => f.qname.namespaceUri === namespaceUri && f.qname.localName === localName);
     const name = formatQName(qname);
     if (overloads.length === 0) {
-        if (!knownNamespaceUris.has(namespaceUri))
-            return;
         errors.push({ message: `${name} is not declared`, code: "XPST0017", offset: nodeStart, length: name.length });
         return;
     }
@@ -35,29 +93,30 @@ function checkArity(qname, arity, nodeStart, allFns, knownNamespaceUris, errors)
  * Walk all FunctionCall, NamedFunctionRef, and ArrowExpr nodes in the AST
  * and report XPST0017 for any call where the argument count does not match
  * any known overload, or where the function name is not declared in a
- * namespace we have analysis for.
+ * namespace this file can call into.
  *
- * If the function's namespace is entirely unknown (no analysis loaded for it),
- * the call is silently skipped — it could be a runtime-only library.
+ * A namespace is only skipped (left unchecked) when it's the target of an
+ * import we couldn't resolve to any analysis, or when the prefix itself is
+ * undeclared (that's findUndeclaredPrefixUsages's concern) — see
+ * accessibleFunctions and checkArity. Every other namespace is closed-world:
+ * not finding a matching declaration there means one doesn't exist.
  */
 export function checkFunctionCalls(ast, analysis, importedAnalyses) {
     const errors = [];
-    const allFns = allFunctionsFlat(analysis, importedAnalyses);
-    // Namespaces we have at least one function declaration for.
-    const knownNamespaceUris = new Set(allFns.map((f) => f.qname.namespaceUri));
+    const { fns: allFns, unresolvedImportUris } = accessibleFunctions(analysis, importedAnalyses);
     // ── FunctionCall ─────────────────────────────────────────────────────────────
     for (const callNode of findAll(ast, "FunctionCall")) {
         const call = asFunctionCall(callNode, analysis);
         if (!call)
             continue;
-        checkArity(call.qname, call.args.length, callNode.start, allFns, knownNamespaceUris, errors);
+        checkArity(call.qname, call.args.length, callNode.start, allFns, unresolvedImportUris, errors);
     }
     // ── NamedFunctionRef ─────────────────────────────────────────────────────────
     for (const refNode of findAll(ast, "NamedFunctionRef")) {
         const ref = asNamedFunctionRef(refNode, analysis);
         if (!ref)
             continue;
-        checkArity(ref.qname, ref.arity, refNode.start, allFns, knownNamespaceUris, errors);
+        checkArity(ref.qname, ref.arity, refNode.start, allFns, unresolvedImportUris, errors);
     }
     // ── ArrowExpr ────────────────────────────────────────────────────────────────
     // "$x => f($y)" is syntax sugar for "f($x, $y)"; the arrow provides one extra
@@ -80,7 +139,7 @@ export function checkFunctionCalls(ast, analysis, importedAnalyses) {
             const { prefix, localName, uri } = parseEQName(rawName);
             const namespaceUri = uri ?? resolvePrefix(prefix, analysis);
             const explicitArgs = directChildrenOf(argList, "Argument").length;
-            checkArity({ prefix, localName, namespaceUri }, 1 + explicitArgs, arrowNode.start, allFns, knownNamespaceUris, errors);
+            checkArity({ prefix, localName, namespaceUri }, 1 + explicitArgs, arrowNode.start, allFns, unresolvedImportUris, errors);
         }
     }
     return errors;

package/dist/inlay-hints.js

@@ -1,35 +1,23 @@
 import { InlayHintKind } from "vscode-languageserver/node.js";
-import { qnameKey } from "./types.js";
-import { findAll, isTerminal, directChildOf } from "./analyzer.js";
-import { asFunctionCall, asBinding, asTypedBinding } from "./ast-nodes.js";
-import { parseType, inferExprType, formatType } from "./typechecker.js";
+import { findAll } from "./analyzer.js";
+import { asFunctionCall } from "./ast-nodes.js";
+import { externalVariableTypes, formatType, resolveFunction, walkModuleScopes, withInferredReturnTypes, } from "./typechecker.js";
 function allFunctionsFlat(analysis, importedAnalyses) {
     const fns = [...analysis.functions];
     for (const a of importedAnalyses.values())
         fns.push(...a.functions);
     return fns;
 }
-function resolveCallee(call, argCount, allFns) {
-    const overloads = allFns.filter((f) => f.qname.namespaceUri === call.qname.namespaceUri && f.qname.localName === call.qname.localName);
-    return overloads.find((f) => (f.variadic ? argCount >= f.arity : f.arity === argCount));
-}
 function inRange(offset, range) {
     return offset >= range.start && offset <= range.end;
 }
-// Narrows a sequence's type to its item type (occurrence ""), for `for` bindings
-// where the bound variable holds one item per iteration, not the whole sequence.
-function itemTypeOf(t) {
-    if (t.kind === "unknown" || t.kind === "empty")
-        return t;
-    return t.occurrence === "" ? t : { ...t, occurrence: "" };
-}
 // ── Parameter name hints ─────────────────────────────────────────────────────
 function collectParameterHints(ast, analysis, allFns, range, hints, doc) {
     for (const callNode of findAll(ast, "FunctionCall")) {
         const call = asFunctionCall(callNode, analysis);
         if (!call || call.args.length === 0)
             continue;
-        const fn = resolveCallee(call, call.args.length, allFns);
+        const fn = resolveFunction(call.qname, call.args.length, allFns);
         if (!fn)
             continue;
         for (let i = 0; i < call.args.length && i < fn.params.length; i++) {
@@ -45,77 +33,35 @@ function collectParameterHints(ast, analysis, allFns, range, hints, doc) {
         }
     }
 }
-// ── Inferred type hints on untyped let/for bindings ──────────────────────────
-function collectParams(paramList, text, analysis, scope) {
-    if (!paramList)
-        return;
-    for (const param of findAll(paramList, "Param")) {
-        const binding = asTypedBinding(param, text, analysis);
-        if (binding?.typeStr)
-            scope.set(qnameKey(binding.qname), parseType(binding.typeStr));
-    }
-}
-function buildModuleVarTypes(ast, text, analysis) {
-    const types = new Map();
-    for (const node of findAll(ast, "VarDecl")) {
-        const binding = asTypedBinding(node, text, analysis);
-        if (binding?.typeStr)
-            types.set(qnameKey(binding.qname), parseType(binding.typeStr));
-    }
-    return types;
-}
-// Walks the tree tracking in-scope variable types, mirroring typechecker.ts's scope walk,
-// but also records the inferred type of untyped let/for bindings so later bindings see it.
-function walkForTypeHints(node, scopeTypes, moduleTypes, text, analysis, allFns, range, hints, doc) {
-    if (isTerminal(node))
-        return;
-    const nt = node;
-    if (node.type === "InlineFunctionExpr") {
-        const innerScope = new Map(moduleTypes);
-        collectParams(directChildOf(node, "ParamList"), text, analysis, innerScope);
-        const body = directChildOf(node, "FunctionBody");
-        if (body)
-            walkForTypeHints(body, innerScope, moduleTypes, text, analysis, allFns, range, hints, doc);
-        return;
-    }
-    if (node.type === "LetBinding" || node.type === "ForBinding") {
-        const typed = asTypedBinding(node, text, analysis);
-        const binding = asBinding(node, analysis);
-        if (typed && binding) {
-            if (typed.typeStr) {
-                scopeTypes.set(qnameKey(typed.qname), parseType(typed.typeStr));
-            }
-            else if (binding.initExpr) {
-                const inferredSeq = inferExprType(binding.initExpr, scopeTypes, analysis, allFns);
-                // A `for` binding iterates the sequence one item at a time, so $x's type
-                // is the *item* type (occurrence narrowed to singular) — not the type of
-                // the whole iterated sequence, which is what inferExprType returns.
-                const inferred = node.type === "ForBinding" ? itemTypeOf(inferredSeq) : inferredSeq;
-                scopeTypes.set(qnameKey(typed.qname), inferred);
-                const nameEnd = binding.nameNode.end ?? binding.nameNode.start;
-                if (inferred.kind !== "unknown" && inRange(nameEnd, range)) {
-                    hints.push({
-                        position: doc.positionAt(nameEnd),
-                        label: `: ${formatType(inferred)}`,
-                        kind: InlayHintKind.Type,
-                        paddingLeft: true,
-                    });
-                }
-            }
-        }
-    }
-    for (const child of nt.children) {
-        walkForTypeHints(child, scopeTypes, moduleTypes, text, analysis, allFns, range, hints, doc);
-    }
+// ── Inferred type hints on untyped bindings ──────────────────────────────────
+// Shows the inferred type after the name of every binding without a declared type:
+// let/for/group-by variables and module-level `declare variable`s. The scope walk is the
+// same one the type checker uses, so hints reflect exactly what diagnostics see.
+function collectTypeHints(ast, analysis, allFns, range, hints, doc, outerScope) {
+    const seen = new Set();
+    walkModuleScopes(ast, analysis, allFns, {
+        onBinding: (nameNode, type) => {
+            const nameEnd = nameNode.end ?? nameNode.start;
+            if (type.kind === "unknown" || !inRange(nameEnd, range) || seen.has(nameEnd))
+                return;
+            seen.add(nameEnd);
+            hints.push({
+                position: doc.positionAt(nameEnd),
+                label: `: ${formatType(type)}`,
+                kind: InlayHintKind.Type,
+                paddingLeft: true,
+            });
+        },
+    }, outerScope);
 }
 // ── Entry point ───────────────────────────────────────────────────────────────
 export function getInlayHints(doc, ast, analysis, imported, range) {
-    const text = doc.getText();
     const offsetRange = { start: doc.offsetAt(range.start), end: doc.offsetAt(range.end) };
-    const allFns = allFunctionsFlat(analysis, imported);
+    const declaredFns = allFunctionsFlat(analysis, imported);
+    const outerScope = externalVariableTypes(analysis, imported.values(), declaredFns);
+    const allFns = withInferredReturnTypes(ast, analysis, declaredFns, outerScope);
     const hints = [];
     collectParameterHints(ast, analysis, allFns, offsetRange, hints, doc);
-    const moduleTypes = buildModuleVarTypes(ast, text, analysis);
-    walkForTypeHints(ast, new Map(moduleTypes), moduleTypes, text, analysis, allFns, offsetRange, hints, doc);
+    collectTypeHints(ast, analysis, allFns, offsetRange, hints, doc, outerScope);
     return hints;
 }

package/dist/module-siblings.d.ts

@@ -0,0 +1,11 @@
+import type { FileAnalysis } from "./types.ts";
+/**
+ * The declarations that *other* files contribute to a module namespace. XQuery lets one module be
+ * implemented by several module files sharing a target namespace, and some runtimes (e.g. Fonto)
+ * merge them, so a file can call a function declared in a sibling without importing it.
+ *
+ * `merged` is the glob index entry for the namespace, which may include the current file's own
+ * on-disk declarations. Those are dropped so they aren't reported as duplicates of the (possibly
+ * edited) in-memory versions, nor resolved to stale positions. Returns null when nothing is left.
+ */
+export declare function siblingModuleAnalysis(merged: FileAnalysis, currentUri: string): FileAnalysis | null;

package/dist/module-siblings.js

@@ -0,0 +1,16 @@
+/**
+ * The declarations that *other* files contribute to a module namespace. XQuery lets one module be
+ * implemented by several module files sharing a target namespace, and some runtimes (e.g. Fonto)
+ * merge them, so a file can call a function declared in a sibling without importing it.
+ *
+ * `merged` is the glob index entry for the namespace, which may include the current file's own
+ * on-disk declarations. Those are dropped so they aren't reported as duplicates of the (possibly
+ * edited) in-memory versions, nor resolved to stale positions. Returns null when nothing is left.
+ */
+export function siblingModuleAnalysis(merged, currentUri) {
+    const functions = merged.functions.filter((f) => f.sourceUri !== currentUri);
+    const moduleVariables = merged.moduleVariables.filter((v) => v.sourceUri !== currentUri);
+    if (functions.length === 0 && moduleVariables.length === 0)
+        return null;
+    return { ...merged, functions, moduleVariables };
+}

package/dist/predeclared-namespaces.js

@@ -125,6 +125,7 @@ export function getRuntimePredeclaredVariables(runtimes, sourceUri) {
         isModuleLevel: true,
         sourceUri,
         doc,
+        type: "xs:string", // all three are file system / collection paths
     }));
 }
 /**

package/dist/prolog-diagnostics.d.ts

@@ -0,0 +1,10 @@
+import type { Node } from "xq-parser";
+import type { TypeDiagnostic, FileAnalysis } from "./types.ts";
+/**
+ * Report an unsupported `xquery version` (XQST0031), serialization option
+ * misuse (XQST0108/0109/0110) and prolog components that the spec allows only once: setters such as
+ * `declare base-uri`, namespace prefixes, default element/function namespaces,
+ * decimal formats, and duplicate function parameter names.
+ * Only the second and later occurrences are flagged.
+ */
+export declare function checkDuplicatePrologDecls(ast: Node, analysis: FileAnalysis): TypeDiagnostic[];