xq-lsp 1.8.3-next.430 → 1.8.3-next.439

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

@@ -17,3 +17,13 @@ export interface ModuleImportDiagnostic extends TypeDiagnostic {
  * checked here.
  */
 export declare function checkModuleImportTargets(analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): ModuleImportDiagnostic[];
+export interface UnresolvedImportDiagnostic extends TypeDiagnostic {
+    code: "xq-lsp:unresolved-import";
+}
+/**
+ * Report imports whose module could not be loaded. Variable and function
+ * checks stay silent for such namespaces, so this is where the user learns
+ * why. Reported as a warning (not XQST0059) because the module may
+ * legitimately live outside the workspace or be generated at install time.
+ */
+export declare function checkUnresolvedImports(analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): UnresolvedImportDiagnostic[];

package/dist/module-import-diagnostics.js

@@ -33,3 +33,24 @@ export function checkModuleImportTargets(analysis, importedAnalyses) {
     }
     return out;
 }
+/**
+ * Report imports whose module could not be loaded. Variable and function
+ * checks stay silent for such namespaces, so this is where the user learns
+ * why. Reported as a warning (not XQST0059) because the module may
+ * legitimately live outside the workspace or be generated at install time.
+ */
+export function checkUnresolvedImports(analysis, importedAnalyses) {
+    const out = [];
+    for (const imp of analysis.imports) {
+        if (importedAnalyses.has(imp.atPath ?? imp.namespaceUri) || importedAnalyses.has(imp.namespaceUri))
+            continue;
+        const location = imp.atPath ? `at '${imp.atPath}'` : `for namespace '${imp.namespaceUri}'`;
+        out.push({
+            message: `Module ${location} could not be resolved; its functions and variables are not checked`,
+            code: "xq-lsp:unresolved-import",
+            offset: imp.offset,
+            length: imp.prefix.length,
+        });
+    }
+    return out;
+}

package/dist/namespace-diagnostics.d.ts

@@ -3,12 +3,27 @@ import type { FileAnalysis } from "./types.ts";
 export type NamespaceUsageKind = "function" | "variable" | "element";
 export interface NamespaceDiagnostic {
     message: string;
-    code: "XQST0081";
+    code: "XQST0081" | "FONS0004";
     offset: number;
     length: number;
     prefix: string;
     usageKind: NamespaceUsageKind;
 }
+export interface DynamicPrefixUse {
+    /** The prefix text. */
+    prefix: string;
+    /** Source offset of the prefix (inside the string literal). */
+    offset: number;
+    /** True when an unbound prefix is an error (xs:QName / xs:NOTATION); false for namespace-uri-for-prefix, which just returns (). */
+    required: boolean;
+}
+/**
+ * Prefixes taken from a string literal and resolved against the static
+ * in-scope namespaces at runtime: `xs:QName("p:l")`, `"p:l" cast as xs:QName`
+ * (also `castable as`, `xs:NOTATION`) and `fn:namespace-uri-for-prefix("p", …)`.
+ * Only literal operands are detected.
+ */
+export declare function findDynamicPrefixUses(ast: Node, analysis: FileAnalysis): DynamicPrefixUse[];
 /**
  * Walk the AST and report every prefixed name reference whose prefix is not
  * declared in `analysis` (via import module namespace, declare namespace,

package/dist/namespace-diagnostics.js

@@ -1,4 +1,70 @@
-import { isTerminal, directChildOf, firstTerminalValue, resolvePrefix } from "./analyzer.js";
+import { XMLNS_FN, XMLNS_XS, isTerminal, directChildOf, findAll, firstTerminalValue, parseEQName, resolvePrefix, } from "./analyzer.js";
+import { asFunctionCall } from "./ast-nodes.js";
+/** Unwraps single-child grammar wrappers down to a StringLiteral terminal; null for anything more complex. */
+function asStringLiteral(node) {
+    let cur = node;
+    while (cur && !isTerminal(cur)) {
+        const children = cur.children;
+        if (children.length !== 1)
+            return null;
+        cur = children[0];
+    }
+    return cur && cur.type === "StringLiteral" ? cur : null;
+}
+/**
+ * Prefixes taken from a string literal and resolved against the static
+ * in-scope namespaces at runtime: `xs:QName("p:l")`, `"p:l" cast as xs:QName`
+ * (also `castable as`, `xs:NOTATION`) and `fn:namespace-uri-for-prefix("p", …)`.
+ * Only literal operands are detected.
+ */
+export function findDynamicPrefixUses(ast, analysis) {
+    const out = [];
+    const fromQNameLiteral = (lit, required) => {
+        if (!lit)
+            return;
+        const text = lit.value.slice(1, -1);
+        const trimmedStart = text.length - text.trimStart().length;
+        const t = text.trim();
+        const c = t.indexOf(":");
+        if (c <= 0)
+            return;
+        out.push({ prefix: t.slice(0, c), offset: lit.start + 1 + trimmedStart, required });
+    };
+    for (const call of findAll(ast, "FunctionCall")) {
+        const fc = asFunctionCall(call, analysis);
+        if (!fc)
+            continue;
+        const { namespaceUri, localName } = fc.qname;
+        const lit = asStringLiteral(fc.args[0]);
+        if (!lit)
+            continue;
+        if (namespaceUri === XMLNS_XS && (localName === "QName" || localName === "NOTATION")) {
+            fromQNameLiteral(lit, true);
+        }
+        else if (namespaceUri === XMLNS_FN && localName === "namespace-uri-for-prefix") {
+            const prefix = lit.value.slice(1, -1);
+            if (prefix.length > 0)
+                out.push({ prefix, offset: lit.start + 1, required: false });
+        }
+    }
+    // castable as never raises an error for an unbound prefix; it just yields false.
+    for (const type of ["CastExpr", "CastableExpr"]) {
+        for (const node of findAll(ast, type)) {
+            const single = directChildOf(node, "SingleType");
+            const typeNode = single && findAll(single, "QName")[0];
+            const typeName = typeNode && firstTerminalValue(typeNode);
+            if (!typeName)
+                continue;
+            const { prefix, localName, uri } = parseEQName(typeName);
+            if ((uri ?? resolvePrefix(prefix, analysis)) !== XMLNS_XS)
+                continue;
+            if (localName !== "QName" && localName !== "NOTATION")
+                continue;
+            fromQNameLiteral(asStringLiteral(node.children[0]), type === "CastExpr");
+        }
+    }
+    return out;
+}
 function checkQName(node, kind, analysis, inlineStack, out) {
     if (!node)
         return;
@@ -23,6 +89,20 @@ function checkQName(node, kind, analysis, inlineStack, out) {
         });
     }
 }
