xq-lsp 1.8.2 → 1.8.3-next.430

package/dist/typechecker.d.ts

@@ -2,6 +2,53 @@ import type { Node } from "xq-parser";
 import type { XQueryType, TypeDiagnostic, FileAnalysis, FunctionSymbol } from "./types.ts";
 export declare function parseType(typeStr: string): XQueryType;
 export declare function isAssignable(from: XQueryType, to: XQueryType): boolean;
+/** The type of a single item of `t` — e.g. what a `for` variable over `t` holds. */
+export declare function itemTypeOf(t: XQueryType): XQueryType;
+/** Type of an expression that yields either `a` or `b` (if/else, switch, typeswitch, try/catch). */
+export declare function choiceType(a: XQueryType, b: XQueryType): XQueryType;
+/** Type of the sequence `(a, b)`. */
+export declare function concatType(a: XQueryType, b: XQueryType): XQueryType;
+/** Finds the declaration a call with `argCount` arguments resolves to, honouring variadic functions. */
+export declare function resolveFunction(qname: {
+    namespaceUri: string;
+    localName: string;
+}, argCount: number, allFns: FunctionSymbol[]): FunctionSymbol | undefined;
+/**
+ * Lets callers observe the sub-expressions a scoped construct evaluates (with the scope
+ * they're evaluated in) and the bindings it introduces. `binding` fires only for bindings
+ * without a declared type — those are the ones whose type is inferred.
+ */
+export interface ScopeVisitor {
+    expr?(node: Node, scope: Map<string, XQueryType>): void;
+    binding?(nameNode: Node, type: XQueryType): void;
+}
 export declare function inferExprType(node: Node, varTypes: Map<string, XQueryType>, analysis: FileAnalysis, allFns: FunctionSymbol[]): XQueryType;
 export declare function formatType(t: XQueryType): string;
-export declare function checkTypes(ast: Node, text: string, analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): TypeDiagnostic[];
+export interface ScopeWalkHooks {
+    /** Called for every non-terminal, with the variable types in scope at that point. */
+    onNode?(node: Node, scope: Map<string, XQueryType>): void;
+    /** Called for every variable binding without a declared type, with its inferred type. */
+    onBinding?(nameNode: Node, type: XQueryType): void;
+}
+/**
+ * Fills in `returnType` for functions in this module declared without `as …`, inferred from
+ * their bodies. Iterates to a fixpoint (bounded) so functions calling other untyped functions,
+ * declared before or after them, resolve too; directly recursive functions stay unknown unless
+ * a non-recursive branch alone determines the type. Callers use the returned list in place of
+ * `allFns` so every call site — hints and type checks alike — sees the inferred types.
+ */
+export declare function withInferredReturnTypes(ast: Node, analysis: FileAnalysis, allFns: FunctionSymbol[], outerScope?: Map<string, XQueryType>): FunctionSymbol[];
+/**
+ * Types of variables visible in this module without being declared in its source: variables
+ * of imported modules and runtime-predeclared ones. A declared `as` type is used as written;
+ * an untyped imported variable is inferred from its initializer when that module's AST is at
+ * hand (it isn't for lightweight glob summaries).
+ */
+export declare function externalVariableTypes(analysis: FileAnalysis, imported: Iterable<FileAnalysis>, allFns: FunctionSymbol[]): Map<string, XQueryType>;
+/**
+ * Walks a whole module with lexically correct variable scopes: module variables (declared or
+ * inferred, in declaration order), function parameters inside each function body, and
+ * FLWOR / quantified / typeswitch / inline-function bindings within their own sub-trees.
+ */
+export declare function walkModuleScopes(ast: Node, analysis: FileAnalysis, allFns: FunctionSymbol[], hooks: ScopeWalkHooks, outerScope?: Map<string, XQueryType>): void;
+export declare function checkTypes(ast: Node, _text: string, analysis: FileAnalysis, importedAnalyses: Map<string, FileAnalysis>): TypeDiagnostic[];