xq-lsp 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [1.7.0](https://github.com/DrRataplan/xq-lsp/compare/lsp-v1.6.0...lsp-v1.7.0) (2026-07-15)
+
+
+### Features
+
+* add document highlight support (textDocument/documentHighlight) ([6d90ad7](https://github.com/DrRataplan/xq-lsp/commit/6d90ad7b63e50b10b68705e819320035318a56da))
+* add find-references support via cross-file glob scan ([f0b0085](https://github.com/DrRataplan/xq-lsp/commit/f0b00852265c68ec95b96d86781eef41cb9dd940))
+* add rename support (textDocument/rename, prepareRename) ([d0cb55d](https://github.com/DrRataplan/xq-lsp/commit/d0cb55dbcba1d5b8520f7a2080818cdc420e06e6))
+* add XQST0034 diagnostic for double-declared functions ([6d44620](https://github.com/DrRataplan/xq-lsp/commit/6d44620e5b41e7de2c0a548086abec0b45ae22ff))
+* add XQST0059 diagnostic for module import namespace mismatches ([d8111fc](https://github.com/DrRataplan/xq-lsp/commit/d8111fcbf034d23306a53cfe28bd7c3dd43ce3a7))
+* auto-import and auto-declare-namespace via completion additionalTextEdits ([e1a9a93](https://github.com/DrRataplan/xq-lsp/commit/e1a9a935dea941bf35a3dc580ee77f7e88dd22c1))
+
+
+### Bug Fixes
+
+* don't blanket-skip XQUpdate-tagged QT4 tests ([f2e45f1](https://github.com/DrRataplan/xq-lsp/commit/f2e45f18022873cb3bb5105eb727b484bedfd518))
+* don't count literal fn:error() code calls as expected static errors ([0bead1b](https://github.com/DrRataplan/xq-lsp/commit/0bead1b8044c52daa2d7f2a11a24f8512d6ee2a9))
+* fall back to glob-resolved namespace when import location hint fails ([6ce03db](https://github.com/DrRataplan/xq-lsp/commit/6ce03db6d9c5deb1fa501617c29b6005f2540102))
+* go-to-definition for function params and imported variables ([415cfdd](https://github.com/DrRataplan/xq-lsp/commit/415cfdd4717b71af66041a7727641f18d091175d))
+* go-to-definition for inline function params and dashed variable names ([a4e7279](https://github.com/DrRataplan/xq-lsp/commit/a4e7279d4b27357bb27e7b67f2ed0551650ef66e))
+* handle InlineFunctionExpr scope in variable and unused-variable walkers ([de19b18](https://github.com/DrRataplan/xq-lsp/commit/de19b186fd367dc1450de1554205e8c07d0e40fd))
+* insert auto-import after last existing import, skip multi-line docblocks ([12227a9](https://github.com/DrRataplan/xq-lsp/commit/12227a916dcdafeb2ba5ddef21e82b4e2f6acbca))
+* load external <test file> queries and skip unsupported QT4 features ([4cbdc58](https://github.com/DrRataplan/xq-lsp/commit/4cbdc589b9af65f9043e3c0de6b5ffe950f3c7fe))
+* make computeRelativePath browser-safe and build the demo in CI ([033a057](https://github.com/DrRataplan/xq-lsp/commit/033a057849cbc492f8e243cf8f4e908200673033))
+* model QT4 environment-bound variables to cut XPST0008 false positives ([5dcb404](https://github.com/DrRataplan/xq-lsp/commit/5dcb4040bd79c0b7dc8edac5086b2289b1582b9e))
+* rewrite imported variable prefix to the importing module's prefix in completions ([f7c5ccc](https://github.com/DrRataplan/xq-lsp/commit/f7c5ccc337af75bae0c2d881210ba3373c90bb71))
+* scope inline function params, window vars, and copy bindings for XPST0008 ([7391a94](https://github.com/DrRataplan/xq-lsp/commit/7391a94c2607a028b6636ad6fcdadb29ba1356e5))
+
 ## [1.6.0](https://github.com/DrRataplan/xq-lsp/compare/lsp-v1.5.0...lsp-v1.6.0) (2026-07-09)
 
 

package/dist/analyzer.js

@@ -229,6 +229,7 @@ function extractFunctions(ast, sourceUri, comments, text, prefixMap, defaultFnNs
                     name: paramName,
                     type: paramType,
                     description: doc?.params[paramName],
+                    sourceOffset: param.start,
                 });
             }
         }

package/dist/ast-nodes.d.ts

@@ -27,6 +27,35 @@ 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;
+export interface InlineFunctionExprShape {
+    params: Array<{
+        nameNode: Node;
+        qname: QName;
+    }>;
+    body: Node | null;
+}
+export declare function asInlineFunctionExpr(node: Node, analysis: FileAnalysis): InlineFunctionExprShape | null;
+export interface WindowVarsShape {
+    currentItem?: QName;
+    positionalVar?: {
+        nameNode: Node;
+        qname: QName;
+    };
+    previousItem?: QName;
+    nextItem?: QName;
+}
+/** Resolves the `$current at $pos previous $prev next $next` bindings of a WindowVars node. */
+export declare function asWindowVars(node: Node, analysis: FileAnalysis): WindowVarsShape | null;
+export interface CopyBindingShape {
+    qname: QName;
+    initExpr: Node;
+}
+export interface TransformExprShape {
+    copyBindings: CopyBindingShape[];
+    modifyExpr: Node | null;
+    returnExpr: Node | null;
+}
+export declare function asTransformExpr(node: Node, analysis: FileAnalysis): TransformExprShape | null;
 /** QName, name node, arity, and annotation local-names for an AnnotatedDecl containing a FunctionDecl, or null. */
 export declare function asFunctionDeclaration(node: Node, analysis: FileAnalysis): {
     qname: QName;

package/dist/ast-nodes.js

@@ -18,6 +18,26 @@ function resolveQName(raw, analysis, defaultNs) {
     const namespaceUri = uri ?? resolvePrefix(prefix, analysis);
     return { prefix, localName, namespaceUri };
 }
+/** Resolves a variable QName from a node whose first descendant terminal is the bare name (no "$"). */
+function qnameFromRawTerminal(node, analysis) {
+    const rawName = firstTerminalValue(node);
+    if (!rawName)
+        return null;
+    const { prefix, localName, uri } = parseEQName(rawName);
+    return { prefix, localName, namespaceUri: uri ?? (prefix ? resolvePrefix(prefix, analysis) : "") };
+}
+function extractParamsFromParamList(paramList, analysis) {
+    const paramNodes = paramList ? directChildrenOf(paramList, "Param") : [];
+    return paramNodes.flatMap((p) => {
+        const pNameNode = directChildOf(p, "EQName");
+        if (!pNameNode)
+            return [];
+        const qname = qnameFromRawTerminal(pNameNode, analysis);
+        if (!qname)
+            return [];
+        return [{ nameNode: pNameNode, qname }];
+    });
+}
 export function asFunctionCall(node, analysis) {
     if (node.type !== "FunctionCall")
         return null;
@@ -90,18 +110,51 @@ export function asFunctionDecl(node, analysis) {
         return null;
     const { prefix, localName, uri } = parseEQName(rawName);
     const namespaceUri = uri ?? resolvePrefix(prefix, analysis);
-    const paramList = directChildOf(node, "ParamList");
-    const paramNodes = paramList ? directChildrenOf(paramList, "Param") : [];
-    const params = paramNodes.flatMap((p) => {
-        const pNameNode = directChildOf(p, "EQName");
-        const pName = pNameNode ? firstTerminalValue(pNameNode) : null;
-        if (!pName || !pNameNode)
+    const params = extractParamsFromParamList(directChildOf(node, "ParamList"), analysis);
+    return { nameNode, qname: { prefix, localName, namespaceUri }, params, body: directChildOf(node, "FunctionBody") ?? null };
+}
+export function asInlineFunctionExpr(node, analysis) {
+    if (node.type !== "InlineFunctionExpr")
+        return null;
+    const params = extractParamsFromParamList(directChildOf(node, "ParamList"), analysis);
+    return { params, body: directChildOf(node, "FunctionBody") ?? null };
+}
+/** Resolves the `$current at $pos previous $prev next $next` bindings of a WindowVars node. */
+export function asWindowVars(node, analysis) {
+    if (node.type !== "WindowVars")
+        return null;
+    const result = {};
+    const currentItemNode = directChildOf(node, "CurrentItem");
+    if (currentItemNode)
+        result.currentItem = qnameFromRawTerminal(currentItemNode, analysis) ?? undefined;
+    const posVarNode = directChildOf(node, "PositionalVar");
+    if (posVarNode)
+        result.positionalVar = asPositionalVar(posVarNode, analysis) ?? undefined;
+    const prevNode = directChildOf(node, "PreviousItem");
+    if (prevNode)
+        result.previousItem = qnameFromRawTerminal(prevNode, analysis) ?? undefined;
+    const nextNode = directChildOf(node, "NextItem");
+    if (nextNode)
+        result.nextItem = qnameFromRawTerminal(nextNode, analysis) ?? undefined;
+    return result;
+}
+export function asTransformExpr(node, analysis) {
+    if (node.type !== "XQUF_TransformExpr")
+        return null;
+    const bindingList = directChildOf(node, "XQUF_CopyBindingList");
+    const bindingNodes = bindingList ? directChildrenOf(bindingList, "XQUF_CopyBinding") : [];
+    const copyBindings = bindingNodes.flatMap((b) => {
+        const nameNode = directChildOf(b, "VarName");
+        const initExpr = directChildOf(b, "ExprSingle");
+        if (!nameNode || !initExpr)
             return [];
-        const { prefix: pPrefix, localName: pLocalName, uri: pUri } = parseEQName(pName);
-        const pNsUri = pUri ?? (pPrefix ? resolvePrefix(pPrefix, analysis) : "");
-        return [{ nameNode: pNameNode, qname: { prefix: pPrefix, localName: pLocalName, namespaceUri: pNsUri } }];
+        const qname = qnameFromRawTerminal(nameNode, analysis);
+        if (!qname)
+            return [];
+        return [{ qname, initExpr }];
     });
-    return { nameNode, qname: { prefix, localName, namespaceUri }, params, body: directChildOf(node, "FunctionBody") ?? null };
+    const [modifyExpr, returnExpr] = directChildrenOf(node, "ExprSingle");
+    return { copyBindings, modifyExpr: modifyExpr ?? null, returnExpr: returnExpr ?? null };
 }
 // ── AnnotatedDecl wrappers ────────────────────────────────────────────────────
 /** QName, name node, arity, and annotation local-names for an AnnotatedDecl containing a FunctionDecl, or null. */

package/dist/completion-core.d.ts

@@ -5,13 +5,26 @@ export interface CompletionContext {
     /** Character offset of the cursor in the document */
     cursorOffset: number;
 }
+/** Carries enough information for the LSP adapter to build the additionalTextEdit. */
+export interface AdditionalEdit {
+    kind: "import-module" | "declare-namespace";
+    prefix: string;
+    namespaceUri: string;
+    /** Source URI of the module file, used to compute the relative `at` path. */
+    sourceUri?: string;
+}
 export interface CompletionEntry {
     label: string;
-    kind: "function" | "variable";
+    kind: "function" | "variable" | "namespace";
     detail?: string;
     documentation?: string;
     insertText: string;
     isSnippet: boolean;
+    additionalEdit?: AdditionalEdit;
 }
 export declare function functionDoc(fn: FunctionSymbol): string;
-export declare function getCompletions(ctx: CompletionContext, currentAnalysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>, snippets?: boolean, lastValidAnalysis?: FileAnalysis): CompletionEntry[];
+export declare function getCompletions(ctx: CompletionContext, currentAnalysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>, snippets?: boolean, lastValidAnalysis?: FileAnalysis, 
+/** Modules available in the workspace but not yet imported in the current file. Keyed by namespace URI. */
+availableAnalyses?: Map<string, FileAnalysis>, 
+/** Known namespace prefix → URI mappings (from config / glob scans) for pure XML namespaces. */
+knownNamespaces?: Map<string, string>): CompletionEntry[];

package/dist/completion-core.js

@@ -76,7 +76,15 @@ function buildFunctionEntry(fn, label, snippets) {
         isSnippet: snippets && fn.params.length > 0,
     };
 }
-export function getCompletions(ctx, currentAnalysis, importedAnalyses, snippets = false, lastValidAnalysis) {
+/** Return the source URI for a module's analysis (taken from the first known symbol). */
+function moduleSourceUri(analysis) {
+    return analysis.functions[0]?.sourceUri ?? analysis.moduleVariables[0]?.sourceUri;
+}
+export function getCompletions(ctx, currentAnalysis, importedAnalyses, snippets = false, lastValidAnalysis, 
+/** Modules available in the workspace but not yet imported in the current file. Keyed by namespace URI. */
+availableAnalyses, 
+/** Known namespace prefix → URI mappings (from config / glob scans) for pure XML namespaces. */
+knownNamespaces) {
     const token = parseToken(ctx.textBeforeCursor);
     const items = [];
     if (token.kind === "variable") {
@@ -132,29 +140,94 @@ export function getCompletions(ctx, currentAnalysis, importedAnalyses, snippets
                 }
             }
         }
-        // Imported module-level variables are always visible
+        // Imported module-level variables — rewrite prefix to the one used in the current module
         for (const analysis of importedAnalyses.values()) {
             for (const v of analysis.moduleVariables) {
-                const e = buildVariableEntry(v, filter);
+                const localPrefix = currentAnalysis.imports.find((i) => i.namespaceUri === v.qname.namespaceUri)?.prefix;
+                const displayVar = localPrefix !== undefined && localPrefix !== v.qname.prefix
+                    ? { ...v, qname: { ...v.qname, prefix: localPrefix } }
+                    : v;
+                const e = buildVariableEntry(displayVar, filter);
                 if (e)
                     items.push(e);
             }
         }
+        // Variables from modules available in the workspace but not yet imported
+        if (availableAnalyses) {
+            const colonIdx = filter.indexOf(":");
+            if (colonIdx >= 0) {
+                const nsPrefix = filter.slice(0, colonIdx);
+                const localFilter = filter.slice(colonIdx + 1).toLowerCase();
+                const nsUri = resolvePrefix(nsPrefix, currentAnalysis);
+                if (nsUri.startsWith("urn:xq-lsp:undeclared:")) {
+                    for (const [moduleNsUri, analysis] of availableAnalyses) {
+                        if (analysis.modulePrefix !== nsPrefix)
+                            continue;
+                        const sourceUri = moduleSourceUri(analysis);
+                        for (const v of analysis.moduleVariables) {
+                            if (localFilter && !v.qname.localName.toLowerCase().startsWith(localFilter))
+                                continue;
+                            const displayQName = { ...v.qname, prefix: nsPrefix };
+                            items.push({
+                                label: `$${formatQName(displayQName)}`,
+                                kind: "variable",
+                                insertText: `$${formatQName(displayQName)}`,
+                                isSnippet: false,
+                                additionalEdit: { kind: "import-module", prefix: nsPrefix, namespaceUri: moduleNsUri, sourceUri },
+                            });
+                        }
+                    }
+                }
+            }
+        }
         return items;
     }
     if (token.kind === "qualified-name" && token.nsPrefix) {
         const targetUri = resolvePrefix(token.nsPrefix, currentAnalysis);
         const filter = token.prefix.toLowerCase();
-        const allFns = [
-            ...currentAnalysis.functions,
-            ...[...importedAnalyses.values()].flatMap((a) => a.functions),
-        ];
-        for (const fn of allFns) {
-            if (fn.qname.namespaceUri !== targetUri)
-                continue;
-            if (filter && !fn.qname.localName.toLowerCase().includes(filter))
-                continue;
-            items.push(buildFunctionEntry(fn, fn.qname.localName, snippets));
+        if (!targetUri.startsWith("urn:xq-lsp:undeclared:")) {
+            // Prefix is declared — show functions from current + imported analyses (no additionalEdit needed)
+            const allFns = [
+                ...currentAnalysis.functions,
+                ...[...importedAnalyses.values()].flatMap((a) => a.functions),
+            ];
+            for (const fn of allFns) {
+                if (fn.qname.namespaceUri !== targetUri)
+                    continue;
+                if (filter && !fn.qname.localName.toLowerCase().includes(filter))
+                    continue;
+                items.push(buildFunctionEntry(fn, fn.qname.localName, snippets));
+            }
+            return items;
+        }
+        // Prefix is undeclared — look for matching modules in the workspace
+        let foundModule = false;
+        if (availableAnalyses) {
+            for (const [moduleNsUri, analysis] of availableAnalyses) {
+                if (analysis.modulePrefix !== token.nsPrefix)
+                    continue;
+                foundModule = true;
+                const sourceUri = moduleSourceUri(analysis);
+                for (const fn of analysis.functions) {
+                    if (filter && !fn.qname.localName.toLowerCase().includes(filter))
+                        continue;
+                    items.push({
+                        ...buildFunctionEntry(fn, fn.qname.localName, snippets),
+                        additionalEdit: { kind: "import-module", prefix: token.nsPrefix, namespaceUri: moduleNsUri, sourceUri },
+                    });
+                }
+            }
+        }
+        // Pure XML namespace (no module functions): offer a declare-namespace item if prefix is known
+        if (!foundModule && knownNamespaces?.has(token.nsPrefix)) {
+            const nsUri = knownNamespaces.get(token.nsPrefix);
+            items.push({
+                label: `declare namespace ${token.nsPrefix} = "${nsUri}"`,
+                kind: "namespace",
+                insertText: token.prefix,
+                isSnippet: false,
+                additionalEdit: { kind: "declare-namespace", prefix: token.nsPrefix, namespaceUri: nsUri },
+            });
         }
         return items;
     }

package/dist/completion.d.ts

@@ -1,4 +1,10 @@
 import { CompletionItem } from "vscode-languageserver/node.js";
-import { getCompletions as getCoreCompletions } from "./completion-core.ts";
+import type { FileAnalysis } from "./types.ts";
+import type { CompletionContext } from "./completion-core.ts";
 export type { CompletionContext } from "./completion-core.ts";
-export declare function getCompletions(...args: Parameters<typeof getCoreCompletions>): CompletionItem[];
+export interface EditContext {
+    docText: string;
+    docUri: string;
+    generateLocationHints: boolean;
+}
+export declare function getCompletions(ctx: CompletionContext, currentAnalysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>, snippets?: boolean, lastValidAnalysis?: FileAnalysis, availableAnalyses?: Map<string, FileAnalysis>, knownNamespaces?: Map<string, string>, editContext?: EditContext): CompletionItem[];

package/dist/completion.js

@@ -1,12 +1,39 @@
 import { CompletionItem, CompletionItemKind, InsertTextFormat, MarkupKind } from "vscode-languageserver/node.js";
 import { getCompletions as getCoreCompletions } from "./completion-core.js";
-export function getCompletions(...args) {
-    return getCoreCompletions(...args).map((e) => ({
-        label: e.label,
-        kind: e.kind === "function" ? CompletionItemKind.Function : CompletionItemKind.Variable,
-        detail: e.detail,
-        documentation: e.documentation ? { kind: MarkupKind.Markdown, value: e.documentation } : undefined,
-        insertText: e.insertText,
-        insertTextFormat: e.isSnippet ? InsertTextFormat.Snippet : InsertTextFormat.PlainText,
-    }));
+import { findImportInsertPosition, findDeclareNsInsertPosition, computeRelativePath } from "./namespace-diagnostics.js";
+export function getCompletions(ctx, currentAnalysis, importedAnalyses, snippets, lastValidAnalysis, availableAnalyses, knownNamespaces, editContext) {
+    return getCoreCompletions(ctx, currentAnalysis, importedAnalyses, snippets, lastValidAnalysis, availableAnalyses, knownNamespaces).map((e) => {
+        const item = {
+            label: e.label,
+            kind: e.kind === "function"
+                ? CompletionItemKind.Function
+                : e.kind === "namespace"
+                    ? CompletionItemKind.Module
+                    : CompletionItemKind.Variable,
+            detail: e.detail,
+            documentation: e.documentation ? { kind: MarkupKind.Markdown, value: e.documentation } : undefined,
+            insertText: e.insertText,
+            insertTextFormat: e.isSnippet ? InsertTextFormat.Snippet : InsertTextFormat.PlainText,
+        };
+        if (e.additionalEdit && editContext) {
+            const { docText, docUri, generateLocationHints } = editContext;
+            const insertPos = e.additionalEdit.kind === "import-module"
+                ? findImportInsertPosition(docText)
+                : findDeclareNsInsertPosition(docText);
+            let newText;
+            if (e.additionalEdit.kind === "import-module") {
+                const atPath = generateLocationHints && e.additionalEdit.sourceUri
+                    ? computeRelativePath(docUri, e.additionalEdit.sourceUri)
+                    : undefined;
+                newText = atPath
+                    ? `import module namespace ${e.additionalEdit.prefix} = "${e.additionalEdit.namespaceUri}" at "${atPath}";\n`
+                    : `import module namespace ${e.additionalEdit.prefix} = "${e.additionalEdit.namespaceUri}";\n`;
+            }
+            else {
+                newText = `declare namespace ${e.additionalEdit.prefix} = "${e.additionalEdit.namespaceUri}";\n`;
+            }
+            item.additionalTextEdits = [{ range: { start: insertPos, end: insertPos }, newText }];
+        }
+        return item;
+    });
 }

package/dist/definition.d.ts

@@ -1,4 +1,4 @@
 import { Location } from "vscode-languageserver/node.js";
 import type { TextDocument } from "vscode-languageserver-textdocument";
 import type { FileAnalysis } from "./types.ts";
-export declare function getDefinition(doc: TextDocument, offset: number, current: FileAnalysis, imported: Map<string, FileAnalysis>, resolveUri: (atPath: string) => string): Location | null;
+export declare function getDefinition(doc: TextDocument, offset: number, current: FileAnalysis, imported: Map<string, FileAnalysis>): Location | null;

package/dist/definition.js

@@ -1,7 +1,8 @@
 import * as fs from "fs";
 import { fileURLToPath } from "url";
 import { Location } from "vscode-languageserver/node.js";
-import { resolvePrefix, parseEQName } from "./analyzer.js";
+import { resolvePrefix, parseEQName, nodeStackAtOffset, directChildOf, directChildrenOf, firstTerminalValue } from "./analyzer.js";
+import { asVarRef } from "./ast-nodes.js";
 function wordAt(text, offset) {
     let start = offset;
     let end = offset;
@@ -16,21 +17,96 @@ function positionInText(text, offset) {
     const lines = before.split("\n");
     return { line: lines.length - 1, character: lines[lines.length - 1].length };
 }
-export function getDefinition(doc, offset, current, imported, resolveUri) {
+export function getDefinition(doc, offset, current, imported) {
     const text = doc.getText();
     const { word, start } = wordAt(text, offset);
     if (!word)
         return null;
     const hasDollar = start > 0 && text[start - 1] === "$";
     if (hasDollar) {
-        const { prefix: varPrefix, localName: varLocalName, uri: varDirectUri } = parseEQName(word);
-        const varNsUri = varDirectUri ?? (varPrefix ? resolvePrefix(varPrefix, current) : "");
+        // Use AST to extract the exact variable name (handles dashes and other valid NCName chars).
+        // Fall back to the text-scanned `word` only when no AST is available.
+        let varLocalName;
+        let varNsUri;
+        let astStack = null;
+        if (current.ast) {
+            astStack = nodeStackAtOffset(current.ast, offset);
+            const varRefNode = [...astStack].reverse().find((n) => n.type === "VarRef");
+            const qname = varRefNode ? asVarRef(varRefNode, current) : null;
+            if (qname) {
+                varLocalName = qname.localName;
+                varNsUri = qname.namespaceUri;
+            }
+            else {
+                // Cursor is on $ but AST didn't yield a VarRef (e.g. mid-edit) — fall back
+                const { prefix, localName, uri } = parseEQName(word);
+                varLocalName = localName;
+                varNsUri = uri ?? (prefix ? resolvePrefix(prefix, current) : "");
+            }
+        }
+        else {
+            const { prefix, localName, uri } = parseEQName(word);
+            varLocalName = localName;
+            varNsUri = uri ?? (prefix ? resolvePrefix(prefix, current) : "");
+        }
+        // Local bindings and module-level variables in current file
         const allVars = [...current.moduleVariables, ...current.localBindings];
         const v = allVars.find((v) => v.qname.namespaceUri === varNsUri && v.qname.localName === varLocalName);
-        if (!v)
-            return null;
-        const pos = doc.positionAt(v.offset);
-        return Location.create(doc.uri, { start: pos, end: pos });
+        if (v) {
+            const pos = doc.positionAt(v.offset);
+            return Location.create(doc.uri, { start: pos, end: pos });
+        }
+        // Params of inline function expressions enclosing the cursor (not tracked in analysis)
+        if (!varNsUri && astStack) {
+            for (let i = astStack.length - 1; i >= 0; i--) {
+                if (astStack[i].type !== "InlineFunctionExpr")
+                    continue;
+                const paramList = directChildOf(astStack[i], "ParamList");
+                for (const param of paramList ? directChildrenOf(paramList, "Param") : []) {
+                    const nameNode = directChildOf(param, "EQName");
+                    const rawName = nameNode ? firstTerminalValue(nameNode) : null;
+                    if (!rawName)
+                        continue;
+                    const { prefix, localName } = parseEQName(rawName);
+                    if (prefix || localName !== varLocalName)
+                        continue;
+                    if (nameNode?.start !== undefined) {
+                        const pos = doc.positionAt(nameNode.start);
+                        return Location.create(doc.uri, { start: pos, end: pos });
+                    }
+                }
+            }
+        }
+        // Params of declared functions in the current file (prefer nearest enclosing by source offset)
+        if (!varNsUri) {
+            const enclosingFn = current.functions
+                .filter((f) => f.sourceOffset !== undefined && f.sourceOffset <= offset)
+                .at(-1);
+            const matchingFn = enclosingFn ?? current.functions[0];
+            const param = matchingFn?.params.find((p) => p.name === varLocalName);
+            if (param?.sourceOffset !== undefined) {
+                const pos = doc.positionAt(param.sourceOffset);
+                return Location.create(doc.uri, { start: pos, end: pos });
+            }
+        }
+        // Imported module-level variables
+        for (const [, analysis] of imported) {
+            const iv = analysis.moduleVariables.find((v) => v.qname.namespaceUri === varNsUri && v.qname.localName === varLocalName);
+            if (!iv)
+                continue;
+            const uri = iv.sourceUri;
+            let pos = { line: 0, character: 0 };
+            try {
+                const filePath = fileURLToPath(uri);
+                const srcText = fs.readFileSync(filePath, "utf-8");
+                pos = positionInText(srcText, iv.offset);
+            }
+            catch {
+                /* file not readable, use line 0 */
+            }
+            return Location.create(uri, { start: pos, end: pos });
+        }
+        return null;
     }
     // Function definition — resolve by namespace URI, search current file then all imports
     const { prefix: wordPrefix, localName: wordLocalName, uri: wordDirectUri } = parseEQName(word);
@@ -49,7 +125,7 @@ export function getDefinition(doc, offset, current, imported, resolveUri) {
         const fn = analysis.functions.find((f) => f.qname.namespaceUri === targetUri && f.qname.localName === wordLocalName);
         if (!fn)
             continue;
-        const uri = imp.atPath ? resolveUri(imp.atPath) : fn.sourceUri;
+        const uri = fn.sourceUri;
         let pos = { line: 0, character: 0 };
         if (fn.sourceOffset !== undefined) {
             try {

package/dist/diagnostics.js

@@ -3,6 +3,8 @@ import { checkFunctionCalls } from "./functioncall-diagnostics.js";
 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 { checkModuleImportTargets } from "./module-import-diagnostics.js";
 import { checkUnused } from "./unused-diagnostics.js";
 /**
  * Run all error-level diagnostics (XQuery static/dynamic error codes).
@@ -17,6 +19,8 @@ export function runDiagnostics(ast, text, analysis, imports) {
         ...findUndeclaredPrefixUsages(ast, analysis),
         ...checkContextItemUsage(ast),
         ...checkUndeclaredVariables(ast, analysis, imports),
+        ...checkDuplicateFunctions(ast, analysis, imports),
+        ...checkModuleImportTargets(analysis, imports),
     ];
 }
 /**

package/dist/duplicate-function-diagnostics.d.ts

@@ -0,0 +1,17 @@
+import type { Node } from "xq-parser";
+import type { TypeDiagnostic, FileAnalysis } from "./types.ts";
+export interface DuplicateFunctionDiagnostic extends TypeDiagnostic {
+    code: "XQST0034";
+}
+/**
+ * Walk the AST and report every function declaration whose expanded QName and
+ * arity (parameter count) collide with another declaration — either another
+ * declaration in this file, or one already provided by an imported module.
+ * Per XQST0034, return type, parameter types, and parameter names are
+ * irrelevant to the clash: only the expanded QName and arity matter.
+ *
+ * All declarations that share a colliding key are reported (not just the
+ * later ones), since the file only stops erroring once every collision is
+ * resolved.
+ */
+export declare function checkDuplicateFunctions(ast: Node, analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): DuplicateFunctionDiagnostic[];

package/dist/duplicate-function-diagnostics.js

@@ -0,0 +1,47 @@
+import { qnameKey, formatQName } from "./types.js";
+import { findAll } from "./analyzer.js";
+import { asFunctionDeclaration } from "./ast-nodes.js";
+/**
+ * Walk the AST and report every function declaration whose expanded QName and
+ * arity (parameter count) collide with another declaration — either another
+ * declaration in this file, or one already provided by an imported module.
+ * Per XQST0034, return type, parameter types, and parameter names are
+ * irrelevant to the clash: only the expanded QName and arity matter.
+ *
+ * All declarations that share a colliding key are reported (not just the
+ * later ones), since the file only stops erroring once every collision is
+ * resolved.
+ */
+export function checkDuplicateFunctions(ast, analysis, importedAnalyses) {
+    const importedKeys = new Set();
+    for (const imported of importedAnalyses.values())
+        for (const f of imported.functions)
+            importedKeys.add(`${qnameKey(f.qname)}#${f.arity}`);
+    const groups = new Map();
+    for (const annotated of findAll(ast, "AnnotatedDecl")) {
+        const fn = asFunctionDeclaration(annotated, analysis);
+        if (!fn)
+            continue;
+        const key = `${qnameKey(fn.qname)}#${fn.arity}`;
+        const entry = { nameNode: fn.nameNode, displayName: formatQName(fn.qname), arity: fn.arity };
+        const group = groups.get(key);
+        if (group)
+            group.push(entry);
+        else
+            groups.set(key, [entry]);
+    }
+    const out = [];
+    for (const [key, decls] of groups) {
+        if (decls.length <= 1 && !importedKeys.has(key))
+            continue;
+        for (const { nameNode, displayName, arity } of decls) {
+            out.push({
+                message: `Function '${displayName}' is declared more than once (${arity} parameter${arity === 1 ? "" : "s"})`,
+                code: "XQST0034",
+                offset: nameNode.start ?? 0,
+                length: displayName.length,
+            });
+        }
+    }
+    return out;
+}

package/dist/module-import-diagnostics.d.ts

@@ -0,0 +1,19 @@
+import type { FileAnalysis, TypeDiagnostic } from "./types.ts";
+export interface ModuleImportDiagnostic extends TypeDiagnostic {
+    code: "XQST0059";
+}
+/**
+ * Report module imports whose target module resolves to a real file but
+ * whose target namespace (from that file's own `module namespace` decl)
+ * does not match the namespace URI written in the import statement.
+ *
+ * `importedAnalyses` is keyed by `atPath` when the import has a location
+ * hint, and always also by `namespaceUri` — mirroring how `resolveContext`
+ * in server.ts populates the map (a resolved import is recorded under both
+ * keys). Preferring `atPath` when present and falling back to
+ * `namespaceUri` lets this check reuse the same map without caring how the
+ * caller resolved it. An import missing from the map entirely means
+ * resolution didn't happen at all, which is a different problem and not
+ * checked here.
+ */
+export declare function checkModuleImportTargets(analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): ModuleImportDiagnostic[];