@rsconcept/domain 1.0.0 → 1.1.0

package/dist/rslang/parser/syntax-errors.js

@@ -1,403 +1,134 @@
-// src/parsing/ast.ts
-var TOKEN_ERROR = 0;
-function visitAstDFS(node, callback) {
-  for (const child of node.children) {
-    visitAstDFS(child, callback);
-  }
-  callback(node);
-}
-
-// src/rslang/ast-annotations.ts
-var AST_ERRORS_KEY = "rsErrors";
-function annotateError(node, code, params) {
-  if (typeof node.annotation === "object" && node.annotation !== null && AST_ERRORS_KEY in node.annotation && isAstNodeErrorRef(node.annotation[AST_ERRORS_KEY])) {
-    return;
-  }
-  const entry = params !== void 0 && params.length > 0 ? { code, params: [...params] } : { code };
-  node.annotation = {
-    ...typeof node.annotation === "object" && node.annotation !== null ? node.annotation : {},
-    [AST_ERRORS_KEY]: entry
-  };
-}
-function isAstNodeErrorRef(x) {
-  if (typeof x !== "object" || x === null || !("code" in x)) {
-    return false;
-  }
-  const code = x.code;
-  if (typeof code !== "number") {
-    return false;
-  }
-  if (!("params" in x)) {
-    return true;
-  }
-  const p = x.params;
-  if (p === void 0) {
-    return true;
-  }
-  return Array.isArray(p) && p.every((item) => typeof item === "string");
-}
-
-// src/rslang/error.ts
-var RSErrorCode = {
-  unknownSyntax: 33792,
-  // 33792
-  missingParenthesis: 33798,
-  // 33798
-  missingCurlyBrace: 33799,
-  // 33799
-  missingSquareBracket: 33800,
-  // 33800
-  bracketMismatch: 33801,
-  // 33801
-  doubleParenthesis: 33802,
-  // 33802
-  missingOpenBracket: 33803,
-  // 33803
-  expectedLocal: 33813,
-  // 33813
-  expectedType: 33814,
-  // 33814
-  localDoubleDeclare: 10241,
-  // 10241
-  localNotUsed: 10242,
-  // 10242
-  localUndeclared: 34817,
-  // 34817
-  localShadowing: 34818,
-  // 34818
-  typesNotEqual: 34819,
-  // 34819
-  globalNotTyped: 34820,
-  // 34820
-  invalidDecart: 34821,
-  // 34821
-  invalidBoolean: 34822,
-  // 34822
-  invalidTypeOperation: 34823,
-  // 34823
-  invalidCard: 34824,
-  // 34824
-  invalidDebool: 34825,
-  // 34825
-  globalFuncWithoutArgs: 34827,
-  // 34827
-  invalidReduce: 34832,
-  // 34832
-  invalidProjectionTuple: 34833,
-  // 34833
-  invalidProjectionSet: 34834,
-  // 34834
-  invalidEnumeration: 34835,
-  // 34835
-  invalidCortegeDeclare: 34836,
-  // 34836
-  localOutOfScope: 34837,
-  // 34837
-  invalidElementPredicate: 34838,
-  // 34838
-  invalidEmptySetUsage: 34839,
-  // 34839
-  invalidArgsArity: 34840,
-  // 34840
-  invalidArgumentType: 34841,
-  // 34841
-  globalStructure: 34844,
-  // 34844
-  radicalUsage: 34849,
-  // 34849
-  invalidFilterArgumentType: 34850,
-  // 34850
-  invalidFilterArity: 34851,
-  // 34851
-  arithmeticNotSupported: 34852,
-  // 34852
-  typesNotCompatible: 34853,
-  // 34853
-  orderingNotSupported: 34854,
-  // 34854
-  expectedLogic: 34855,
-  // 34855
-  expectedSetexpr: 34856,
-  // 34856
-  invalidArgumentCortegeDeclare: 34857,
-  // 34857
-  globalNoValue: 34880,
-  // 34880
-  invalidPropertyUsage: 34881,
-  // 34881
-  // Value evaluation (runtime)
-  calcUnknownError: 33024,
-  // 35328
-  setOverflow: 33025,
-  // 35329
-  booleanBaseLimit: 33026,
-  // 35330
-  calcGlobalMissing: 33027,
-  // 35331
-  iterationsLimit: 33028,
-  // 35332
-  calcInvalidDebool: 33029,
-  // 35333
-  iterateInfinity: 33030,
-  // 35334
-  calculationNotSupported: 33031,
-  // 35335
-  cstEmptyDerived: 34913,
-  // 34913
-  definitionNotAllowed: 34914
-  // 34914
-};
-
-// src/rslang/parser/parser.terms.ts
-var Variable = 4;
-
-// src/rslang/parser/token.ts
-var TokenID = {
-  // Global, local IDs and literals
-  ERROR: TOKEN_ERROR,
-  ID_LOCAL: 258,
-  ID_GLOBAL: 259,
-  ID_FUNCTION: 260,
-  ID_PREDICATE: 261,
-  ID_RADICAL: 262,
-  LIT_INTEGER: 263,
-  LIT_WHOLE_NUMBERS: 264,
-  LIT_EMPTYSET: 265,
-  // Arithmetic
-  PLUS: 266,
-  MINUS: 267,
-  MULTIPLY: 268,
-  // Integer predicate symbols
-  GREATER: 269,
-  LESSER: 270,
-  GREATER_OR_EQ: 271,
-  LESSER_OR_EQ: 272,
-  // Equality comparison
-  EQUAL: 273,
-  NOTEQUAL: 274,
-  // Logic predicate symbols
-  QUANTOR_UNIVERSAL: 275,
-  QUANTOR_EXISTS: 276,
-  LOGIC_NOT: 277,
-  LOGIC_EQUIVALENT: 278,
-  LOGIC_IMPLICATION: 279,
-  LOGIC_OR: 280,
-  LOGIC_AND: 281,
-  // Set theory predicate symbols
-  SET_IN: 282,
-  SET_NOT_IN: 283,
-  SUBSET: 284,
-  SUBSET_OR_EQ: 285,
-  NOT_SUBSET: 286,
-  // Set theory operators
-  DECART: 287,
-  SET_UNION: 288,
-  SET_INTERSECTION: 289,
-  SET_MINUS: 290,
-  SET_SYMMETRIC_MINUS: 291,
-  BOOLEAN: 292,
-  // Structure operations
-  BIGPR: 293,
-  SMALLPR: 294,
-  FILTER: 295,
-  CARD: 296,
-  BOOL: 297,
-  DEBOOL: 298,
-  REDUCE: 299,
-  // Term constructions prefixes
-  DECLARATIVE: 300,
-  RECURSIVE: 301,
-  IMPERATIVE: 302,
-  ITERATE: 303,
-  ASSIGN: 304,
-  // Punctuation
-  PUNCTUATION_DEFINE: 305,
-  PUNCTUATION_STRUCT: 306,
-  PUNCTUATION_PL: 307,
-  PUNCTUATION_PR: 308,
-  PUNCTUATION_CL: 309,
-  PUNCTUATION_CR: 310,
-  PUNCTUATION_SL: 311,
-  PUNCTUATION_SR: 312,
-  PUNCTUATION_BAR: 313,
-  PUNCTUATION_COMMA: 314,
-  PUNCTUATION_SEMICOLON: 315,
-  // ======= Non-terminal tokens =========
-  NT_ENUM_DECL: 316,
-  NT_TUPLE: 317,
-  NT_ENUMERATION: 318,
-  NT_TUPLE_DECL: 319,
-  NT_ARG_DECL: 320,
-  NT_FUNC_DEFINITION: 321,
-  NT_ARGUMENTS: 322,
-  NT_FUNC_CALL: 323,
-  NT_DECLARATIVE_EXPR: 324,
-  NT_IMPERATIVE_EXPR: 325,
-  NT_RECURSIVE_FULL: 326,
-  NT_RECURSIVE_SHORT: 327,
-  // ======= Helper tokens ========
-  INTERRUPT: 328,
-  END: 329
-};
-
-// src/rslang/parser/syntax-errors.ts
+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 "./parser.terms.js";
+//#region src/rslang/parser/syntax-errors.ts
+/**
+* Module: Syntactic errors reporting.
+*/
 function extractSyntaxErrors(ast, expression, reporter, annotateErrors = false) {
-  const bracketError = extractBracketErrors(expression);
-  if (bracketError !== null) {
-    reporter(bracketError);
-    if (annotateErrors) {
-      annotateError(ast, bracketError.code, bracketError.params);
-    }
-  }
-  const hasBracketErrors = bracketError !== null;
-  visitAstDFS(ast, (node) => extractInternal(node, reporter, annotateErrors, hasBracketErrors));
+	const bracketError = extractBracketErrors(expression);
+	if (bracketError !== null) {
+		reporter(bracketError);
+		if (annotateErrors) annotateError(ast, bracketError.code, bracketError.params);
+	}
+	const hasBracketErrors = bracketError !== null;
+	visitAstDFS(ast, (node) => extractInternal(node, reporter, annotateErrors, hasBracketErrors));
 }
 function extractInternal(node, reporter, annotateErrors, ignoreUnknownErrors) {
-  if (node.typeID !== TokenID.ERROR) {
-    return;
-  }
-  function emit(target, code) {
-    reporter({ code, from: target.from, to: target.to });
-    if (annotateErrors) {
-      annotateError(target, code);
-    }
-  }
-  const parent = node.parent;
-  if (parent === null) {
-    if (!ignoreUnknownErrors) {
-      return emit(node, RSErrorCode.unknownSyntax);
-    }
-    return;
-  }
-  if (parent.typeID === Variable) {
-    return emit(parent, RSErrorCode.expectedLocal);
-  }
-  if (!ignoreUnknownErrors) {
-    emit(node.from === node.to ? parent : node, RSErrorCode.unknownSyntax);
-  }
+	if (node.typeID !== TokenID.ERROR) return;
+	function emit(target, code) {
+		reporter({
+			code,
+			from: target.from,
+			to: target.to
+		});
+		if (annotateErrors) annotateError(target, code);
+	}
+	const parent = node.parent;
+	if (parent === null) {
+		if (!ignoreUnknownErrors) return emit(node, RSErrorCode.unknownSyntax);
+		return;
+	}
+	if (parent.typeID === 4) return emit(parent, RSErrorCode.expectedLocal);
+	if (!ignoreUnknownErrors) emit(node.from === node.to ? parent : node, RSErrorCode.unknownSyntax);
 }
 function extractBracketErrors(expression) {
-  const stack = [];
-  for (let pos = 0; pos < expression.length; pos++) {
-    const symbol = expression[pos];
-    if (isOpenBracket(symbol)) {
-      if (isDoubleParenthesis(expression, pos)) {
-        return {
-          code: RSErrorCode.doubleParenthesis,
-          from: pos,
-          to: pos + 2
-        };
-      }
-      stack.push({ bracket: symbol, index: pos });
-      continue;
-    }
-    if (!isCloseBracket(symbol)) {
-      continue;
-    }
-    const expectedOpen = closeToOpen(symbol);
-    const top = stack[stack.length - 1];
-    if (top === void 0) {
-      return {
-        code: RSErrorCode.missingOpenBracket,
-        from: pos,
-        to: pos + 1,
-        params: [expectedOpen]
-      };
-    }
-    if (top.bracket !== expectedOpen) {
-      return {
-        code: RSErrorCode.bracketMismatch,
-        from: pos,
-        to: pos + 1,
-        params: [openToClose(top.bracket), symbol]
-      };
-    }
-    stack.pop();
-  }
-  if (stack.length > 0) {
-    const unclosed = stack[0];
-    const code = missingBracketCode(unclosed.bracket);
-    return {
-      code,
-      from: expression.length,
-      to: expression.length
-    };
-  }
-  return null;
+	const stack = [];
+	for (let pos = 0; pos < expression.length; pos++) {
+		const symbol = expression[pos];
+		if (isOpenBracket(symbol)) {
+			if (isDoubleParenthesis(expression, pos)) return {
+				code: RSErrorCode.doubleParenthesis,
+				from: pos,
+				to: pos + 2
+			};
+			stack.push({
+				bracket: symbol,
+				index: pos
+			});
+			continue;
+		}
+		if (!isCloseBracket(symbol)) continue;
+		const expectedOpen = closeToOpen(symbol);
+		const top = stack[stack.length - 1];
+		if (top === void 0) return {
+			code: RSErrorCode.missingOpenBracket,
+			from: pos,
+			to: pos + 1,
+			params: [expectedOpen]
+		};
+		if (top.bracket !== expectedOpen) return {
+			code: RSErrorCode.bracketMismatch,
+			from: pos,
+			to: pos + 1,
+			params: [openToClose(top.bracket), symbol]
+		};
+		stack.pop();
+	}
+	if (stack.length > 0) {
+		const unclosed = stack[0];
+		return {
+			code: missingBracketCode(unclosed.bracket),
+			from: expression.length,
+			to: expression.length
+		};
+	}
+	return null;
 }
 function missingBracketCode(bracket) {
-  switch (bracket) {
-    case "(":
-      return RSErrorCode.missingParenthesis;
-    case "[":
-      return RSErrorCode.missingSquareBracket;
-    case "{":
-      return RSErrorCode.missingCurlyBrace;
-  }
+	switch (bracket) {
+		case "(": return RSErrorCode.missingParenthesis;
+		case "[": return RSErrorCode.missingSquareBracket;
+		case "{": return RSErrorCode.missingCurlyBrace;
+	}
 }
 function isOpenBracket(symbol) {
-  return symbol === "(" || symbol === "[" || symbol === "{";
+	return symbol === "(" || symbol === "[" || symbol === "{";
 }
 function isCloseBracket(symbol) {
-  return symbol === ")" || symbol === "]" || symbol === "}";
+	return symbol === ")" || symbol === "]" || symbol === "}";
 }
 function openToClose(symbol) {
-  switch (symbol) {
-    case "(":
-      return ")";
-    case "[":
-      return "]";
-    case "{":
-      return "}";
-  }
+	switch (symbol) {
+		case "(": return ")";
+		case "[": return "]";
+		case "{": return "}";
+	}
 }
 function closeToOpen(symbol) {
-  switch (symbol) {
-    case ")":
-      return "(";
-    case "]":
-      return "[";
-    case "}":
-      return "{";
-  }
+	switch (symbol) {
+		case ")": return "(";
+		case "]": return "[";
+		case "}": return "{";
+	}
 }
 function isDoubleParenthesis(expression, pos) {
-  const isOpenDoubleParenthesis = expression[pos] === "(" && expression[pos + 1] === "(";
-  if (!isOpenDoubleParenthesis) {
-    return false;
-  }
-  const outerClose = findMatchingCloseBracket(expression, pos);
-  const innerClose = findMatchingCloseBracket(expression, pos + 1);
-  if (outerClose < 0 || innerClose < 0) {
-    return false;
-  }
-  return outerClose === innerClose + 1;
+	if (!(expression[pos] === "(" && expression[pos + 1] === "(")) return false;
+	const outerClose = findMatchingCloseBracket(expression, pos);
+	const innerClose = findMatchingCloseBracket(expression, pos + 1);
+	if (outerClose < 0 || innerClose < 0) return false;
+	return outerClose === innerClose + 1;
 }
 function findMatchingCloseBracket(expression, openPos) {
-  if (expression[openPos] !== "(") {
-    return -1;
-  }
-  const stack = [];
-  for (let index = openPos; index < expression.length; index++) {
-    const symbol = expression[index];
-    if (isOpenBracket(symbol)) {
-      stack.push(symbol);
-      continue;
-    }
-    if (!isCloseBracket(symbol)) {
-      continue;
-    }
-    const top = stack.pop();
-    if (top === void 0 || top !== closeToOpen(symbol)) {
-      return -1;
-    }
-    if (stack.length === 0) {
-      return index;
-    }
-  }
-  return -1;
+	if (expression[openPos] !== "(") return -1;
+	const stack = [];
+	for (let index = openPos; index < expression.length; index++) {
+		const symbol = expression[index];
+		if (isOpenBracket(symbol)) {
+			stack.push(symbol);
+			continue;
+		}
+		if (!isCloseBracket(symbol)) continue;
+		const top = stack.pop();
+		if (top === void 0 || top !== closeToOpen(symbol)) return -1;
+		if (stack.length === 0) return index;
+	}
+	return -1;
 }
