@rsconcept/domain 1.6.1 → 1.7.1

package/src/rslang/parser/syntax-errors/incomplete-formal.ts

@@ -0,0 +1,76 @@
+/**
+ * Incomplete formal headers: `[α∈…]` declarations and quantifiers (`∀α∈…`).
+ */
+
+import type { AstNode } from '../../../parsing';
+import { RSErrorCode, type RSErrorDescription } from '../../error';
+import { TypeClass as TypeClassEnum } from '../../semantic/typification';
+import { Arguments, Variable_pack } from '../parser.terms';
+import { TokenID } from '../token';
+
+import { findAncestor, isFunctionDeclNode, isQuantifierNode, subtreeHasError } from './ast-utils';
+import type { ClassifyContext, ErrorClassifier } from './context';
+import { detectTrailingErrorSlot } from './trailing-slot';
+
+export const classifyIncompleteFormal: ErrorClassifier = (node, expression, context) =>
+  detectIncompleteFunctionDecl(node, expression, context.expected) ?? detectIncompleteQuantifier(node, expression);
+
+function detectIncompleteFunctionDecl(
+  node: AstNode,
+  expression: string,
+  expected?: ClassifyContext['expected']
+): RSErrorDescription | null {
+  return detectTrailingErrorSlot(node, expression, findAncestor(node, isFunctionDeclNode), {
+    headerValid: container => {
+      const argsNode = container.children.find(
+        child => child.typeID === Arguments || child.typeID === TokenID.NT_ARGUMENTS
+      );
+      return argsNode !== undefined && !subtreeHasError(argsNode);
+    },
+    code: () => incompleteFormalExpressionCode(expected)
+  });
+}
+
+function incompleteFormalExpressionCode(expected?: ClassifyContext['expected']): RSErrorCode {
+  switch (expected) {
+    case TypeClassEnum.function:
+      return RSErrorCode.expectedExpressionBody;
+    case TypeClassEnum.predicate:
+    case TypeClassEnum.logic:
+      return RSErrorCode.expectedLogicBody;
+    default:
+      return RSErrorCode.expectedFunctionBody;
+  }
+}
+
+function detectIncompleteQuantifier(node: AstNode, expression: string): RSErrorDescription | null {
+  return detectTrailingErrorSlot(node, expression, findAncestor(node, isQuantifierNode), {
+    headerValid: container => {
+      const varPack = container.children.find(
+        child => child.typeID === Variable_pack || child.typeID === TokenID.NT_ENUM_DECL
+      );
+      return varPack !== undefined && !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 === undefined || domainChild === bodyChild || subtreeHasError(domainChild)) {
+        return RSErrorCode.expectedQuantifierDomain;
+      }
+
+      return RSErrorCode.expectedQuantifierBody;
+    }
+  });
+}
+
+export function isIncompleteGeneratorBodyCode(code: RSErrorCode): boolean {
+  return (
+    code === RSErrorCode.expectedDeclarativeBody ||
+    code === RSErrorCode.expectedImperativeBody ||
+    code === RSErrorCode.expectedRecursiveBody
+  );
+}

package/src/rslang/parser/syntax-errors/incomplete-operands.ts

