@rsconcept/domain 1.7.0 → 1.7.2

package/dist/{rslang/parser/syntax-errors.js → syntax-errors-B6c2vsan.js}

@@ -1,137 +1,162 @@
-import { annotateError } from "../ast-annotations.js";
-import { RSErrorCode } from "../error.js";
-import { visitAstDFS } from "../../parsing/ast.js";
-import "../../parsing/index.js";
-import { TokenID } from "./token.js";
-import { TypeClass } from "../semantic/typification.js";
-import "./parser.terms.js";
-//#region src/rslang/parser/syntax-errors.ts
-/**
-* Module: Syntactic errors reporting.
-*/
-/** Extracts syntax errors from an AST. */
-function extractSyntaxErrors(ast, expression, reporter, annotateErrors = false, options) {
-	const forbiddenErrors = extractForbiddenCharacterErrors(expression);
-	if (forbiddenErrors.length > 0) {
-		for (const error of forbiddenErrors) {
-			reporter(error);
-			if (annotateErrors) annotateError(ast, error.code, error.params);
-		}
-		return;
-	}
-	const collected = [];
-	const annotationTargets = /* @__PURE__ */ new Map();
-	const collect = (error, target) => {
-		collected.push(error);
-		if (target !== void 0) annotationTargets.set(error, target);
-	};
-	const bracketError = extractBracketErrors(expression);
-	const hasBracketErrors = bracketError !== null;
-	visitAstDFS(ast, (node) => extractInternal(node, expression, collect, hasBracketErrors, options));
-	const hasIncompleteGenerator = collected.some((error) => isIncompleteGeneratorBodyCode(error.code));
-	if (bracketError !== null && !hasIncompleteGenerator) collect(bracketError, ast);
-	for (const error of deduplicateErrors(collected)) {
-		reporter(error);
-		if (annotateErrors) {
-			const target = annotationTargets.get(error);
-			if (target !== void 0) annotateError(target, error.code, error.params);
-		}
+import { annotateError } from "./rslang/ast-annotations.js";
+import { RSErrorCode } from "./rslang/error.js";
+import { visitAstDFS } from "./parsing/ast.js";
+import "./parsing/index.js";
+import { TokenID } from "./rslang/parser/token.js";
+import { TypeClass } from "./rslang/semantic/typification.js";
+import "./rslang/parser/parser.terms.js";
+//#region src/rslang/parser/syntax-errors/context.ts
+/** Skips classifiers that conflict with bracket-level diagnostics. */
+function whenNoBracketErrors(classifier) {
+	return (node, expression, context) => context.hasBracketErrors ? null : classifier(node, expression, context);
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/ast-utils.ts
+function findAncestor(node, predicate) {
+	let current = node;
+	while (current !== null) {
+		if (predicate(current)) return current;
+		current = current.parent;
 	}
+	return null;
 }
-function extractInternal(node, expression, collect, ignoreUnknownErrors, options) {
-	if (node.typeID !== TokenID.ERROR) return;
-	function emit(target, code, params) {
-		collect({
-			code,
-			from: target.from,
-			to: target.to,
-			params
-		}, target);
+function findRelatedNode(node, predicate) {
+	let current = node.parent;
+	while (current !== null) {
+		for (const child of current.children) if (predicate(child)) return child;
+		current = current.parent;
 	}
-	const classified = classifyParseError(node, expression, options);
-	if (classified !== null) {
-		collect(classified, node);
-		return;
+	return null;
+}
+function isDescendantOf(ancestor, node) {
+	let current = node.parent;
+	while (current !== null) {
+		if (current === ancestor) return true;
+		current = current.parent;
 	}
-	const parent = node.parent;
-	if (parent === null) {
-		if (!ignoreUnknownErrors) return emit(node, RSErrorCode.unknownSyntax);
-		return;
+	return false;
+}
+function subtreeHasError(node) {
+	if (node.typeID === TokenID.ERROR) return true;
+	return node.children.some(subtreeHasError);
+}
+function isFunctionDeclNode(node) {
+	return node.typeID === 76 || node.typeID === TokenID.NT_FUNC_DEFINITION;
+}
+function isQuantifierNode(node) {
+	return node.typeID === 29;
+}
+function isFunctionNode(node) {
+	return node.typeID === 69 || node.typeID === TokenID.ID_FUNCTION;
+}
+function isPredicateNode(node) {
+	return node.typeID === 26 || node.typeID === TokenID.ID_PREDICATE;
+}
+function isFilterNode(node) {
+	return node.typeID === 59 || node.typeID === TokenID.FILTER;
+}
+function findMatchingCloseBracket(expression, openPos) {
+	if (expression[openPos] !== "[") return -1;
+	let depth = 0;
+	for (let index = openPos; index < expression.length; index++) {
+		const symbol = expression[index];
+		if (symbol === "[") depth++;
+		else if (symbol === "]") {
+			depth--;
+			if (depth === 0) return index;
+		}
 	}
-	if (parent.typeID === 4) return emit(parent, RSErrorCode.expectedLocal);
-	if (!ignoreUnknownErrors) emit(node.from === node.to ? parent : node, RSErrorCode.unknownSyntax);
-}
-function classifyParseError(node, expression, options) {
-	const incompleteFunctionDecl = detectIncompleteFunctionDecl(node, expression, options?.expected);
-	if (incompleteFunctionDecl !== null) return incompleteFunctionDecl;
-	const incompleteQuantifier = detectIncompleteQuantifier(node, expression);
-	if (incompleteQuantifier !== null) return incompleteQuantifier;
-	const incompleteGenerator = detectIncompleteGenerator(node, expression);
-	if (incompleteGenerator !== null) return incompleteGenerator;
-	const filterParen = detectFilterParenMismatch(node, expression);
-	if (filterParen !== null) return filterParen;
-	return detectGlobalFuncWithoutArgs(node, expression);
+	return -1;
 }
-function detectIncompleteFunctionDecl(node, expression, expected) {
-	const funcDecl = findAncestor(node, isFunctionDeclNode);
-	if (funcDecl === null) return null;
-	const bodyChild = funcDecl.children[funcDecl.children.length - 1];
-	if (bodyChild?.typeID !== TokenID.ERROR || node !== bodyChild) return null;
-	const argsNode = funcDecl.children.find((child) => child.typeID === 77 || child.typeID === TokenID.NT_ARGUMENTS);
-	if (argsNode === void 0 || subtreeHasError(argsNode)) return null;
-	if (expression.slice(funcDecl.to).trim().length > 0) return null;
+function getErrorOperandNode(node) {
+	if (node.typeID === TokenID.ERROR) return node;
+	if (node.children.length === 1) return getErrorOperandNode(node.children[0]);
+	return null;
+}
+function isErrorPlaceholder(node) {
+	if (node.typeID === TokenID.ERROR) return true;
+	if (node.children.length === 0) return false;
+	return node.children.every((child) => isErrorPlaceholder(child));
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/function-calls.ts
+const classifyFilterParenMismatch = (node, expression) => {
+	const filterNode = findAncestor(node, isFilterNode) ?? findRelatedNode(node, isFilterNode);
+	if (filterNode === null || expression[filterNode.to] !== "(") return null;
 	return {
-		code: incompleteFormalExpressionCode(expected),
-		from: bodyChild.from,
-		to: bodyChild.to
+		code: RSErrorCode.invalidFilterSyntax,
+		from: filterNode.from,
+		to: filterNode.to + 1
 	};
+};
+const classifyGlobalFuncCall = (node, expression) => {
+	const funcNode = findAncestor(node, (n) => isFunctionNode(n) || isPredicateNode(n)) ?? findRelatedNode(node, (n) => isFunctionNode(n) || isPredicateNode(n));
+	if (funcNode === null) return null;
+	return classifyFuncWithoutArgs(funcNode, expression);
+};
+function classifyFuncWithoutArgs(funcNode, expression) {
+	const name = expression.slice(funcNode.from, funcNode.to);
+	const rest = expression.slice(funcNode.to);
+	const withoutArgs = {
+		code: RSErrorCode.globalFuncWithoutArgs,
+		from: funcNode.from,
+		to: funcNode.to,
+		params: [name]
+	};
+	if (/^\s*$/.test(rest)) return withoutArgs;
+	if (/^\s*\(/.test(rest)) return {
+		code: RSErrorCode.globalFuncParenCall,
+		from: funcNode.from,
+		to: funcNode.to,
+		params: [name]
+	};
+	const openBracket = /^\s*\[/.exec(rest);
+	if (openBracket === null) return null;
+	const closeIdx = findMatchingCloseBracket(rest, openBracket[0].length - 1);
+	if (closeIdx >= 0 && rest.slice(openBracket[0].length, closeIdx).trim().length === 0) return withoutArgs;
+	return null;
 }
-function incompleteFormalExpressionCode(expected) {
-	switch (expected) {
-		case TypeClass.function: return RSErrorCode.expectedExpressionBody;
-		case TypeClass.predicate:
-		case TypeClass.logic: return RSErrorCode.expectedLogicBody;
-		default: return RSErrorCode.expectedFunctionBody;
-	}
-}
-function detectIncompleteQuantifier(node, expression) {
-	const quantNode = findAncestor(node, isQuantifierNode);
-	if (quantNode === null) return null;
-	const bodyChild = quantNode.children[quantNode.children.length - 1];
-	if (bodyChild?.typeID !== TokenID.ERROR || node !== bodyChild) return null;
-	const headerChildren = quantNode.children.slice(0, -1);
-	if (headerChildren.length < 3) return null;
-	const varPack = headerChildren.find((child) => child.typeID === 31 || child.typeID === TokenID.NT_ENUM_DECL);
-	if (varPack === void 0 || subtreeHasError(varPack)) return null;
-	const domainChild = headerChildren[headerChildren.length - 1];
-	if (domainChild === varPack || subtreeHasError(domainChild)) return null;
-	if (expression.slice(quantNode.to).trim().length > 0) return null;
+//#endregion
+//#region src/rslang/parser/syntax-errors/error-builders.ts
+function errorAt(node, code, params) {
 	return {
-		code: RSErrorCode.expectedQuantifierBody,
-		from: bodyChild.from,
-		to: bodyChild.to
+		code,
+		from: node.from,
+		to: node.to,
+		params
 	};
 }
-function detectIncompleteGenerator(node, expression) {
-	return detectIncompleteDeclarative(node, expression) ?? detectIncompleteImperative(node, expression) ?? detectIncompleteRecursion(node, expression);
+function hasOnlyClosingSuffix(expression, from) {
+	const suffix = expression.slice(from).trim();
+	return suffix.length === 0 || /^[\]\)\}]*$/.test(suffix);
+}
+function sliceText(node, expression) {
+	return expression.slice(node.from, node.to);
+}
+function isTextToken(node, expression, text) {
+	return sliceText(node, expression) === text;
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/generators.ts
+const classifyIncompleteGenerator = (node, expression) => detectIncompleteDeclarative(node, expression) ?? detectIncompleteImperative(node, expression) ?? detectIncompleteRecursion(node, expression);
+function isIncompleteGeneratorBodyCode(code) {
+	return code === RSErrorCode.expectedDeclarativeBody || code === RSErrorCode.expectedImperativeBody || code === RSErrorCode.expectedRecursiveBody;
 }
 function detectIncompleteDeclarative(node, expression) {
-	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 60 || target.typeID === TokenID.NT_DECLARATIVE_EXPR), RSErrorCode.expectedDeclarativeBody, (slot) => isIncompleteDeclarativeBody(slot));
+	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 60 || target.typeID === TokenID.NT_DECLARATIVE_EXPR), RSErrorCode.expectedDeclarativeBody, (slot) => isIncompleteDeclarativeBody(slot.nodes));
 }
 function detectIncompleteImperative(node, expression) {
 	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 64 || target.typeID === TokenID.NT_IMPERATIVE_EXPR), RSErrorCode.expectedImperativeBody, (slot) => isIncompleteImperativeBody(slot, expression));
 }
 function detectIncompleteRecursion(node, expression) {
-	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 68), RSErrorCode.expectedRecursiveBody, (slot) => isIncompleteRecursionBody(slot));
+	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 68), RSErrorCode.expectedRecursiveBody, (slot) => isIncompleteRecursionBody(slot.nodes));
 }
 function detectIncompleteGeneratorBody(node, expression, generatorNode, code, isIncomplete) {
-	if (generatorNode === null) return null;
-	if (expression.slice(generatorNode.to).trim().length > 0) return null;
+	if (generatorNode === null || expression.slice(generatorNode.to).trim().length > 0) return null;
 	const slot = getGeneratorBodySlot(generatorNode, expression);
-	if (slot === null || !isIncomplete(slot)) return null;
-	if (!generatorHeaderIsValid(generatorNode, expression, slot.headerEndIndex)) return null;
+	if (slot === null || !isIncomplete(slot) || !generatorHeaderIsValid(generatorNode, expression, slot.headerEndIndex)) return null;
 	if (!isErrorInBodySlot(node, slot, generatorNode)) return null;
-	return incompleteGeneratorError(code, node);
+	return errorAt(node, code);
 }
 function getGeneratorBodySlot(generatorNode, expression) {
 	if (generatorNode.typeID === 60 || generatorNode.typeID === TokenID.NT_DECLARATIVE_EXPR) return getDeclarativeBodySlot(generatorNode, expression);
@@ -140,7 +165,7 @@ function getGeneratorBodySlot(generatorNode, expression) {
 	return null;
 }
 function getDeclarativeBodySlot(declNode, expression) {
-	const pipeIndex = declNode.children.findIndex((child) => isPipeToken(child, expression));
+	const pipeIndex = declNode.children.findIndex((child) => isTextToken(child, expression, "|"));
 	if (pipeIndex >= 0) return {
 		nodes: contentChildren(declNode, expression, pipeIndex + 1),
 		headerEndIndex: pipeIndex + 1
@@ -154,7 +179,7 @@ function getDeclarativeBodySlot(declNode, expression) {
 	};
 }
 function getImperativeBodySlot(impNode, expression) {
-	const pipeIndex = impNode.children.findIndex((child) => isPipeToken(child, expression));
+	const pipeIndex = impNode.children.findIndex((child) => isTextToken(child, expression, "|"));
 	if (pipeIndex >= 0) return {
 		nodes: contentChildren(impNode, expression, pipeIndex + 1),
 		headerEndIndex: pipeIndex + 1
@@ -186,11 +211,11 @@ function contentChildren(generatorNode, expression, fromIndex) {
 	return generatorNode.children.slice(fromIndex).filter((child) => !isClosingBrace(child, expression));
 }
 function findDeclarativeDomain(declNode, expression) {
-	const inIndex = declNode.children.findIndex((child) => expression.slice(child.from, child.to) === "∈");
+	const inIndex = declNode.children.findIndex((child) => isTextToken(child, expression, "∈"));
 	if (inIndex < 0) return null;
 	for (let index = inIndex + 1; index < declNode.children.length; index++) {
 		const child = declNode.children[index];
-		if (isPipeToken(child, expression) || isClosingBrace(child, expression)) break;
+		if (isTextToken(child, expression, "|") || isClosingBrace(child, expression)) break;
 		if (child.typeID === 38) return child;
 	}
 	return null;
@@ -200,7 +225,7 @@ function findImperativeTuple(impNode) {
 	return null;
 }
 function findLastPipeIndex(nodes, expression) {
-	for (let index = nodes.length - 1; index >= 0; index--) if (isPipeToken(nodes[index], expression)) return index;
+	for (let index = nodes.length - 1; index >= 0; index--) if (isTextToken(nodes[index], expression, "|")) return index;
 	return -1;
 }
 function generatorHeaderIsValid(generatorNode, expression, headerEndIndex) {
@@ -212,16 +237,16 @@ function generatorHeaderIsValid(generatorNode, expression, headerEndIndex) {
 	}
 	return true;
 }
-function isIncompleteDeclarativeBody(slot) {
-	return isEmptyOrErrorOnlyBody(slot.nodes);
+function isIncompleteDeclarativeBody(nodes) {
+	return isEmptyOrErrorOnlyBody(nodes);
 }
 function isIncompleteImperativeBody(slot, expression) {
 	if (slot.nodes.length === 0) return true;
 	if (slot.nodes.length === 1 && slot.nodes[0].typeID === 65) return isImpBlocksIncomplete(slot.nodes[0], expression);
 	return isEmptyOrErrorOnlyBody(slot.nodes);
 }
-function isIncompleteRecursionBody(slot) {
-	return isEmptyOrErrorOnlyBody(slot.nodes);
+function isIncompleteRecursionBody(nodes) {
+	return isEmptyOrErrorOnlyBody(nodes);
 }
 function isEmptyOrErrorOnlyBody(nodes) {
 	if (nodes.length === 0) return true;
@@ -232,7 +257,7 @@ function isImpBlocksIncomplete(blocksNode, expression) {
 	if (blocksNode.children.length === 0) return true;
 	const lastChild = blocksNode.children[blocksNode.children.length - 1];
 	if (lastChild.typeID === TokenID.ERROR) return true;
-	if (isSemicolonToken(lastChild, expression)) return true;
+	if (isTextToken(lastChild, expression, ";")) return true;
 	if (lastChild.typeID === 38 && isErrorPlaceholder(lastChild)) return true;
 	return false;
 }
@@ -251,149 +276,208 @@ function isImpBlocksTailError(blocksNode, errorNode) {
 	const lastChild = blocksNode.children[blocksNode.children.length - 1];
 	return lastChild.typeID === TokenID.ERROR && (errorNode === lastChild || isDescendantOf(lastChild, errorNode));
 }
-function isErrorPlaceholder(node) {
-	if (node.typeID === TokenID.ERROR) return true;
-	if (node.children.length === 0) return false;
-	return node.children.every((child) => isErrorPlaceholder(child));
-}
-function isDescendantOf(ancestor, node) {
-	let current = node.parent;
-	while (current !== null) {
-		if (current === ancestor) return true;
-		current = current.parent;
-	}
-	return false;
-}
 function findRecursionInit(recursionNode, expression) {
-	const assignIndex = recursionNode.children.findIndex((child) => expression.slice(child.from, child.to) === ":=");
+	const assignIndex = recursionNode.children.findIndex((child) => isTextToken(child, expression, ":="));
 	if (assignIndex < 0) return null;
 	for (let index = assignIndex + 1; index < recursionNode.children.length; index++) {
 		const child = recursionNode.children[index];
 		if (child.typeID === TokenID.ERROR) break;
-		if (isPipeToken(child, expression) || isClosingBrace(child, expression)) continue;
+		if (isTextToken(child, expression, "|") || isClosingBrace(child, expression)) continue;
 		return child;
 	}
 	return null;
 }
-function incompleteGeneratorError(code, errorNode) {
-	return {
-		code,
-		from: errorNode.from,
-		to: errorNode.to
-	};
-}
-function isIncompleteGeneratorBodyCode(code) {
-	return code === RSErrorCode.expectedDeclarativeBody || code === RSErrorCode.expectedImperativeBody || code === RSErrorCode.expectedRecursiveBody;
-}
-function isPipeToken(node, expression) {
-	return expression.slice(node.from, node.to) === "|";
-}
-function isSemicolonToken(node, expression) {
-	return expression.slice(node.from, node.to) === ";";
-}
 function isClosingBrace(node, expression) {
-	return node.typeID !== TokenID.ERROR && expression.slice(node.from, node.to) === "}";
+	return node.typeID !== TokenID.ERROR && isTextToken(node, expression, "}");
 }
 function isStructuralGeneratorToken(node, expression) {
 	const text = expression.slice(node.from, node.to);
 	return text === "{" || text === "}" || text === "|" || text === "∈" || text === ":=" || text === ";";
 }
-function subtreeHasError(node) {
-	if (node.typeID === TokenID.ERROR) return true;
-	return node.children.some(subtreeHasError);
-}
-function detectFilterParenMismatch(node, expression) {
-	const filterNode = findAncestor(node, isFilterNode) ?? findRelatedNode(node, isFilterNode);
-	if (filterNode === null) return null;
-	if (expression[filterNode.to] === "(") return {
-		code: RSErrorCode.invalidFilterSyntax,
-		from: filterNode.from,
-		to: filterNode.to + 1
-	};
-	return null;
+//#endregion
+//#region src/rslang/parser/syntax-errors/trailing-slot.ts
+function detectTrailingErrorSlot(node, expression, container, options) {
+	if (container === null) return null;
+	const bodyChild = container.children[container.children.length - 1];
+	if (bodyChild?.typeID !== TokenID.ERROR || node !== bodyChild) return null;
+	if (expression.slice(container.to).trim().length > 0) return null;
+	if (options.headerValid !== void 0 && !options.headerValid(container)) return null;
+	const code = typeof options.code === "function" ? options.code(container, bodyChild) : options.code;
+	if (code === null) return null;
+	return errorAt(bodyChild, code);
 }
-function detectGlobalFuncWithoutArgs(node, expression) {
-	const funcNode = findAncestor(node, (n) => isFunctionNode(n) || isPredicateNode(n)) ?? findRelatedNode(node, (n) => isFunctionNode(n) || isPredicateNode(n));
-	if (funcNode === null) return null;
-	return classifyFuncWithoutArgs(funcNode, expression);
+//#endregion
+//#region src/rslang/parser/syntax-errors/incomplete-formal.ts
+const classifyIncompleteFormal = (node, expression, context) => detectIncompleteFunctionDecl(node, expression, context.expected) ?? detectIncompleteQuantifier(node, expression);
+function detectIncompleteFunctionDecl(node, expression, expected) {
+	return detectTrailingErrorSlot(node, expression, findAncestor(node, isFunctionDeclNode), {
+		headerValid: (container) => {
+			const argsNode = container.children.find((child) => child.typeID === 77 || child.typeID === TokenID.NT_ARGUMENTS);
+			return argsNode !== void 0 && !subtreeHasError(argsNode);
+		},
+		code: () => incompleteFormalExpressionCode(expected)
+	});
 }
-function findRelatedNode(node, predicate) {
-	let current = node.parent;
-	while (current !== null) {
-		for (const child of current.children) if (predicate(child)) return child;
-		current = current.parent;
+function incompleteFormalExpressionCode(expected) {
+	switch (expected) {
+		case TypeClass.function: return RSErrorCode.expectedExpressionBody;
+		case TypeClass.predicate:
+		case TypeClass.logic: return RSErrorCode.expectedLogicBody;
+		default: return RSErrorCode.expectedFunctionBody;
 	}
-	return null;
 }
-function classifyFuncWithoutArgs(funcNode, expression) {
-	const name = expression.slice(funcNode.from, funcNode.to);
-	const rest = expression.slice(funcNode.to);
-	const withoutArgs = {
-		code: RSErrorCode.globalFuncWithoutArgs,
-		from: funcNode.from,
-		to: funcNode.to,
-		params: [name]
-	};
-	if (/^\s*$/.test(rest)) return withoutArgs;
-	const openBracket = /^\s*\[/.exec(rest);
-	if (openBracket === null) return null;
-	const closeIdx = findMatchingCloseBracket(rest, openBracket[0].length - 1);
-	if (closeIdx >= 0) {
-		if (rest.slice(openBracket[0].length, closeIdx).trim().length === 0) return withoutArgs;
+function detectIncompleteQuantifier(node, expression) {
+	return detectTrailingErrorSlot(node, expression, findAncestor(node, isQuantifierNode), {
+		headerValid: (container) => {
+			const varPack = container.children.find((child) => child.typeID === 31 || child.typeID === TokenID.NT_ENUM_DECL);
+			return varPack !== void 0 && !subtreeHasError(varPack);
+		},
+		code: (container, bodyChild) => {
+			const inIndex = container.children.findIndex((child) => expression.slice(child.from, child.to) === "∈");
+			if (inIndex < 0) return RSErrorCode.expectedQuantifierDomain;
+			const domainChild = container.children[inIndex + 1];
+			if (domainChild === void 0 || domainChild === bodyChild || subtreeHasError(domainChild)) return RSErrorCode.expectedQuantifierDomain;
+			return RSErrorCode.expectedQuantifierBody;
+		}
+	});
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/incomplete-operands.ts
+const classifyIncompleteOperands = (node, expression) => detectIncompleteUnaryOperand(node, expression) ?? detectIncompleteBinaryOperand(node, expression) ?? detectIncompleteBooleanOperand(node, expression);
+const classifyIncompleteArgument = (node, expression) => detectIncompleteArgument(node, expression);
+function detectIncompleteUnaryOperand(node, expression) {
+	const unaryNode = findAncestor(node, (target) => target.typeID === 24);
+	if (unaryNode === null) return null;
+	const operandChild = unaryNode.children[unaryNode.children.length - 1];
+	if (operandChild?.typeID !== TokenID.ERROR || node !== operandChild) return null;
+	if (expression.slice(unaryNode.to).trim().length > 0) return null;
+	const operatorChild = unaryNode.children[0];
+	if (operatorChild === void 0 || operatorChild === operandChild) return null;
+	if (!isTextToken(operatorChild, expression, "¬")) return null;
+	return errorAt(operandChild, RSErrorCode.expectedUnaryOperand);
+}
+function detectIncompleteBinaryOperand(node, expression) {
+	const binaryNode = findAncestor(node, (target) => target.typeID === 33 || target.typeID === 3 || target.typeID === 44);
+	if (binaryNode === null) return null;
+	const operandChild = binaryNode.children[binaryNode.children.length - 1];
+	if (operandChild?.typeID !== TokenID.ERROR || node !== operandChild) return null;
+	if (expression.slice(binaryNode.to).trim().length > 0) return null;
+	if (binaryNode.children.length < 2) return null;
+	const leftChild = binaryNode.children[0];
+	if (leftChild.typeID === TokenID.ERROR || subtreeHasError(leftChild)) return null;
+	return errorAt(operandChild, RSErrorCode.expectedRightOperand);
+}
+function detectIncompleteBooleanOperand(node, expression) {
+	const booleanNode = findAncestor(node, (target) => target.typeID === 56);
+	if (booleanNode === null) return null;
+	const operandChild = findTrailingErrorOperand(booleanNode, expression);
+	if (operandChild === null || node !== operandChild) return null;
+	if (!hasOnlyClosingSuffix(expression, booleanNode.to)) return null;
+	return errorAt(operandChild, RSErrorCode.expectedRightOperand);
+}
+function detectIncompleteArgument(node, expression) {
+	const enumNode = findAncestor(node, (target) => target.typeID === 9);
+	if (enumNode === null || !isLegitimateArgumentEnum(enumNode, expression)) return null;
+	const errorChild = findEnumArgumentError(enumNode, expression);
+	if (errorChild === null || node !== errorChild || !hasOnlyClosingSuffix(expression, enumNode.to)) return null;
+	return errorAt(errorChild, RSErrorCode.expectedArgument);
+}
+function findTrailingErrorOperand(container, expression) {
+	for (let index = container.children.length - 1; index >= 0; index--) {
+		const child = container.children[index];
+		if (isOperandStructuralToken(child, expression)) continue;
+		return getErrorOperandNode(child);
 	}
 	return null;
 }
-function findAncestor(node, predicate) {
-	let current = node;
-	while (current !== null) {
-		if (predicate(current)) return current;
-		current = current.parent;
+function findEnumArgumentError(enumNode, expression) {
+	for (const child of enumNode.children) {
+		if (isTextToken(child, expression, ",")) continue;
+		const errorNode = getErrorOperandNode(child);
+		if (errorNode !== null) return errorNode;
 	}
 	return null;
 }
-function isFunctionDeclNode(node) {
-	return node.typeID === 76 || node.typeID === TokenID.NT_FUNC_DEFINITION;
-}
-function isQuantifierNode(node) {
-	return node.typeID === 29;
-}
-function isFunctionNode(node) {
-	return node.typeID === 69 || node.typeID === TokenID.ID_FUNCTION;
-}
-function isPredicateNode(node) {
-	return node.typeID === 26 || node.typeID === TokenID.ID_PREDICATE;
+function isOperandStructuralToken(node, expression) {
+	const text = sliceText(node, expression);
+	return text === "(" || text === ")" || text === "ℬ";
 }
-function isFilterNode(node) {
-	return node.typeID === 59 || node.typeID === TokenID.FILTER;
+function isLegitimateArgumentEnum(enumNode, expression) {
+	return findCallHostForBracketEnum(enumNode, expression) !== null;
 }
-function findMatchingCloseBracket(expression, openPos) {
-	if (expression[openPos] !== "[") return -1;
-	let depth = 0;
-	for (let index = openPos; index < expression.length; index++) {
-		const symbol = expression[index];
-		if (symbol === "[") depth++;
-		else if (symbol === "]") {
-			depth--;
-			if (depth === 0) return index;
+function findCallHostForBracketEnum(enumNode, expression) {
+	let current = enumNode.parent;
+	while (current !== null) {
+		for (const child of current.children) {
+			if (!isFunctionNode(child) && !isPredicateNode(child) && !isFilterNode(child)) continue;
+			if (isEnumInCallBrackets(enumNode, child, expression)) return child;
 		}
+		current = current.parent;
 	}
-	return -1;
+	return null;
 }
-function deduplicateErrors(errors) {
-	const result = [];
-	for (const error of errors) {
-		if (result.some((existing) => existing.code === error.code && existing.from === error.from && existing.to === error.to)) continue;
-		if (error.code !== RSErrorCode.unknownSyntax) {
-			for (let index = result.length - 1; index >= 0; index--) if (result[index].code === RSErrorCode.unknownSyntax && rangesOverlap(error, result[index])) result.splice(index, 1);
-		}
-		result.push(error);
+function isEnumInCallBrackets(enumNode, nameNode, expression) {
+	const rest = expression.slice(nameNode.to);
+	const match = /^\s*\[/.exec(rest);
+	if (match === null) return false;
+	const openPos = nameNode.to + match.index + match[0].indexOf("[");
+	const closePos = findMatchingCloseBracket(expression, openPos);
+	if (closePos < 0) return false;
+	return enumNode.from > openPos && enumNode.from < closePos;
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/classify.ts
+const PARSE_ERROR_CLASSIFIERS = [
+	classifyIncompleteFormal,
+	classifyIncompleteGenerator,
+	whenNoBracketErrors(classifyIncompleteOperands),
+	whenNoBracketErrors(classifyIncompleteArgument),
+	classifyFilterParenMismatch,
+	classifyGlobalFuncCall
+];
+/** Runs classifiers in priority order for one `ERROR` AST node. */
+function classifyParseError(node, expression, context) {
+	for (const classifier of PARSE_ERROR_CLASSIFIERS) {
+		const error = classifier(node, expression, context);
+		if (error !== null) return error;
 	}
-	const specific = result.filter((error) => error.code !== RSErrorCode.unknownSyntax);
-	return result.filter((error) => error.code !== RSErrorCode.unknownSyntax || !specific.some((item) => rangesOverlap(error, item)));
+	return null;
 }
-function rangesOverlap(a, b) {
-	return a.from < b.to && b.from < a.to;
+/** Default rules when no classifier matched: `expectedLocal` or `unknownSyntax`. */
+function classifyFallbackError(node, ignoreUnknownErrors) {
+	const parent = node.parent;
+	if (parent === null) return ignoreUnknownErrors ? null : {
+		error: {
+			code: RSErrorCode.unknownSyntax,
+			from: node.from,
+			to: node.to
+		},
+		target: node
+	};
+	if (parent.typeID === 4) return {
+		error: {
+			code: RSErrorCode.expectedLocal,
+			from: parent.from,
+			to: parent.to
+		},
+		target: parent
+	};
+	if (ignoreUnknownErrors) return null;
+	const target = node.from === node.to ? parent : node;
+	return {
+		error: {
+			code: RSErrorCode.unknownSyntax,
+			from: target.from,
+			to: target.to
+		},
+		target
+	};
 }
+//#endregion
+//#region src/rslang/parser/syntax-errors/expression-errors.ts
+/**
+* Expression-level diagnostics (no AST required) and error deduplication.
+*/
 const ALLOWED_EXPRESSION_CHARS = buildAllowedExpressionChars();
 function buildAllowedExpressionChars() {
 	const chars = /* @__PURE__ */ new Set();
@@ -474,6 +558,50 @@ function extractBracketErrors(expression) {
 	}
 	return null;
 }
+function deduplicateErrors(errors) {
+	const result = [];
+	for (const error of errors) {
+		if (result.some((existing) => existing.code === error.code && existing.from === error.from && existing.to === error.to)) continue;
+		if (error.code !== RSErrorCode.unknownSyntax) {
+			for (let index = result.length - 1; index >= 0; index--) if (result[index].code === RSErrorCode.unknownSyntax && rangesOverlap(error, result[index])) result.splice(index, 1);
+		}
+		result.push(error);
+	}
+	const specific = result.filter((error) => error.code !== RSErrorCode.unknownSyntax);
+	return collapseContiguousUnknownSyntax(result.filter((error) => error.code !== RSErrorCode.unknownSyntax || !specific.some((item) => rangesOverlap(error, item))));
+}
+function collapseContiguousUnknownSyntax(errors) {
+	const unknowns = errors.filter((error) => error.code === RSErrorCode.unknownSyntax);
+	if (unknowns.length <= 1) return errors;
+	const others = errors.filter((error) => error.code !== RSErrorCode.unknownSyntax);
+	const sorted = [...unknowns].sort((left, right) => left.from - right.from || left.to - right.to);
+	const merged = [];
+	let clusterFrom = sorted[0].from;
+	let clusterTo = sorted[0].to;
+	for (let index = 1; index < sorted.length; index++) {
+		const error = sorted[index];
+		if (error.from <= clusterTo) {
+			clusterTo = Math.max(clusterTo, error.to);
+			continue;
+		}
+		merged.push({
+			code: RSErrorCode.unknownSyntax,
+			from: clusterFrom,
+			to: clusterTo
+		});
+		clusterFrom = error.from;
+		clusterTo = error.to;
+	}
+	merged.push({
+		code: RSErrorCode.unknownSyntax,
+		from: clusterFrom,
+		to: clusterTo
+	});
+	return [...others, ...merged];
+}
+function rangesOverlap(a, b) {
+	return a.from < b.to && b.from < a.to;
+}
 function isOpenBracket(symbol) {
 	return symbol === "(" || symbol === "[" || symbol === "{";
 }
@@ -518,6 +646,66 @@ function findMatchingCloseParen(expression, openPos) {
 	return -1;
 }
 //#endregion
-export { extractSyntaxErrors };
+//#region src/rslang/parser/syntax-errors/index.ts
+/**
+* Syntax error extraction — public entry point.
+*
+* Expects the **hybrid** AST produced by `normalizeAST` (see `parser/README.md`).
+* See {@link ./README.md} for pipeline, classifier order, and how to add codes.
+*
+* @module rslang/parser/syntax-errors
+*/
+/**
+* Walks a parsed expression AST and reports syntax errors.
+*
+* @param ast - Root AST from `buildTree(parser.parse(expression))`
+* @param expression - Original source text (positions must match the AST)
+* @param reporter - Called once per deduplicated error
+* @param annotateErrors - When true, also calls `annotateError` on the triggering node
+* @param options - Optional typification hint for incomplete formal expressions
+*/
+function extractSyntaxErrors(ast, expression, reporter, annotateErrors = false, options) {
+	const forbiddenErrors = extractForbiddenCharacterErrors(expression);
+	if (forbiddenErrors.length > 0) {
+		for (const error of forbiddenErrors) {
+			reporter(error);
+			if (annotateErrors) annotateError(ast, error.code, error.params);
+		}
+		return;
+	}
+	const collected = [];
+	const annotationTargets = /* @__PURE__ */ new Map();
+	const collect = (error, target) => {
+		collected.push(error);
+		if (target !== void 0) annotationTargets.set(error, target);
+	};
+	const bracketError = extractBracketErrors(expression);
+	const hasBracketErrors = bracketError !== null;
+	visitAstDFS(ast, (node) => extractInternal(node, expression, collect, hasBracketErrors, options));
+	const hasIncompleteGenerator = collected.some((error) => isIncompleteGeneratorBodyCode(error.code));
+	if (bracketError !== null && !hasIncompleteGenerator) collect(bracketError, ast);
+	for (const error of deduplicateErrors(collected)) {
+		reporter(error);
+		if (annotateErrors) {
+			const target = annotationTargets.get(error);
+			if (target !== void 0) annotateError(target, error.code, error.params);
+		}
+	}
+}
+function extractInternal(node, expression, collect, hasBracketErrors, options) {
+	if (node.typeID !== TokenID.ERROR) return;
+	const classified = classifyParseError(node, expression, {
+		hasBracketErrors,
+		expected: options?.expected
+	});
+	if (classified !== null) {
+		collect(classified, node);
+		return;
+	}
+	const fallback = classifyFallbackError(node, hasBracketErrors);
+	if (fallback !== null) collect(fallback.error, fallback.target);
+}
+//#endregion
+export { extractSyntaxErrors as t };
 
-//# sourceMappingURL=syntax-errors.js.map
+//# sourceMappingURL=syntax-errors-B6c2vsan.js.map