-export {
-  extractSyntaxErrors
-};
+//#endregion
+export { extractSyntaxErrors };
+
 //# sourceMappingURL=syntax-errors.js.map

package/dist/rslang/parser/syntax-errors.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/parsing/ast.ts","../../../src/rslang/ast-annotations.ts","../../../src/rslang/error.ts","../../../src/rslang/parser/parser.terms.ts","../../../src/rslang/parser/token.ts","../../../src/rslang/parser/syntax-errors.ts"],"sourcesContent":["import { type TreeCursor } from './lezer-tree';\n\nexport const TOKEN_ERROR = 0;\n\n/** Represents AST node data. */\ninterface AstNodeData extends Record<string, unknown> {\n  dataType: string;\n  value: unknown;\n}\n\n/** Represents AST structured node base. */\nexport interface AstNodeBase {\n  typeID: number;\n  data: AstNodeData;\n  annotation?: Record<string, unknown>;\n}\n\n/** Represents AST structured node. */\nexport interface AstNode extends Record<string, unknown>, AstNodeBase {\n  uid: number;\n  from: number;\n  to: number;\n  hasError: boolean;\n  parenthesis?: boolean;\n  parent: AstNode | null;\n  children: AstNode[];\n}\n\n/** Represents AST node. */\nexport interface FlatAstNode extends Record<string, unknown>, AstNodeBase {\n  uid: number;\n  parent: number | null;\n  from: number;\n  to: number;\n}\n\n/** Represents Syntax tree flat representation. */\nexport type FlatAST = FlatAstNode[];\n\n/** Builds AST tree from a given tree cursor, generating unique uids for each node. */\nexport function buildTree(cursor: TreeCursor): AstNode {\n  let nextUid = 1;\n  function genUid() {\n    return nextUid++;\n  }\n  return buildTreeInternal(cursor, null, genUid);\n}\n\n/** Flattens AST tree to a array form. */\nexport function flattenAst(node: AstNode, parent: number | null = null, out: FlatAST = []): FlatAST {\n  out.push({\n    uid: node.uid,\n    parent: parent,\n    typeID: node.typeID,\n    from: node.from,\n    to: node.to,\n    data: node.data,\n    annotation: node.annotation\n  });\n  for (const child of node.children) {\n    flattenAst(child, node.uid, out);\n  }\n  return out;\n}\n\n/** Visits AST tree in depth-first order. */\nexport function visitAstDFS(node: AstNode, callback: (node: AstNode) => void) {\n  for (const child of node.children) {\n    visitAstDFS(child, callback);\n  }\n  callback(node);\n}\n\n/** Finds and returns the AstNode with the given ui. */\nexport function findByUid(root: AstNode, uid: number): AstNode | null {\n  let found: AstNode | null = null;\n  visitAstDFS(root, node => {\n    if (node.uid === uid && !found) {\n      found = node;\n    }\n  });\n  return found;\n}\n\n/** Prints AST tree. */\nexport function printAst(node: AstNode, printNode: (node: AstNode) => string): string {\n  let children: string = '';\n  for (const child of node.children) {\n    children += `${printAst(child, printNode)}`;\n  }\n  return `[${printNode(node)}${children}]`;\n}\n\n/** Extracts node text. */\nexport function getNodeText(node: AstNode): string {\n  if (node.data.dataType === 'string' && typeof node.data.value === 'string') {\n    return node.data.value;\n  }\n  return `NO DATA NODE: ${node.typeID}`;\n}\n\n/** Extracts node indices. */\nexport function getNodeIndices(node: AstNode): number[] {\n  if (node.data.dataType === 'string[]' && Array.isArray(node.data.value)) {\n    return (node.data.value as string[]).map(s => parseInt(s, 10)).filter(n => !isNaN(n));\n  }\n  return [];\n}\n\n// ======== Internals ========\nfunction buildTreeInternal(cursor: TreeCursor, parent: AstNode | null = null, genUid: () => number): AstNode {\n  const node = cursor.node;\n\n  const result: AstNode = {\n    uid: genUid(),\n    typeID: node.type.isError ? 0 : node.type.id,\n    from: node.from,\n    to: node.to,\n    hasError: node.type.isError,\n    data: node.type.isError ? { dataType: 'null', value: null } : { dataType: 'string', value: node.type.name },\n    parent,\n    children: []\n  };\n\n  if (cursor.firstChild()) {\n    do {\n      const child = buildTreeInternal(cursor, result, genUid);\n      if (child.hasError) {\n        result.hasError = true;\n      }\n      result.children.push(child);\n    } while (cursor.nextSibling());\n    cursor.parent();\n  }\n  return result;\n}\n","/** Module: AST annotations. */\n\nimport { type AstNode } from '../parsing';\n\nimport { type ExpressionType } from './semantic/typification';\nimport { type RSErrorCode, type RSErrorInfo } from './error';\n\nconst AST_ERRORS_KEY = 'rsErrors' as const;\nconst AST_TYPE_KEY = 'rsType' as const;\n\n/** Appends {@link ExpressionType} onto the node's `annotation.rsType`. */\nexport function annotateType(node: AstNode, type: ExpressionType): void {\n  node.annotation = {\n    ...(typeof node.annotation === 'object' && node.annotation !== null ? node.annotation : {}),\n    [AST_TYPE_KEY]: type\n  };\n}\n\n/** Reads {@link ExpressionType} from node's `annotation`. */\nexport function readTypeAnnotation(node: AstNode): ExpressionType | null {\n  if (node.annotation && AST_TYPE_KEY in node.annotation) {\n    return node.annotation[AST_TYPE_KEY] as ExpressionType;\n  }\n  return null;\n}\n\n/** Appends {@link RSErrorInfo} onto the node's `annotation.rsErrors` if not already set. */\nexport function annotateError(node: AstNode, code: RSErrorCode, params?: readonly string[]): void {\n  if (\n    typeof node.annotation === 'object' &&\n    node.annotation !== null &&\n    AST_ERRORS_KEY in node.annotation &&\n    isAstNodeErrorRef(node.annotation[AST_ERRORS_KEY])\n  ) {\n    return;\n  }\n  const entry: RSErrorInfo = params !== undefined && params.length > 0 ? { code, params: [...params] } : { code };\n  node.annotation = {\n    ...(typeof node.annotation === 'object' && node.annotation !== null ? node.annotation : {}),\n    [AST_ERRORS_KEY]: entry\n  };\n}\n\n/** Reads validated {@link RSErrorInfo} entry from node's `annotation`. */\nexport function readErrorAnnotation(node: AstNode): RSErrorInfo | null {\n  const raw = node.annotation?.[AST_ERRORS_KEY];\n  if (isAstNodeErrorRef(raw)) {\n    return raw;\n  }\n  return null;\n}\n\n// ====== Internal ======\nfunction isAstNodeErrorRef(x: unknown): x is RSErrorInfo {\n  if (typeof x !== 'object' || x === null || !('code' in x)) {\n    return false;\n  }\n  const code = x.code;\n  if (typeof code !== 'number') {\n    return false;\n  }\n  if (!('params' in x)) {\n    return true;\n  }\n  const p = (x as { params: unknown }).params;\n  if (p === undefined) {\n    return true;\n  }\n  return Array.isArray(p) && p.every(item => typeof item === 'string');\n}\n","/** Module: Error types and functions. */\n\n/** Represents error class. */\nexport const RSErrorClass = {\n  LEXER: 0,\n  PARSER: 1,\n  SEMANTIC: 2,\n  EVALUATION: 3,\n  UNKNOWN: 4\n} as const;\nexport type RSErrorClass = (typeof RSErrorClass)[keyof typeof RSErrorClass];\n\n/** Represents RSLang expression error information. */\nexport interface RSErrorInfo {\n  code: RSErrorCode;\n  params?: readonly string[];\n}\n\n/** Represents RSLang expression error description. */\nexport interface RSErrorDescription extends RSErrorInfo {\n  from: number;\n  to: number;\n}\n\n/** Error reporter function type. */\nexport type ErrorReporter = (error: RSErrorDescription) => void;\n\n/** Represents RSLang expression error types. */\nexport const RSErrorCode = {\n  unknownSyntax: 0x8400, // 33792\n  missingParenthesis: 0x8406, // 33798\n  missingCurlyBrace: 0x8407, // 33799\n  missingSquareBracket: 0x8408, // 33800\n  bracketMismatch: 0x8409, // 33801\n  doubleParenthesis: 0x840a, // 33802\n  missingOpenBracket: 0x840b, // 33803\n  expectedLocal: 0x8415, // 33813\n  expectedType: 0x8416, // 33814\n\n  localDoubleDeclare: 0x2801, // 10241\n  localNotUsed: 0x2802, // 10242\n\n  localUndeclared: 0x8801, // 34817\n  localShadowing: 0x8802, // 34818\n\n  typesNotEqual: 0x8803, // 34819\n  globalNotTyped: 0x8804, // 34820\n  invalidDecart: 0x8805, // 34821\n  invalidBoolean: 0x8806, // 34822\n  invalidTypeOperation: 0x8807, // 34823\n  invalidCard: 0x8808, // 34824\n  invalidDebool: 0x8809, // 34825\n  globalFuncWithoutArgs: 0x880b, // 34827\n  invalidReduce: 0x8810, // 34832\n  invalidProjectionTuple: 0x8811, // 34833\n  invalidProjectionSet: 0x8812, // 34834\n  invalidEnumeration: 0x8813, // 34835\n  invalidCortegeDeclare: 0x8814, // 34836\n  localOutOfScope: 0x8815, // 34837\n  invalidElementPredicate: 0x8816, // 34838\n  invalidEmptySetUsage: 0x8817, // 34839\n  invalidArgsArity: 0x8818, // 34840\n  invalidArgumentType: 0x8819, // 34841\n  globalStructure: 0x881c, // 34844\n  radicalUsage: 0x8821, // 34849\n  invalidFilterArgumentType: 0x8822, // 34850\n  invalidFilterArity: 0x8823, // 34851\n  arithmeticNotSupported: 0x8824, // 34852\n  typesNotCompatible: 0x8825, // 34853\n  orderingNotSupported: 0x8826, // 34854\n  expectedLogic: 0x8827, // 34855\n  expectedSetexpr: 0x8828, // 34856\n  invalidArgumentCortegeDeclare: 0x8829, // 34857\n\n  globalNoValue: 0x8840, // 34880\n  invalidPropertyUsage: 0x8841, // 34881\n\n  // Value evaluation (runtime)\n  calcUnknownError: 0x8100, // 35328\n  setOverflow: 0x8101, // 35329\n  booleanBaseLimit: 0x8102, // 35330\n  calcGlobalMissing: 0x8103, // 35331\n  iterationsLimit: 0x8104, // 35332\n  calcInvalidDebool: 0x8105, // 35333\n  iterateInfinity: 0x8106, // 35334\n  calculationNotSupported: 0x8107, // 35335\n\n  cstEmptyDerived: 0x8861, // 34913\n  definitionNotAllowed: 0x8862 // 34914\n} as const;\nexport type RSErrorCode = (typeof RSErrorCode)[keyof typeof RSErrorCode];\n\nconst ERROR_EVALUATION_MASK = 0x0100;\nconst ERROR_LEXER_MASK = 0x0200;\nconst ERROR_PARSER_MASK = 0x0400;\nconst ERROR_SEMANTIC_MASK = 0x0800;\n\n/** Infers error class from error type (code). */\nfunction inferErrorClass(error: RSErrorCode): RSErrorClass {\n  if ((error & ERROR_EVALUATION_MASK) !== 0) {\n    return RSErrorClass.EVALUATION;\n  } else if ((error & ERROR_LEXER_MASK) !== 0) {\n    return RSErrorClass.LEXER;\n  } else if ((error & ERROR_PARSER_MASK) !== 0) {\n    return RSErrorClass.PARSER;\n  } else if ((error & ERROR_SEMANTIC_MASK) !== 0) {\n    return RSErrorClass.SEMANTIC;\n  } else {\n    return RSErrorClass.UNKNOWN;\n  }\n}\n\n/** Generate ErrorID label. */\nexport function getRSErrorPrefix(code: RSErrorCode): string {\n  const id = code.toString(16).toUpperCase();\n  // prettier-ignore\n  switch (inferErrorClass(code)) {\n    case RSErrorClass.LEXER: return 'L' + id;\n    case RSErrorClass.PARSER: return 'P' + id;\n    case RSErrorClass.SEMANTIC: return 'S' + id;\n    case RSErrorClass.EVALUATION: return 'E' + id;\n    case RSErrorClass.UNKNOWN: return 'U' + id;\n  }\n}\n\n/** Checks if error is critical. */\nexport function isCritical(code: RSErrorCode): boolean {\n  return code !== RSErrorCode.localDoubleDeclare && code !== RSErrorCode.localNotUsed;\n}\n","// This file was generated by lezer-generator. You probably shouldn't edit it.\nexport const\n  Expression = 1,\n  Logic = 2,\n  Logic_predicates = 3,\n  Variable = 4,\n  Local = 5,\n  Tuple = 8,\n  Expr_enum_min2 = 9,\n  Logic_unary = 24,\n  Predicate = 26,\n  Logic_quantor = 29,\n  Variable_pack = 31,\n  Logic_binary = 33,\n  Setexpr = 38,\n  Integer = 39,\n  EmptySet = 40,\n  IntegerSet = 41,\n  Global = 42,\n  Radical = 43,\n  Setexpr_binary = 44,\n  Enumeration = 55,\n  Boolean = 56,\n  Filter_expression = 58,\n  Filter = 59,\n  Declarative = 60,\n  PrefixD = 62,\n  PrefixI = 63,\n  Imperative = 64,\n  Imp_blocks = 65,\n  PrefixR = 67,\n  Recursion = 68,\n  Function = 69,\n  BigPr = 70,\n  SmallPr = 71,\n  Card = 72,\n  Bool = 73,\n  Debool = 74,\n  Red = 75,\n  Function_decl = 76,\n  Arguments = 77,\n  Declaration = 78\n","import { TOKEN_ERROR } from '../../parsing';\n\n/** Represents RSLang token types. */\nexport const TokenID = {\n  // Global, local IDs and literals\n  ERROR: TOKEN_ERROR,\n\n  ID_LOCAL: 258,\n  ID_GLOBAL: 259,\n  ID_FUNCTION: 260,\n  ID_PREDICATE: 261,\n  ID_RADICAL: 262,\n  LIT_INTEGER: 263,\n  LIT_WHOLE_NUMBERS: 264,\n  LIT_EMPTYSET: 265,\n\n  // Arithmetic\n  PLUS: 266,\n  MINUS: 267,\n  MULTIPLY: 268,\n\n  // Integer predicate symbols\n  GREATER: 269,\n  LESSER: 270,\n  GREATER_OR_EQ: 271,\n  LESSER_OR_EQ: 272,\n\n  // Equality comparison\n  EQUAL: 273,\n  NOTEQUAL: 274,\n\n  // Logic predicate symbols\n  QUANTOR_UNIVERSAL: 275,\n  QUANTOR_EXISTS: 276,\n  LOGIC_NOT: 277,\n  LOGIC_EQUIVALENT: 278,\n  LOGIC_IMPLICATION: 279,\n  LOGIC_OR: 280,\n  LOGIC_AND: 281,\n\n  // Set theory predicate symbols\n  SET_IN: 282,\n  SET_NOT_IN: 283,\n  SUBSET: 284,\n  SUBSET_OR_EQ: 285,\n  NOT_SUBSET: 286,\n\n  // Set theory operators\n  DECART: 287,\n  SET_UNION: 288,\n  SET_INTERSECTION: 289,\n  SET_MINUS: 290,\n  SET_SYMMETRIC_MINUS: 291,\n  BOOLEAN: 292,\n\n  // Structure operations\n  BIGPR: 293,\n  SMALLPR: 294,\n  FILTER: 295,\n  CARD: 296,\n  BOOL: 297,\n  DEBOOL: 298,\n  REDUCE: 299,\n\n  // Term constructions prefixes\n  DECLARATIVE: 300,\n  RECURSIVE: 301,\n  IMPERATIVE: 302,\n\n  ITERATE: 303,\n  ASSIGN: 304,\n\n  // Punctuation\n  PUNCTUATION_DEFINE: 305,\n  PUNCTUATION_STRUCT: 306,\n  PUNCTUATION_PL: 307,\n  PUNCTUATION_PR: 308,\n  PUNCTUATION_CL: 309,\n  PUNCTUATION_CR: 310,\n  PUNCTUATION_SL: 311,\n  PUNCTUATION_SR: 312,\n  PUNCTUATION_BAR: 313,\n  PUNCTUATION_COMMA: 314,\n  PUNCTUATION_SEMICOLON: 315,\n\n  // ======= Non-terminal tokens =========\n  NT_ENUM_DECL: 316,\n  NT_TUPLE: 317,\n  NT_ENUMERATION: 318,\n  NT_TUPLE_DECL: 319,\n  NT_ARG_DECL: 320,\n\n  NT_FUNC_DEFINITION: 321,\n  NT_ARGUMENTS: 322,\n  NT_FUNC_CALL: 323,\n\n  NT_DECLARATIVE_EXPR: 324,\n  NT_IMPERATIVE_EXPR: 325,\n  NT_RECURSIVE_FULL: 326,\n  NT_RECURSIVE_SHORT: 327,\n\n  // ======= Helper tokens ========\n  INTERRUPT: 328,\n  END: 329\n} as const;\nexport type TokenID = (typeof TokenID)[keyof typeof TokenID];\n","/**\n * Module: Syntactic errors reporting.\n */\n\nimport { type AstNode, visitAstDFS } from '../../parsing';\nimport { annotateError } from '../ast-annotations';\nimport { type ErrorReporter, RSErrorCode, type RSErrorDescription } from '../error';\n\nimport { Variable } from './parser.terms';\nimport { TokenID } from './token';\n\nexport function extractSyntaxErrors(\n  ast: AstNode,\n  expression: string,\n  reporter: ErrorReporter,\n  annotateErrors: boolean = false\n) {\n  const bracketError = extractBracketErrors(expression);\n  if (bracketError !== null) {\n    reporter(bracketError);\n    if (annotateErrors) {\n      annotateError(ast, bracketError.code, bracketError.params);\n    }\n  }\n  const hasBracketErrors = bracketError !== null;\n  visitAstDFS(ast, node => extractInternal(node, reporter, annotateErrors, hasBracketErrors));\n}\n\n// ====== Internals =========\nfunction extractInternal(\n  node: AstNode,\n  reporter: ErrorReporter,\n  annotateErrors: boolean,\n  ignoreUnknownErrors: boolean\n) {\n  if (node.typeID !== TokenID.ERROR) {\n    return;\n  }\n\n  function emit(target: AstNode, code: RSErrorCode) {\n    reporter({ code: code, from: target.from, to: target.to });\n    if (annotateErrors) {\n      annotateError(target, code);\n    }\n  }\n\n  const parent = node.parent;\n  if (parent === null) {\n    if (!ignoreUnknownErrors) {\n      return emit(node, RSErrorCode.unknownSyntax);\n    }\n    return;\n  }\n\n  if (parent.typeID === Variable) {\n    return emit(parent, RSErrorCode.expectedLocal);\n  }\n\n  if (!ignoreUnknownErrors) {\n    emit(node.from === node.to ? parent : node, RSErrorCode.unknownSyntax);\n  }\n}\n\ntype OpenBracket = '(' | '[' | '{';\ntype CloseBracket = ')' | ']' | '}';\n\ninterface BracketFrame {\n  bracket: OpenBracket;\n  index: number;\n}\n\nfunction extractBracketErrors(expression: string): RSErrorDescription | null {\n  const stack: BracketFrame[] = [];\n\n  for (let pos = 0; pos < expression.length; pos++) {\n    const symbol = expression[pos];\n    if (isOpenBracket(symbol)) {\n      if (isDoubleParenthesis(expression, pos)) {\n        return {\n          code: RSErrorCode.doubleParenthesis,\n          from: pos,\n          to: pos + 2\n        };\n      }\n      stack.push({ bracket: symbol, index: pos });\n      continue;\n    }\n    if (!isCloseBracket(symbol)) {\n      continue;\n    }\n\n    const expectedOpen = closeToOpen(symbol);\n    const top = stack[stack.length - 1];\n    if (top === undefined) {\n      return {\n        code: RSErrorCode.missingOpenBracket,\n        from: pos,\n        to: pos + 1,\n        params: [expectedOpen]\n      };\n    }\n\n    if (top.bracket !== expectedOpen) {\n      return {\n        code: RSErrorCode.bracketMismatch,\n        from: pos,\n        to: pos + 1,\n        params: [openToClose(top.bracket), symbol]\n      };\n    }\n\n    stack.pop();\n  }\n\n  if (stack.length > 0) {\n    const unclosed = stack[0];\n    const code = missingBracketCode(unclosed.bracket);\n    return {\n      code,\n      from: expression.length,\n      to: expression.length\n    };\n  }\n\n  return null;\n}\n\nfunction missingBracketCode(bracket: OpenBracket): RSErrorCode {\n  switch (bracket) {\n    case '(':\n      return RSErrorCode.missingParenthesis;\n    case '[':\n      return RSErrorCode.missingSquareBracket;\n    case '{':\n      return RSErrorCode.missingCurlyBrace;\n  }\n}\n\nfunction isOpenBracket(symbol: string): symbol is OpenBracket {\n  return symbol === '(' || symbol === '[' || symbol === '{';\n}\n\nfunction isCloseBracket(symbol: string): symbol is CloseBracket {\n  return symbol === ')' || symbol === ']' || symbol === '}';\n}\n\nfunction openToClose(symbol: OpenBracket): CloseBracket {\n  switch (symbol) {\n    case '(':\n      return ')';\n    case '[':\n      return ']';\n    case '{':\n      return '}';\n  }\n}\n\nfunction closeToOpen(symbol: CloseBracket): OpenBracket {\n  switch (symbol) {\n    case ')':\n      return '(';\n    case ']':\n      return '[';\n    case '}':\n      return '{';\n  }\n}\n\nfunction isDoubleParenthesis(expression: string, pos: number): boolean {\n  const isOpenDoubleParenthesis = expression[pos] === '(' && expression[pos + 1] === '(';\n  if (!isOpenDoubleParenthesis) {\n    return false;\n  }\n\n  const outerClose = findMatchingCloseBracket(expression, pos);\n  const innerClose = findMatchingCloseBracket(expression, pos + 1);\n  if (outerClose < 0 || innerClose < 0) {\n    return false;\n  }\n\n  return outerClose === innerClose + 1;\n}\n\nfunction findMatchingCloseBracket(expression: string, openPos: number): number {\n  if (expression[openPos] !== '(') {\n    return -1;\n  }\n\n  const stack: OpenBracket[] = [];\n  for (let index = openPos; index < expression.length; index++) {\n    const symbol = expression[index];\n    if (isOpenBracket(symbol)) {\n      stack.push(symbol);\n      continue;\n    }\n    if (!isCloseBracket(symbol)) {\n      continue;\n    }\n    const top = stack.pop();\n    if (top === undefined || top !== closeToOpen(symbol)) {\n      return -1;\n    }\n    if (stack.length === 0) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"file":"syntax-errors.js","names":[],"sources":["../../../src/rslang/parser/syntax-errors.ts"],"sourcesContent":["/**\n * Module: Syntactic errors reporting.\n */\n\nimport { type AstNode, visitAstDFS } from '../../parsing';\nimport { annotateError } from '../ast-annotations';\nimport { type ErrorReporter, RSErrorCode, type RSErrorDescription } from '../error';\n\nimport { Variable } from './parser.terms';\nimport { TokenID } from './token';\n\nexport function extractSyntaxErrors(\n  ast: AstNode,\n  expression: string,\n  reporter: ErrorReporter,\n  annotateErrors: boolean = false\n) {\n  const bracketError = extractBracketErrors(expression);\n  if (bracketError !== null) {\n    reporter(bracketError);\n    if (annotateErrors) {\n      annotateError(ast, bracketError.code, bracketError.params);\n    }\n  }\n  const hasBracketErrors = bracketError !== null;\n  visitAstDFS(ast, node => extractInternal(node, reporter, annotateErrors, hasBracketErrors));\n}\n\n// ====== Internals =========\nfunction extractInternal(\n  node: AstNode,\n  reporter: ErrorReporter,\n  annotateErrors: boolean,\n  ignoreUnknownErrors: boolean\n) {\n  if (node.typeID !== TokenID.ERROR) {\n    return;\n  }\n\n  function emit(target: AstNode, code: RSErrorCode) {\n    reporter({ code: code, from: target.from, to: target.to });\n    if (annotateErrors) {\n      annotateError(target, code);\n    }\n  }\n\n  const parent = node.parent;\n  if (parent === null) {\n    if (!ignoreUnknownErrors) {\n      return emit(node, RSErrorCode.unknownSyntax);\n    }\n    return;\n  }\n\n  if (parent.typeID === Variable) {\n    return emit(parent, RSErrorCode.expectedLocal);\n  }\n\n  if (!ignoreUnknownErrors) {\n    emit(node.from === node.to ? parent : node, RSErrorCode.unknownSyntax);\n  }\n}\n\ntype OpenBracket = '(' | '[' | '{';\ntype CloseBracket = ')' | ']' | '}';\n\ninterface BracketFrame {\n  bracket: OpenBracket;\n  index: number;\n}\n\nfunction extractBracketErrors(expression: string): RSErrorDescription | null {\n  const stack: BracketFrame[] = [];\n\n  for (let pos = 0; pos < expression.length; pos++) {\n    const symbol = expression[pos];\n    if (isOpenBracket(symbol)) {\n      if (isDoubleParenthesis(expression, pos)) {\n        return {\n          code: RSErrorCode.doubleParenthesis,\n          from: pos,\n          to: pos + 2\n        };\n      }\n      stack.push({ bracket: symbol, index: pos });\n      continue;\n    }\n    if (!isCloseBracket(symbol)) {\n      continue;\n    }\n\n    const expectedOpen = closeToOpen(symbol);\n    const top = stack[stack.length - 1];\n    if (top === undefined) {\n      return {\n        code: RSErrorCode.missingOpenBracket,\n        from: pos,\n        to: pos + 1,\n        params: [expectedOpen]\n      };\n    }\n\n    if (top.bracket !== expectedOpen) {\n      return {\n        code: RSErrorCode.bracketMismatch,\n        from: pos,\n        to: pos + 1,\n        params: [openToClose(top.bracket), symbol]\n      };\n    }\n\n    stack.pop();\n  }\n\n  if (stack.length > 0) {\n    const unclosed = stack[0];\n    const code = missingBracketCode(unclosed.bracket);\n    return {\n      code,\n      from: expression.length,\n      to: expression.length\n    };\n  }\n\n  return null;\n}\n\nfunction missingBracketCode(bracket: OpenBracket): RSErrorCode {\n  switch (bracket) {\n    case '(':\n      return RSErrorCode.missingParenthesis;\n    case '[':\n      return RSErrorCode.missingSquareBracket;\n    case '{':\n      return RSErrorCode.missingCurlyBrace;\n  }\n}\n\nfunction isOpenBracket(symbol: string): symbol is OpenBracket {\n  return symbol === '(' || symbol === '[' || symbol === '{';\n}\n\nfunction isCloseBracket(symbol: string): symbol is CloseBracket {\n  return symbol === ')' || symbol === ']' || symbol === '}';\n}\n\nfunction openToClose(symbol: OpenBracket): CloseBracket {\n  switch (symbol) {\n    case '(':\n      return ')';\n    case '[':\n      return ']';\n    case '{':\n      return '}';\n  }\n}\n\nfunction closeToOpen(symbol: CloseBracket): OpenBracket {\n  switch (symbol) {\n    case ')':\n      return '(';\n    case ']':\n      return '[';\n    case '}':\n      return '{';\n  }\n}\n\nfunction isDoubleParenthesis(expression: string, pos: number): boolean {\n  const isOpenDoubleParenthesis = expression[pos] === '(' && expression[pos + 1] === '(';\n  if (!isOpenDoubleParenthesis) {\n    return false;\n  }\n\n  const outerClose = findMatchingCloseBracket(expression, pos);\n  const innerClose = findMatchingCloseBracket(expression, pos + 1);\n  if (outerClose < 0 || innerClose < 0) {\n    return false;\n  }\n\n  return outerClose === innerClose + 1;\n}\n\nfunction findMatchingCloseBracket(expression: string, openPos: number): number {\n  if (expression[openPos] !== '(') {\n    return -1;\n  }\n\n  const stack: OpenBracket[] = [];\n  for (let index = openPos; index < expression.length; index++) {\n    const symbol = expression[index];\n    if (isOpenBracket(symbol)) {\n      stack.push(symbol);\n      continue;\n    }\n    if (!isCloseBracket(symbol)) {\n      continue;\n    }\n    const top = stack.pop();\n    if (top === undefined || top !== closeToOpen(symbol)) {\n      return -1;\n    }\n    if (stack.length === 0) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n"],"mappings":"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"}