@@ -0,0 +1,184 @@
+/**
+ * Incomplete operators and bracket argument lists (`P1[S1, ]`).
+ *
+ * Tuple enums `(α,β,)` intentionally stay `unknownSyntax` — not `expectedArgument`.
+ */
+
+import type { AstNode } from '../../../parsing';
+import { RSErrorCode, type RSErrorDescription } from '../../error';
+import { Boolean, Expr_enum_min2, Logic_binary, Logic_predicates, Logic_unary, Setexpr_binary } from '../parser.terms';
+import { TokenID } from '../token';
+
+import {
+  findAncestor,
+  findMatchingCloseBracket,
+  getErrorOperandNode,
+  isFilterNode,
+  isFunctionNode,
+  isPredicateNode,
+  subtreeHasError
+} from './ast-utils';
+import type { ErrorClassifier } from './context';
+import { errorAt, hasOnlyClosingSuffix, isTextToken, sliceText } from './error-builders';
+
+export const classifyIncompleteOperands: ErrorClassifier = (node, expression) =>
+  detectIncompleteUnaryOperand(node, expression) ??
+  detectIncompleteBinaryOperand(node, expression) ??
+  detectIncompleteBooleanOperand(node, expression);
+
+export const classifyIncompleteArgument: ErrorClassifier = (node, expression) =>
+  detectIncompleteArgument(node, expression);
+
+function detectIncompleteUnaryOperand(node: AstNode, expression: string): RSErrorDescription | null {
+  const unaryNode = findAncestor(node, target => target.typeID === Logic_unary);
+  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 === undefined || operatorChild === operandChild) {
+    return null;
+  }
+
+  if (!isTextToken(operatorChild, expression, '¬')) {
+    return null;
+  }
+
+  return errorAt(operandChild, RSErrorCode.expectedUnaryOperand);
+}
+
+function detectIncompleteBinaryOperand(node: AstNode, expression: string): RSErrorDescription | null {
+  const binaryNode = findAncestor(
+    node,
+    target => target.typeID === Logic_binary || target.typeID === Logic_predicates || target.typeID === Setexpr_binary
+  );
+  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: AstNode, expression: string): RSErrorDescription | null {
+  const booleanNode = findAncestor(node, target => target.typeID === Boolean);
+  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: AstNode, expression: string): RSErrorDescription | null {
+  const enumNode = findAncestor(node, target => target.typeID === Expr_enum_min2);
+  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: AstNode, expression: string): AstNode | null {
+  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 findEnumArgumentError(enumNode: AstNode, expression: string): AstNode | null {
+  for (const child of enumNode.children) {
+    if (isTextToken(child, expression, ',')) {
+      continue;
+    }
+    const errorNode = getErrorOperandNode(child);
+    if (errorNode !== null) {
+      return errorNode;
+    }
+  }
+  return null;
+}
+
+function isOperandStructuralToken(node: AstNode, expression: string): boolean {
+  const text = sliceText(node, expression);
+  return text === '(' || text === ')' || text === 'ℬ';
+}
+
+function isLegitimateArgumentEnum(enumNode: AstNode, expression: string): boolean {
+  return findCallHostForBracketEnum(enumNode, expression) !== null;
+}
+
+function findCallHostForBracketEnum(enumNode: AstNode, expression: string): AstNode | null {
+  let current: AstNode | null = 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 null;
+}
+
+function isEnumInCallBrackets(enumNode: AstNode, nameNode: AstNode, expression: string): boolean {
+  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;
+}

package/src/rslang/parser/syntax-errors/index.ts

@@ -0,0 +1,102 @@
+/**
+ * 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
+ */
+
+import { type AstNode, visitAstDFS } from '../../../parsing';
+import { annotateError } from '../../ast-annotations';
+import { type ErrorReporter, type RSErrorDescription } from '../../error';
+import { type TypeClass } from '../../semantic/typification';
+import { TokenID } from '../token';
+
+import { classifyFallbackError, classifyParseError } from './classify';
+import { deduplicateErrors, extractBracketErrors, extractForbiddenCharacterErrors } from './expression-errors';
+import { isIncompleteGeneratorBodyCode } from './incomplete-formal';
+
+/** When set, refines incomplete formal headers (`[α∈…]`, quantifiers). */
+export interface SyntaxErrorOptions {
+  expected?: TypeClass;
+}
+
+/**
+ * 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
+ */
+export function extractSyntaxErrors(
+  ast: AstNode,
+  expression: string,
+  reporter: ErrorReporter,
+  annotateErrors: boolean = false,
+  options?: SyntaxErrorOptions
+) {
+  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: RSErrorDescription[] = [];
+  const annotationTargets = new Map<RSErrorDescription, AstNode>();
+  const collect = (error: RSErrorDescription, target?: AstNode) => {
+    collected.push(error);
+    if (target !== undefined) {
+      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 !== undefined) {
+        annotateError(target, error.code, error.params);
+      }
+    }
+  }
+}
+
+function extractInternal(
+  node: AstNode,
+  expression: string,
+  collect: (error: RSErrorDescription, target: AstNode) => void,
+  hasBracketErrors: boolean,
+  options?: SyntaxErrorOptions
+) {
+  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);
+  }
+}

package/src/rslang/parser/syntax-errors/trailing-slot.ts

@@ -0,0 +1,45 @@
+/**
+ * Reusable pattern: container header is valid, last child is `ERROR`, input ends here.
+ *
+ * @see incomplete-formal.ts — function declarations, quantifiers
+ */
+
+import type { AstNode } from '../../../parsing';
+import { type RSErrorCode, type RSErrorDescription } from '../../error';
+import { TokenID } from '../token';
+
+import { errorAt } from './error-builders';
+
+export function detectTrailingErrorSlot(
+  node: AstNode,
+  expression: string,
+  container: AstNode | null,
+  options: {
+    headerValid?: (container: AstNode) => boolean;
+    code: RSErrorCode | ((container: AstNode, bodyChild: AstNode) => RSErrorCode | null);
+  }
+): RSErrorDescription | null {
+  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 !== undefined && !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);
+}

package/dist/rslang/parser/syntax-errors.d.ts

@@ -1,14 +0,0 @@
-import { t as AstNode } from "../../ast-C8sIpKdL.js";
-import { g as TypeClass } from "../../typification-Dk-fisgO.js";
-import { t as ErrorReporter } from "../../error-CZXO5Y6a.js";
-
-//#region src/rslang/parser/syntax-errors.d.ts
-/** Options for syntax error extraction. */
-interface SyntaxErrorOptions {
-  expected?: TypeClass;
-}
-/** Extracts syntax errors from an AST. */
-declare function extractSyntaxErrors(ast: AstNode, expression: string, reporter: ErrorReporter, annotateErrors?: boolean, options?: SyntaxErrorOptions): void;
-//#endregion
-export { SyntaxErrorOptions, extractSyntaxErrors };
-//# sourceMappingURL=syntax-errors.d.ts.map