+function inlineXmlnsPrefixes(elem) {
+    const local = new Set();
+    const attrList = directChildOf(elem, "DirAttributeList");
+    if (attrList && !isTerminal(attrList)) {
+        for (const c of attrList.children) {
+            if (c.type !== "QName")
+                continue;
+            const attrName = firstTerminalValue(c);
+            if (attrName?.startsWith("xmlns:"))
+                local.add(attrName.slice(6));
+        }
+    }
+    return local;
+}
 function walk(node, analysis, inlineStack, out) {
     if (isTerminal(node))
         return;
@@ -30,17 +110,7 @@ function walk(node, analysis, inlineStack, out) {
     if (node.type === "DirElemConstructor") {
         // Collect xmlns:prefix declarations from this element's attribute list,
         // then push them onto the scope stack for the duration of this subtree.
-        const local = new Set();
-        const attrList = directChildOf(node, "DirAttributeList");
-        if (attrList && !isTerminal(attrList)) {
-            for (const c of attrList.children) {
-                if (c.type !== "QName")
-                    continue;
-                const attrName = firstTerminalValue(c);
-                if (attrName?.startsWith("xmlns:"))
-                    local.add(attrName.slice(6));
-            }
-        }
+        const local = inlineXmlnsPrefixes(node);
         inlineStack.push(local);
         checkQName(directChildOf(node, "QName"), "element", analysis, inlineStack, out);
         for (const c of children)
@@ -77,6 +147,29 @@ export function findUndeclaredPrefixUsages(ast, analysis) {
         return [];
     const out = [];
     walk(ast, analysis, [], out);
+    // Prefixes inside string literals resolve against the in-scope namespaces, which
+    // include xmlns:prefix declarations of enclosing direct element constructors.
+    const dirElems = findAll(ast, "DirElemConstructor").map((el) => ({
+        start: el.start ?? 0,
+        end: el.end ?? 0,
+        prefixes: inlineXmlnsPrefixes(el),
+    }));
+    for (const use of findDynamicPrefixUses(ast, analysis)) {
+        if (!use.required)
+            continue;
+        if (dirElems.some((el) => el.start <= use.offset && use.offset < el.end && el.prefixes.has(use.prefix)))
+            continue;
+        if (!resolvePrefix(use.prefix, analysis).startsWith("urn:xq-lsp:undeclared:"))
+            continue;
+        out.push({
+            message: `Namespace prefix '${use.prefix}' is not declared`,
+            code: "FONS0004",
+            offset: use.offset,
+            length: use.prefix.length,
+            prefix: use.prefix,
+            usageKind: "element",
+        });
+    }
     return out;
 }
 // ── Insertion-position helpers (used by the code action handler) ─────────────

package/dist/server.js

@@ -18,6 +18,7 @@ import { findConfig, expandGlobs } from "./config.js";
 import { findImportInsertPosition, findDeclareNsInsertPosition, computeRelativePath } from "./namespace-diagnostics.js";
 import { findUndeclaredPrefixUsages } from "./namespace-diagnostics.js";
 import { runDiagnostics, runHints } from "./diagnostics.js";
+import { checkUnresolvedImports } from "./module-import-diagnostics.js";
 import { getRuntimeAnalyses, getRuntimePredeclaredNamespaces, withPredeclaredNs, getRuntimePredeclaredVariables, withPredeclaredVariables, } from "./runtimes.js";
 import { buildOrganizeImportsEdit, buildExtractVariableEdit, buildExtractFunctionEdit } from "./refactor-actions.js";
 import { getWorkspaceSymbols } from "./workspace-symbol.js";
@@ -279,6 +280,7 @@ function computeDiagnostics(doc) {
     const nsDiagRaw = findUndeclaredPrefixUsages(ast, analysis);
     const errorDiagRaw = hasAst && ast !== null ? runDiagnostics(ast, doc.getText(), analysis, resolvedImported) : [];
     const hintDiagRaw = hasAst && ast !== null ? runHints(ast, analysis) : [];
+    const unresolvedImportRaw = hasAst ? checkUnresolvedImports(analysis, resolvedImported) : [];
     function toLsp(d, severity) {
         return {
             severity,
@@ -295,7 +297,8 @@ function computeDiagnostics(doc) {
     // nsDiags already covers XQST0081 (with the code-action data field), so exclude those here.
     const errorDiags = errorDiagRaw.filter((d) => d.code !== "XQST0081").map((d) => toLsp(d, DiagnosticSeverity.Error));
     const hintDiags = hintDiagRaw.map((d) => toLsp(d, DiagnosticSeverity.Hint));
-    return [...parseDiags, ...nsDiags, ...errorDiags, ...hintDiags];
+    const unresolvedImportDiags = unresolvedImportRaw.map((d) => toLsp(d, DiagnosticSeverity.Warning));
+    return [...parseDiags, ...nsDiags, ...errorDiags, ...unresolvedImportDiags, ...hintDiags];
 }
 documents.onDidChangeContent((change) => {
     connection.sendDiagnostics({ uri: change.document.uri, diagnostics: computeDiagnostics(change.document) });
@@ -524,7 +527,7 @@ connection.onCodeAction((params) => {
     const actions = [];
     const only = params.context.only;
     for (const diag of params.context.diagnostics) {
-        if (diag.code !== "XQST0081")
+        if (diag.code !== "XQST0081" && diag.code !== "FONS0004")
             continue;
         const data = diag.data;
         if (!data?.prefix)

package/dist/unused-diagnostics.js

@@ -1,4 +1,5 @@
 import { qnameKey, formatQName } from "./types.js";
+import { findDynamicPrefixUses } from "./namespace-diagnostics.js";
 import { isTerminal, directChildOf, directChildrenOf, findAll, firstTerminalValue, parseEQName, resolvePrefix } from "./analyzer.js";
 import { asFunctionCall, asNamedFunctionRef, asVarRef, asVarName, asFunctionDecl, asFunctionDeclaration, asVariableDeclaration, asBinding, asCatchClause, } from "./ast-nodes.js";
 // ── Scope stack ───────────────────────────────────────────────────────────────
@@ -170,7 +171,7 @@ function walk(node, scope, analysis, usedFns, usedVars) {
  * two terminal types catches every usage site without enumerating each
  * grammar production that can carry a prefix.
  */
-function collectUsedPrefixes(ast) {
+function collectUsedPrefixes(ast, analysis) {
     const used = new Set();
     for (const node of findAll(ast, "QName")) {
         const value = firstTerminalValue(node);
@@ -191,8 +192,13 @@ function collectUsedPrefixes(ast) {
         if (prefix !== "*")
             used.add(prefix);
     }
+    collectDynamicPrefixUses(ast, analysis, used);
     return used;
 }
+function collectDynamicPrefixUses(ast, analysis, used) {
+    for (const use of findDynamicPrefixUses(ast, analysis))
+        used.add(use.prefix);
+}
 // ── Public entry point ────────────────────────────────────────────────────────
 /**
  * Walk the AST and report declared functions and module-level variables that
@@ -248,7 +254,7 @@ export function checkUnused(ast, analysis) {
         });
     }
     // ── Check imports and namespace declarations ─────────────────────────────
-    const usedPrefixes = collectUsedPrefixes(ast);
+    const usedPrefixes = collectUsedPrefixes(ast, analysis);
     for (const imp of analysis.imports) {
         if (usedPrefixes.has(imp.prefix))
             continue;

package/dist/variable-diagnostics.d.ts

@@ -11,6 +11,8 @@ export interface UndeclaredVariableDiagnostic {
  * to a declared variable: function parameter, let/for binding, module-level
  * `declare variable`, or an imported module variable.
  *
+ * Variables whose prefix is bound by an import that did not resolve to an
+ * analysed module are skipped too (XQST0059 reports the import itself).
  * Variables whose namespace prefix is undeclared are skipped — XQST0081
  * already fires for those, and adding XPST0008 on top would be noisy.
  * Variables inside catch clauses are also skipped since the implicit

package/dist/variable-diagnostics.js

@@ -10,10 +10,14 @@ class ScopeStack {
     has(key) { return this.frames.some((f) => f.has(key)); }
 }
 // ── Helpers ───────────────────────────────────────────────────────────────────
-function isKnown(qname, scope, moduleVarKeys) {
+function isKnown(qname, scope, moduleVarKeys, unresolvedImportUris) {
     // Variables with an undeclared-prefix URI are already caught by XQST0081; skip here.
     if (qname.namespaceUri.startsWith("urn:xq-lsp:undeclared:"))
         return true;
+    // The import exists but its module was not analysed (outside the workspace,
+    // generated at install time, …): we cannot know what it declares, so stay silent.
+    if (unresolvedImportUris.has(qname.namespaceUri))
+        return true;
     return scope.has(qnameKey(qname)) || moduleVarKeys.has(qnameKey(qname));
 }
 function reportVarRef(node, qname, out) {
@@ -25,18 +29,18 @@ function reportVarRef(node, qname, out) {
         length: name.length + 1, // +1 for "$"
     });
 }
-function addBinding(bindingNode, scope, analysis, moduleVarKeys, out) {
+function addBinding(bindingNode, scope, analysis, moduleVarKeys, unresolvedImportUris, out) {
     const b = asBinding(bindingNode, analysis);
     if (!b)
         return;
     if (b.initExpr)
-        walk(b.initExpr, scope, analysis, moduleVarKeys, out);
+        walk(b.initExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
     scope.add(qnameKey(b.qname));
     if (b.positionalVar)
         scope.add(qnameKey(b.positionalVar.qname));
 }
 // ── Scope-aware AST walker ────────────────────────────────────────────────────
-function walk(node, scope, analysis, moduleVarKeys, out) {
+function walk(node, scope, analysis, moduleVarKeys, unresolvedImportUris, out) {
     if (isTerminal(node))
         return;
     const { children } = node;
@@ -49,7 +53,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                 for (const p of fn.params)
                     scope.add(qnameKey(p.qname));
                 if (fn.body)
-                    walk(fn.body, scope, analysis, moduleVarKeys, out);
+                    walk(fn.body, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                 scope.pop();
                 return;
             }
@@ -57,7 +61,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
             const varDecl = directChildOf(node, "VarDecl");
             if (varDecl && !isTerminal(varDecl)) {
                 for (const child of varDecl.children)
-                    walk(child, scope, analysis, moduleVarKeys, out);
+                    walk(child, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
             }
             return;
         }
@@ -77,19 +81,19 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                 switch (clause.type) {
                     case "ForClause":
                         for (const b of directChildrenOf(clause, "ForBinding"))
-                            addBinding(b, scope, analysis, moduleVarKeys, out);
+                            addBinding(b, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                         break;
                     case "LetClause":
                         for (const b of directChildrenOf(clause, "LetBinding"))
-                            addBinding(b, scope, analysis, moduleVarKeys, out);
+                            addBinding(b, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                         break;
                     case "CountClause":
-                        addBinding(clause, scope, analysis, moduleVarKeys, out);
+                        addBinding(clause, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                         break;
                     case "GroupByClause": {
                         const specList = directChildOf(clause, "GroupingSpecList");
                         for (const spec of specList ? directChildrenOf(specList, "GroupingSpec") : [])
-                            addBinding(spec, scope, analysis, moduleVarKeys, out);
+                            addBinding(spec, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                         break;
                     }
                     case "WindowClause": {
@@ -99,7 +103,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                         if (b) {
                             // The "in" source expr is evaluated in the outer scope, before $w exists.
                             if (b.initExpr)
-                                walk(b.initExpr, scope, analysis, moduleVarKeys, out);
+                                walk(b.initExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                             // Start/end condition vars ($current/$positional/$previous/$next) are visible
                             // across both conditions and the return clause — but $w itself is not yet bound
                             // while its own boundary conditions are being evaluated.
@@ -121,14 +125,14 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                                 }
                                 const whenExpr = directChildOf(cond, "ExprSingle");
                                 if (whenExpr)
-                                    walk(whenExpr, scope, analysis, moduleVarKeys, out);
+                                    walk(whenExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                             }
                             scope.add(qnameKey(b.qname));
                         }
                         break;
                     }
                     default:
-                        walk(clause, scope, analysis, moduleVarKeys, out);
+                        walk(clause, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                 }
             }
             scope.pop();
@@ -145,7 +149,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                         scope.add(qnameKey(qname));
                 }
                 else {
-                    walk(child, scope, analysis, moduleVarKeys, out);
+                    walk(child, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                 }
             }
             scope.pop();
@@ -159,7 +163,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
             for (const p of fn.params)
                 scope.add(qnameKey(p.qname));
             if (fn.body)
-                walk(fn.body, scope, analysis, moduleVarKeys, out);
+                walk(fn.body, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
             scope.pop();
             return;
         }
@@ -169,7 +173,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
         case "TypeswitchExpr": {
             const operand = directChildOf(node, "Expr");
             if (operand)
-                walk(operand, scope, analysis, moduleVarKeys, out);
+                walk(operand, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
             for (const caseClause of directChildrenOf(node, "CaseClause")) {
                 scope.push();
                 const varNameNode = directChildOf(caseClause, "VarName");
@@ -178,7 +182,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                     scope.add(qnameKey(qname));
                 const returnExpr = directChildOf(caseClause, "ExprSingle");
                 if (returnExpr)
-                    walk(returnExpr, scope, analysis, moduleVarKeys, out);
+                    walk(returnExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                 scope.pop();
             }
             // `default $v return ...` — $v (optional) and the return expr are direct
@@ -190,7 +194,7 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                 scope.add(qnameKey(defaultQname));
             const defaultExpr = directChildOf(node, "ExprSingle");
             if (defaultExpr)
-                walk(defaultExpr, scope, analysis, moduleVarKeys, out);
+                walk(defaultExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
             scope.pop();
             return;
         }
@@ -200,25 +204,25 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
                 break;
             scope.push();
             for (const b of tx.copyBindings) {
-                walk(b.initExpr, scope, analysis, moduleVarKeys, out);
+                walk(b.initExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
                 scope.add(qnameKey(b.qname));
             }
             if (tx.modifyExpr)
-                walk(tx.modifyExpr, scope, analysis, moduleVarKeys, out);
+                walk(tx.modifyExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
             if (tx.returnExpr)
-                walk(tx.returnExpr, scope, analysis, moduleVarKeys, out);
+                walk(tx.returnExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
             scope.pop();
             return;
         }
         case "VarRef": {
             const qname = asVarRef(node, analysis);
-            if (qname && !isKnown(qname, scope, moduleVarKeys))
+            if (qname && !isKnown(qname, scope, moduleVarKeys, unresolvedImportUris))
                 reportVarRef(node, qname, out);
             return;
         }
         default:
             for (const child of children)
-                walk(child, scope, analysis, moduleVarKeys, out);
+                walk(child, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
     }
 }
 // ── Public entry point ────────────────────────────────────────────────────────
@@ -227,6 +231,8 @@ function walk(node, scope, analysis, moduleVarKeys, out) {
  * to a declared variable: function parameter, let/for binding, module-level
  * `declare variable`, or an imported module variable.
  *
+ * Variables whose prefix is bound by an import that did not resolve to an
+ * analysed module are skipped too (XQST0059 reports the import itself).
  * Variables whose namespace prefix is undeclared are skipped — XQST0081
  * already fires for those, and adding XPST0008 on top would be noisy.
  * Variables inside catch clauses are also skipped since the implicit
@@ -239,7 +245,9 @@ export function checkUndeclaredVariables(ast, analysis, importedAnalyses) {
     for (const imported of importedAnalyses.values())
         for (const v of imported.moduleVariables)
             moduleVarKeys.add(qnameKey(v.qname));
+    // Imports whose module was not analysed: their variables are unknowable.
+    const unresolvedImportUris = new Set(analysis.imports.map((i) => i.namespaceUri).filter((u) => !importedAnalyses.has(u)));
     const out = [];
-    walk(ast, new ScopeStack(), analysis, moduleVarKeys, out);
+    walk(ast, new ScopeStack(), analysis, moduleVarKeys, unresolvedImportUris, out);
     return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xq-lsp",
-	"version": "1.8.3-next.430",
+	"version": "1.8.3-next.439",
 	"description": "XQuery Language Server Protocol implementation",
 	"license": "MIT",
 	"author": "Martin Middel",

package/src/module-import-diagnostics.ts

@@ -41,3 +41,31 @@ export function checkModuleImportTargets(
 	}
 	return out;
 }
+
+export interface UnresolvedImportDiagnostic extends TypeDiagnostic {
+	code: "xq-lsp:unresolved-import";
+}
+
+/**
+ * Report imports whose module could not be loaded. Variable and function
+ * checks stay silent for such namespaces, so this is where the user learns
+ * why. Reported as a warning (not XQST0059) because the module may
+ * legitimately live outside the workspace or be generated at install time.
+ */
+export function checkUnresolvedImports(
+	analysis: FileAnalysis,
+	importedAnalyses: Map<string, FileAnalysis>,
+): UnresolvedImportDiagnostic[] {
+	const out: UnresolvedImportDiagnostic[] = [];
+	for (const imp of analysis.imports) {
+		if (importedAnalyses.has(imp.atPath ?? imp.namespaceUri) || importedAnalyses.has(imp.namespaceUri)) continue;
+		const location = imp.atPath ? `at '${imp.atPath}'` : `for namespace '${imp.namespaceUri}'`;
+		out.push({
+			message: `Module ${location} could not be resolved; its functions and variables are not checked`,
+			code: "xq-lsp:unresolved-import",
+			offset: imp.offset,
+			length: imp.prefix.length,
+		});
+	}
+	return out;
+}

package/src/namespace-diagnostics.ts

@@ -1,18 +1,96 @@
-import type { Node } from "xq-parser";
+import type { Node, NonTerminal, Terminal } from "xq-parser";
 import type { FileAnalysis } from "./types.ts";
-import { isTerminal, directChildOf, firstTerminalValue, resolvePrefix } from "./analyzer.ts";
+import {
+	XMLNS_FN,
+	XMLNS_XS,
+	isTerminal,
+	directChildOf,
+	findAll,
+	firstTerminalValue,
+	parseEQName,
+	resolvePrefix,
+} from "./analyzer.ts";
+import { asFunctionCall } from "./ast-nodes.ts";
 
 export type NamespaceUsageKind = "function" | "variable" | "element";
 
 export interface NamespaceDiagnostic {
 	message: string;
-	code: "XQST0081";
+	code: "XQST0081" | "FONS0004";
 	offset: number; // offset of the prefix start in source
 	length: number; // length of the prefix (not including the colon)
 	prefix: string;
 	usageKind: NamespaceUsageKind;
 }
 
+/** Unwraps single-child grammar wrappers down to a StringLiteral terminal; null for anything more complex. */
+function asStringLiteral(node: Node | undefined): Terminal | null {
+	let cur: Node | undefined = node;
+	while (cur && !isTerminal(cur)) {
+		const children = (cur as NonTerminal).children;
+		if (children.length !== 1) return null;
+		cur = children[0];
+	}
+	return cur && cur.type === "StringLiteral" ? (cur as Terminal) : null;
+}
+
+export interface DynamicPrefixUse {
+	/** The prefix text. */
+	prefix: string;
+	/** Source offset of the prefix (inside the string literal). */
+	offset: number;
+	/** True when an unbound prefix is an error (xs:QName / xs:NOTATION); false for namespace-uri-for-prefix, which just returns (). */
+	required: boolean;
+}
+
+/**
+ * Prefixes taken from a string literal and resolved against the static
+ * in-scope namespaces at runtime: `xs:QName("p:l")`, `"p:l" cast as xs:QName`
+ * (also `castable as`, `xs:NOTATION`) and `fn:namespace-uri-for-prefix("p", …)`.
+ * Only literal operands are detected.
+ */
+export function findDynamicPrefixUses(ast: Node, analysis: FileAnalysis): DynamicPrefixUse[] {
+	const out: DynamicPrefixUse[] = [];
+	const fromQNameLiteral = (lit: Terminal | null, required: boolean): void => {
+		if (!lit) return;
+		const text = lit.value.slice(1, -1);
+		const trimmedStart = text.length - text.trimStart().length;
+		const t = text.trim();
+		const c = t.indexOf(":");
+		if (c <= 0) return;
+		out.push({ prefix: t.slice(0, c), offset: lit.start + 1 + trimmedStart, required });
+	};
+
+	for (const call of findAll(ast, "FunctionCall")) {
+		const fc = asFunctionCall(call, analysis);
+		if (!fc) continue;
+		const { namespaceUri, localName } = fc.qname;
+		const lit = asStringLiteral(fc.args[0]);
+		if (!lit) continue;
+		if (namespaceUri === XMLNS_XS && (localName === "QName" || localName === "NOTATION")) {
+			fromQNameLiteral(lit, true);
+		} else if (namespaceUri === XMLNS_FN && localName === "namespace-uri-for-prefix") {
+			const prefix = lit.value.slice(1, -1);
+			if (prefix.length > 0) out.push({ prefix, offset: lit.start + 1, required: false });
+		}
+	}
+
+	// castable as never raises an error for an unbound prefix; it just yields false.
+	for (const type of ["CastExpr", "CastableExpr"]) {
+		for (const node of findAll(ast, type)) {
+			const single = directChildOf(node, "SingleType");
+			const typeNode = single && findAll(single, "QName")[0];
+			const typeName = typeNode && firstTerminalValue(typeNode);
+			if (!typeName) continue;
+			const { prefix, localName, uri } = parseEQName(typeName);
+			if ((uri ?? resolvePrefix(prefix, analysis)) !== XMLNS_XS) continue;
+			if (localName !== "QName" && localName !== "NOTATION") continue;
+			fromQNameLiteral(asStringLiteral((node as NonTerminal).children[0]), type === "CastExpr");
+		}
+	}
+	return out;
+}
+
 function checkQName(
 	node: Node | undefined,
 	kind: NamespaceUsageKind,
@@ -40,6 +118,19 @@ function checkQName(
 	}
 }
 
+function inlineXmlnsPrefixes(elem: Node): Set<string> {
+	const local = new Set<string>();
+	const attrList = directChildOf(elem, "DirAttributeList");
+	if (attrList && !isTerminal(attrList)) {
+		for (const c of (attrList as { children: Node[] }).children) {
+			if (c.type !== "QName") continue;
+			const attrName = firstTerminalValue(c);
+			if (attrName?.startsWith("xmlns:")) local.add(attrName.slice(6));
+		}
+	}
+	return local;
+}
+
 function walk(
 	node: Node,
 	analysis: FileAnalysis,
@@ -52,15 +143,7 @@ function walk(
 	if (node.type === "DirElemConstructor") {
 		// Collect xmlns:prefix declarations from this element's attribute list,
 		// then push them onto the scope stack for the duration of this subtree.
-		const local = new Set<string>();
-		const attrList = directChildOf(node, "DirAttributeList");
-		if (attrList && !isTerminal(attrList)) {
-			for (const c of (attrList as { children: Node[] }).children) {
-				if (c.type !== "QName") continue;
-				const attrName = firstTerminalValue(c);
-				if (attrName?.startsWith("xmlns:")) local.add(attrName.slice(6));
-			}
-		}
+		const local = inlineXmlnsPrefixes(node);
 		inlineStack.push(local);
 		checkQName(directChildOf(node, "QName"), "element", analysis, inlineStack, out);
 		for (const c of children) walk(c, analysis, inlineStack, out);
@@ -100,6 +183,27 @@ export function findUndeclaredPrefixUsages(
 	if (!ast) return [];
 	const out: NamespaceDiagnostic[] = [];
 	walk(ast, analysis, [], out);
+
+	// Prefixes inside string literals resolve against the in-scope namespaces, which
+	// include xmlns:prefix declarations of enclosing direct element constructors.
+	const dirElems = findAll(ast, "DirElemConstructor").map((el) => ({
+		start: el.start ?? 0,
+		end: el.end ?? 0,
+		prefixes: inlineXmlnsPrefixes(el),
+	}));
+	for (const use of findDynamicPrefixUses(ast, analysis)) {
+		if (!use.required) continue;
+		if (dirElems.some((el) => el.start <= use.offset && use.offset < el.end && el.prefixes.has(use.prefix))) continue;
+		if (!resolvePrefix(use.prefix, analysis).startsWith("urn:xq-lsp:undeclared:")) continue;
+		out.push({
+			message: `Namespace prefix '${use.prefix}' is not declared`,
+			code: "FONS0004",
+			offset: use.offset,
+			length: use.prefix.length,
+			prefix: use.prefix,
+			usageKind: "element",
+		});
+	}
 	return out;
 }
 

package/src/server.ts

@@ -35,6 +35,7 @@ import { findImportInsertPosition, findDeclareNsInsertPosition, computeRelativeP
 import type { NamespaceUsageKind } from "./namespace-diagnostics.ts";
 import { findUndeclaredPrefixUsages } from "./namespace-diagnostics.ts";
 import { runDiagnostics, runHints } from "./diagnostics.ts";
+import { checkUnresolvedImports } from "./module-import-diagnostics.ts";
 import {
 	getRuntimeAnalyses,
 	getRuntimePredeclaredNamespaces,
@@ -327,6 +328,8 @@ function computeDiagnostics(doc: TextDocument) {
 	const errorDiagRaw = hasAst && ast !== null ? runDiagnostics(ast, doc.getText(), analysis, resolvedImported) : [];
 	const hintDiagRaw = hasAst && ast !== null ? runHints(ast, analysis) : [];
 
+	const unresolvedImportRaw = hasAst ? checkUnresolvedImports(analysis, resolvedImported) : [];
+
 	function toLsp(d: TypeDiagnostic, severity: DiagnosticSeverity) {
 		return {
 			severity,
@@ -345,7 +348,9 @@ function computeDiagnostics(doc: TextDocument) {
 	const errorDiags = errorDiagRaw.filter((d) => d.code !== "XQST0081").map((d) => toLsp(d, DiagnosticSeverity.Error));
 	const hintDiags = hintDiagRaw.map((d) => toLsp(d, DiagnosticSeverity.Hint));
 
-	return [...parseDiags, ...nsDiags, ...errorDiags, ...hintDiags];
+	const unresolvedImportDiags = unresolvedImportRaw.map((d) => toLsp(d, DiagnosticSeverity.Warning));
+
+	return [...parseDiags, ...nsDiags, ...errorDiags, ...unresolvedImportDiags, ...hintDiags];
 }
 
 documents.onDidChangeContent((change) => {
@@ -588,7 +593,7 @@ connection.onCodeAction((params) => {
 	const only = params.context.only as CodeActionKind[] | undefined;
 
 	for (const diag of params.context.diagnostics) {
-		if (diag.code !== "XQST0081") continue;
+		if (diag.code !== "XQST0081" && diag.code !== "FONS0004") continue;
 		const data = diag.data as { prefix: string; usageKind: NamespaceUsageKind } | undefined;
 		if (!data?.prefix) continue;
 

package/src/unused-diagnostics.ts

@@ -1,6 +1,7 @@
 import type { Node, NonTerminal } from "xq-parser";
 import type { FileAnalysis } from "./types.ts";
 import { qnameKey, formatQName } from "./types.ts";
+import { findDynamicPrefixUses } from "./namespace-diagnostics.ts";
 import { isTerminal, directChildOf, directChildrenOf, findAll, firstTerminalValue, parseEQName, resolvePrefix } from "./analyzer.ts";
 import {
 	asFunctionCall,
@@ -198,7 +199,7 @@ function walk(
  * two terminal types catches every usage site without enumerating each
  * grammar production that can carry a prefix.
  */
-function collectUsedPrefixes(ast: Node): Set<string> {
+function collectUsedPrefixes(ast: Node, analysis: FileAnalysis): Set<string> {
 	const used = new Set<string>();
 
 	for (const node of findAll(ast, "QName")) {
@@ -217,9 +218,15 @@ function collectUsedPrefixes(ast: Node): Set<string> {
 		if (prefix !== "*") used.add(prefix);
 	}
 
+	collectDynamicPrefixUses(ast, analysis, used);
+
 	return used;
 }
 
+function collectDynamicPrefixUses(ast: Node, analysis: FileAnalysis, used: Set<string>): void {
+	for (const use of findDynamicPrefixUses(ast, analysis)) used.add(use.prefix);
+}
+
 // ── Public entry point ────────────────────────────────────────────────────────
 
 /**
@@ -278,7 +285,7 @@ export function checkUnused(ast: Node, analysis: FileAnalysis): UnusedDiagnostic
 
 	// ── Check imports and namespace declarations ─────────────────────────────
 
-	const usedPrefixes = collectUsedPrefixes(ast);
+	const usedPrefixes = collectUsedPrefixes(ast, analysis);
 
 	for (const imp of analysis.imports) {
 		if (usedPrefixes.has(imp.prefix)) continue;

package/src/variable-diagnostics.ts

@@ -23,9 +23,12 @@ class ScopeStack {
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
-function isKnown(qname: QName, scope: ScopeStack, moduleVarKeys: Set<string>): boolean {
+function isKnown(qname: QName, scope: ScopeStack, moduleVarKeys: Set<string>, unresolvedImportUris: Set<string>): boolean {
 	// Variables with an undeclared-prefix URI are already caught by XQST0081; skip here.
 	if (qname.namespaceUri.startsWith("urn:xq-lsp:undeclared:")) return true;
+	// The import exists but its module was not analysed (outside the workspace,
+	// generated at install time, …): we cannot know what it declares, so stay silent.
+	if (unresolvedImportUris.has(qname.namespaceUri)) return true;
 	return scope.has(qnameKey(qname)) || moduleVarKeys.has(qnameKey(qname));
 }
 
@@ -44,11 +47,12 @@ function addBinding(
 	scope: ScopeStack,
 	analysis: FileAnalysis,
 	moduleVarKeys: Set<string>,
+	unresolvedImportUris: Set<string>,
 	out: UndeclaredVariableDiagnostic[],
 ): void {
 	const b = asBinding(bindingNode, analysis);
 	if (!b) return;
-	if (b.initExpr) walk(b.initExpr, scope, analysis, moduleVarKeys, out);
+	if (b.initExpr) walk(b.initExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 	scope.add(qnameKey(b.qname));
 	if (b.positionalVar) scope.add(qnameKey(b.positionalVar.qname));
 }
@@ -60,6 +64,7 @@ function walk(
 	scope: ScopeStack,
 	analysis: FileAnalysis,
 	moduleVarKeys: Set<string>,
+	unresolvedImportUris: Set<string>,
 	out: UndeclaredVariableDiagnostic[],
 ): void {
 	if (isTerminal(node)) return;
@@ -72,7 +77,7 @@ function walk(
 			if (fn) {
 				scope.push();
 				for (const p of fn.params) scope.add(qnameKey(p.qname));
-				if (fn.body) walk(fn.body, scope, analysis, moduleVarKeys, out);
+				if (fn.body) walk(fn.body, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 				scope.pop();
 				return;
 			}
@@ -80,7 +85,7 @@ function walk(
 			const varDecl = directChildOf(node, "VarDecl");
 			if (varDecl && !isTerminal(varDecl)) {
 				for (const child of (varDecl as NonTerminal).children)
-					walk(child, scope, analysis, moduleVarKeys, out);
+					walk(child, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 			}
 			return;
 		}
@@ -99,19 +104,19 @@ function walk(
 				switch (clause.type) {
 					case "ForClause":
 						for (const b of directChildrenOf(clause, "ForBinding"))
-							addBinding(b, scope, analysis, moduleVarKeys, out);
+							addBinding(b, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 						break;
 					case "LetClause":
 						for (const b of directChildrenOf(clause, "LetBinding"))
-							addBinding(b, scope, analysis, moduleVarKeys, out);
+							addBinding(b, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 						break;
 					case "CountClause":
-						addBinding(clause, scope, analysis, moduleVarKeys, out);
+						addBinding(clause, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 						break;
 					case "GroupByClause": {
 						const specList = directChildOf(clause, "GroupingSpecList");
 						for (const spec of specList ? directChildrenOf(specList, "GroupingSpec") : [])
-							addBinding(spec, scope, analysis, moduleVarKeys, out);
+							addBinding(spec, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 						break;
 					}
 					case "WindowClause": {
@@ -121,7 +126,7 @@ function walk(
 						const b = inner ? asBinding(inner, analysis) : null;
 						if (b) {
 							// The "in" source expr is evaluated in the outer scope, before $w exists.
-							if (b.initExpr) walk(b.initExpr, scope, analysis, moduleVarKeys, out);
+							if (b.initExpr) walk(b.initExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 							// Start/end condition vars ($current/$positional/$previous/$next) are visible
 							// across both conditions and the return clause — but $w itself is not yet bound
 							// while its own boundary conditions are being evaluated.
@@ -137,14 +142,14 @@ function walk(
 									if (wv.nextItem) scope.add(qnameKey(wv.nextItem));
 								}
 								const whenExpr = directChildOf(cond, "ExprSingle");
-								if (whenExpr) walk(whenExpr, scope, analysis, moduleVarKeys, out);
+								if (whenExpr) walk(whenExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 							}
 							scope.add(qnameKey(b.qname));
 						}
 						break;
 					}
 					default:
-						walk(clause, scope, analysis, moduleVarKeys, out);
+						walk(clause, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 				}
 			}
 			scope.pop();
@@ -159,7 +164,7 @@ function walk(
 					const qname = asVarName(child, analysis);
 					if (qname) scope.add(qnameKey(qname));
 				} else {
-					walk(child, scope, analysis, moduleVarKeys, out);
+					walk(child, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 				}
 			}
 			scope.pop();
@@ -171,7 +176,7 @@ function walk(
 			if (!fn) break;
 			scope.push();
 			for (const p of fn.params) scope.add(qnameKey(p.qname));
-			if (fn.body) walk(fn.body, scope, analysis, moduleVarKeys, out);
+			if (fn.body) walk(fn.body, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 			scope.pop();
 			return;
 		}
@@ -182,14 +187,14 @@ function walk(
 
 		case "TypeswitchExpr": {
 			const operand = directChildOf(node, "Expr");
-			if (operand) walk(operand, scope, analysis, moduleVarKeys, out);
+			if (operand) walk(operand, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 			for (const caseClause of directChildrenOf(node, "CaseClause")) {
 				scope.push();
 				const varNameNode = directChildOf(caseClause, "VarName");
 				const qname = varNameNode ? asVarName(varNameNode, analysis) : null;
 				if (qname) scope.add(qnameKey(qname));
 				const returnExpr = directChildOf(caseClause, "ExprSingle");
-				if (returnExpr) walk(returnExpr, scope, analysis, moduleVarKeys, out);
+				if (returnExpr) walk(returnExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 				scope.pop();
 			}
 			// `default $v return ...` — $v (optional) and the return expr are direct
@@ -199,7 +204,7 @@ function walk(
 			const defaultQname = defaultVarNode ? asVarName(defaultVarNode, analysis) : null;
 			if (defaultQname) scope.add(qnameKey(defaultQname));
 			const defaultExpr = directChildOf(node, "ExprSingle");
-			if (defaultExpr) walk(defaultExpr, scope, analysis, moduleVarKeys, out);
+			if (defaultExpr) walk(defaultExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 			scope.pop();
 			return;
 		}
@@ -209,24 +214,24 @@ function walk(
 			if (!tx) break;
 			scope.push();
 			for (const b of tx.copyBindings) {
-				walk(b.initExpr, scope, analysis, moduleVarKeys, out);
+				walk(b.initExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 				scope.add(qnameKey(b.qname));
 			}
-			if (tx.modifyExpr) walk(tx.modifyExpr, scope, analysis, moduleVarKeys, out);
-			if (tx.returnExpr) walk(tx.returnExpr, scope, analysis, moduleVarKeys, out);
+			if (tx.modifyExpr) walk(tx.modifyExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
+			if (tx.returnExpr) walk(tx.returnExpr, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 			scope.pop();
 			return;
 		}
 
 		case "VarRef": {
 			const qname = asVarRef(node, analysis);
-			if (qname && !isKnown(qname, scope, moduleVarKeys))
+			if (qname && !isKnown(qname, scope, moduleVarKeys, unresolvedImportUris))
 				reportVarRef(node, qname, out);
 			return;
 		}
 
 		default:
-			for (const child of children) walk(child, scope, analysis, moduleVarKeys, out);
+			for (const child of children) walk(child, scope, analysis, moduleVarKeys, unresolvedImportUris, out);
 	}
 }
 
@@ -237,6 +242,8 @@ function walk(
  * to a declared variable: function parameter, let/for binding, module-level
  * `declare variable`, or an imported module variable.
  *
+ * Variables whose prefix is bound by an import that did not resolve to an
+ * analysed module are skipped too (XQST0059 reports the import itself).
  * Variables whose namespace prefix is undeclared are skipped — XQST0081
  * already fires for those, and adding XPST0008 on top would be noisy.
  * Variables inside catch clauses are also skipped since the implicit
@@ -252,7 +259,12 @@ export function checkUndeclaredVariables(
 	for (const imported of importedAnalyses.values())
 		for (const v of imported.moduleVariables) moduleVarKeys.add(qnameKey(v.qname));
 
+	// Imports whose module was not analysed: their variables are unknowable.
+	const unresolvedImportUris = new Set(
+		analysis.imports.map((i) => i.namespaceUri).filter((u) => !importedAnalyses.has(u)),
+	);
+
 	const out: UndeclaredVariableDiagnostic[] = [];
-	walk(ast, new ScopeStack(), analysis, moduleVarKeys, out);
+	walk(ast, new ScopeStack(), analysis, moduleVarKeys, unresolvedImportUris, out);
 	return out;
 }