package/dist/rslang/parser/token.d.ts

@@ -1,79 +1,2 @@
-/** Represents RSLang token types. */
-declare const TokenID: {
-    readonly ERROR: 0;
-    readonly ID_LOCAL: 258;
-    readonly ID_GLOBAL: 259;
-    readonly ID_FUNCTION: 260;
-    readonly ID_PREDICATE: 261;
-    readonly ID_RADICAL: 262;
-    readonly LIT_INTEGER: 263;
-    readonly LIT_WHOLE_NUMBERS: 264;
-    readonly LIT_EMPTYSET: 265;
-    readonly PLUS: 266;
-    readonly MINUS: 267;
-    readonly MULTIPLY: 268;
-    readonly GREATER: 269;
-    readonly LESSER: 270;
-    readonly GREATER_OR_EQ: 271;
-    readonly LESSER_OR_EQ: 272;
-    readonly EQUAL: 273;
-    readonly NOTEQUAL: 274;
-    readonly QUANTOR_UNIVERSAL: 275;
-    readonly QUANTOR_EXISTS: 276;
-    readonly LOGIC_NOT: 277;
-    readonly LOGIC_EQUIVALENT: 278;
-    readonly LOGIC_IMPLICATION: 279;
-    readonly LOGIC_OR: 280;
-    readonly LOGIC_AND: 281;
-    readonly SET_IN: 282;
-    readonly SET_NOT_IN: 283;
-    readonly SUBSET: 284;
-    readonly SUBSET_OR_EQ: 285;
-    readonly NOT_SUBSET: 286;
-    readonly DECART: 287;
-    readonly SET_UNION: 288;
-    readonly SET_INTERSECTION: 289;
-    readonly SET_MINUS: 290;
-    readonly SET_SYMMETRIC_MINUS: 291;
-    readonly BOOLEAN: 292;
-    readonly BIGPR: 293;
-    readonly SMALLPR: 294;
-    readonly FILTER: 295;
-    readonly CARD: 296;
-    readonly BOOL: 297;
-    readonly DEBOOL: 298;
-    readonly REDUCE: 299;
-    readonly DECLARATIVE: 300;
-    readonly RECURSIVE: 301;
-    readonly IMPERATIVE: 302;
-    readonly ITERATE: 303;
-    readonly ASSIGN: 304;
-    readonly PUNCTUATION_DEFINE: 305;
-    readonly PUNCTUATION_STRUCT: 306;
-    readonly PUNCTUATION_PL: 307;
-    readonly PUNCTUATION_PR: 308;
-    readonly PUNCTUATION_CL: 309;
-    readonly PUNCTUATION_CR: 310;
-    readonly PUNCTUATION_SL: 311;
-    readonly PUNCTUATION_SR: 312;
-    readonly PUNCTUATION_BAR: 313;
-    readonly PUNCTUATION_COMMA: 314;
-    readonly PUNCTUATION_SEMICOLON: 315;
-    readonly NT_ENUM_DECL: 316;
-    readonly NT_TUPLE: 317;
-    readonly NT_ENUMERATION: 318;
-    readonly NT_TUPLE_DECL: 319;
-    readonly NT_ARG_DECL: 320;
-    readonly NT_FUNC_DEFINITION: 321;
-    readonly NT_ARGUMENTS: 322;
-    readonly NT_FUNC_CALL: 323;
-    readonly NT_DECLARATIVE_EXPR: 324;
-    readonly NT_IMPERATIVE_EXPR: 325;
-    readonly NT_RECURSIVE_FULL: 326;
-    readonly NT_RECURSIVE_SHORT: 327;
-    readonly INTERRUPT: 328;
-    readonly END: 329;
-};
-type TokenID = (typeof TokenID)[keyof typeof TokenID];
-
-export { TokenID };
+import { t as TokenID } from "../../token-DeXAmzwr.js";
+export { TokenID };