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

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

@@ -524,7 +524,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/package.json

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

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

@@ -588,7 +588,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;