@rsconcept/domain 1.0.0

package/dist/rslang/semantic/arguments-extractor.js

@@ -0,0 +1,366 @@
+// src/parsing/ast.ts
+var TOKEN_ERROR = 0;
+function getNodeText(node) {
+  if (node.data.dataType === "string" && typeof node.data.value === "string") {
+    return node.data.value;
+  }
+  return `NO DATA NODE: ${node.typeID}`;
+}
+
+// src/rslang/ast-annotations.ts
+var AST_TYPE_KEY = "rsType";
+function readTypeAnnotation(node) {
+  if (node.annotation && AST_TYPE_KEY in node.annotation) {
+    return node.annotation[AST_TYPE_KEY];
+  }
+  return null;
+}
+
+// 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/semantic/arguments-extractor.ts
+var ArgumentsExtractor = class {
+  locals = new LocalContext();
+  result = [];
+  run(ast) {
+    if (ast.hasError) {
+      return [];
+    }
+    this.result = [];
+    this.locals.clear();
+    this.dispatchVisit(ast);
+    return this.result;
+  }
+  dispatchDeclare(node) {
+    return this.processDeclare(node);
+  }
+  processDeclare(node) {
+    switch (node.typeID) {
+      case TokenID.ID_LOCAL:
+        return this.declareLocal(node);
+      case TokenID.NT_TUPLE_DECL:
+        return this.declareTuple(node);
+      case TokenID.NT_ENUM_DECL:
+        return this.declareEnumeration(node);
+    }
+    return false;
+  }
+  declareLocal(node) {
+    this.locals.pushLocal(node);
+    return true;
+  }
+  declareTuple(node) {
+    for (let child = 0; child < node.children.length; child++) {
+      if (!this.visitChildDeclaration(node, child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  declareEnumeration(node) {
+    for (const child of node.children) {
+      if (!this.dispatchDeclare(child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  dispatchVisit(node) {
+    return this.processVisit(node);
+  }
+  processVisit(node) {
+    switch (node.typeID) {
+      case TokenID.ID_GLOBAL:
+      case TokenID.ID_FUNCTION:
+      case TokenID.ID_PREDICATE:
+      case TokenID.ID_RADICAL:
+      case TokenID.LIT_INTEGER:
+      case TokenID.LIT_WHOLE_NUMBERS:
+      case TokenID.LIT_EMPTYSET:
+        return true;
+      case TokenID.CARD:
+      case TokenID.FILTER:
+      case TokenID.PLUS:
+      case TokenID.MINUS:
+      case TokenID.MULTIPLY:
+      case TokenID.LOGIC_AND:
+      case TokenID.LOGIC_OR:
+      case TokenID.LOGIC_IMPLICATION:
+      case TokenID.LOGIC_EQUIVALENT:
+      case TokenID.EQUAL:
+      case TokenID.NOTEQUAL:
+      case TokenID.GREATER:
+      case TokenID.LESSER:
+      case TokenID.GREATER_OR_EQ:
+      case TokenID.LESSER_OR_EQ:
+      case TokenID.SET_IN:
+      case TokenID.SET_NOT_IN:
+      case TokenID.SUBSET:
+      case TokenID.SUBSET_OR_EQ:
+      case TokenID.NOT_SUBSET:
+      case TokenID.DECART:
+      case TokenID.BOOLEAN:
+      case TokenID.BIGPR:
+      case TokenID.SMALLPR:
+      case TokenID.REDUCE:
+      case TokenID.BOOL:
+      case TokenID.DEBOOL:
+      case TokenID.SET_UNION:
+      case TokenID.SET_INTERSECTION:
+      case TokenID.SET_MINUS:
+      case TokenID.SET_SYMMETRIC_MINUS:
+      case TokenID.LOGIC_NOT:
+      case TokenID.NT_TUPLE:
+      case TokenID.NT_ENUMERATION:
+      case TokenID.NT_ARGUMENTS:
+        return this.visitAllAndReturn(node);
+      case TokenID.ID_LOCAL:
+        return this.visitLocal(node);
+      case TokenID.NT_ARG_DECL:
+        return this.visitArgument(node);
+      case TokenID.QUANTOR_UNIVERSAL:
+      case TokenID.QUANTOR_EXISTS:
+      case TokenID.NT_DECLARATIVE_EXPR:
+        return this.visitQuantifier(node);
+      case TokenID.NT_FUNC_DEFINITION:
+        return this.visitFunctionDefinition(node);
+      case TokenID.NT_FUNC_CALL:
+        return this.visitFunctionCall(node);
+      case TokenID.ITERATE:
+      case TokenID.ASSIGN:
+        return this.visitIterate(node);
+      case TokenID.NT_IMPERATIVE_EXPR:
+        return this.visitImperative(node);
+      case TokenID.NT_RECURSIVE_FULL:
+      case TokenID.NT_RECURSIVE_SHORT:
+        return this.visitRecursion(node);
+    }
+    return false;
+  }
+  visitChild(node, index) {
+    return index < node.children.length && this.dispatchVisit(node.children[index]);
+  }
+  visitChildDeclaration(node, index) {
+    return index < node.children.length && this.dispatchDeclare(node.children[index]);
+  }
+  visitAllAndReturn(node) {
+    for (const child of node.children) {
+      if (!this.dispatchVisit(child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  visitLocal(node) {
+    const alias = getNodeText(node);
+    if (!this.locals.checkLocal(node) && this.result.find((arg) => arg.alias === alias) === void 0) {
+      this.result.push({ alias, type: readTypeAnnotation(node) });
+    }
+    return true;
+  }
+  visitFunctionDefinition(node) {
+    this.locals.startScope();
+    if (!this.visitChild(node, 0)) {
+      return false;
+    }
+    if (!this.visitChild(node, 1)) {
+      return false;
+    }
+    this.locals.endScope();
+    return true;
+  }
+  visitFunctionCall(node) {
+    for (let child = 1; child < node.children.length; child++) {
+      if (!this.visitChild(node, child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  visitArgument(node) {
+    return this.visitChild(node, 1) && this.visitChildDeclaration(node, 0);
+  }
+  visitQuantifier(node) {
+    this.locals.startScope();
+    if (!this.visitChild(node, 1)) {
+      return false;
+    }
+    if (!this.visitChildDeclaration(node, 0)) {
+      return false;
+    }
+    if (!this.visitChild(node, 2)) {
+      return false;
+    }
+    this.locals.endScope();
+    return true;
+  }
+  visitImperative(node) {
+    this.locals.startScope();
+    for (let child = 1; child < node.children.length; child++) {
+      if (!this.visitChild(node, child)) {
+        return false;
+      }
+    }
+    if (!this.visitChild(node, 0)) {
+      return false;
+    }
+    this.locals.endScope();
+    return true;
+  }
+  visitIterate(node) {
+    return this.visitChild(node, 1) && this.visitChildDeclaration(node, 0);
+  }
+  visitRecursion(node) {
+    this.locals.startScope();
+    if (!this.visitChild(node, 1)) {
+      return false;
+    }
+    if (!this.visitChildDeclaration(node, 0)) {
+      return false;
+    }
+    const isFull = node.typeID === TokenID.NT_RECURSIVE_FULL;
+    const iterationIndex = isFull ? 3 : 2;
+    if (!this.visitChild(node, iterationIndex)) {
+      return false;
+    }
+    if (isFull) {
+      if (!this.visitChild(node, 2)) {
+        return false;
+      }
+    }
+    this.locals.endScope();
+    return true;
+  }
+};
+var LocalContext = class {
+  data = [];
+  clear() {
+    this.data = [];
+  }
+  startScope() {
+    for (const local of this.data) {
+      if (local.level > 0) {
+        local.level = local.level + 1;
+      }
+    }
+  }
+  endScope() {
+    for (const local of this.data) {
+      local.level--;
+    }
+  }
+  clearUnused() {
+    this.data = this.data.filter((data) => data.level > 0);
+  }
+  pushLocal(node) {
+    const alias = getNodeText(node);
+    const existing = this.data.find((data) => data.alias === alias);
+    if (existing) {
+      if (existing.level > 0) {
+        return;
+      } else {
+        const index = this.data.indexOf(existing);
+        if (index !== -1) {
+          this.data.splice(index, 1);
+        }
+      }
+    }
+    this.data.push({ alias, level: 1 });
+  }
+  checkLocal(node) {
+    const alias = getNodeText(node);
+    const local = this.data.find((data) => data.alias === alias);
+    return local !== void 0;
+  }
+};
+export {
+  ArgumentsExtractor
+};
+//# sourceMappingURL=arguments-extractor.js.map

package/dist/rslang/semantic/arguments-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/parsing/ast.ts","../../../src/rslang/ast-annotations.ts","../../../src/rslang/parser/token.ts","../../../src/rslang/semantic/arguments-extractor.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","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: Type auditor for AST type checking.\n */\n\nimport { type AstNode, getNodeText } from '../../parsing';\nimport { readTypeAnnotation } from '../ast-annotations';\nimport { TokenID } from '../parser/token';\n\nimport { type ExpressionType } from './typification';\n\n/** Represents function argument definition. */\nexport interface ArgumentsType {\n  alias: string;\n  type: ExpressionType | null;\n}\n\n/** Type auditor for AST type checking.\n * Warning! Assumes that the AST is well-formed and annotated with types.\n */\nexport class ArgumentsExtractor {\n  private locals: LocalContext = new LocalContext();\n  private result: ArgumentsType[] = [];\n\n  public run(ast: AstNode): ArgumentsType[] {\n    if (ast.hasError) {\n      return [];\n    }\n    this.result = [];\n    this.locals.clear();\n    this.dispatchVisit(ast);\n    return this.result;\n  }\n\n  private dispatchDeclare(node: AstNode): boolean {\n    return this.processDeclare(node);\n  }\n\n  private processDeclare(node: AstNode): boolean {\n    switch (node.typeID) {\n      case TokenID.ID_LOCAL:\n        return this.declareLocal(node);\n      case TokenID.NT_TUPLE_DECL:\n        return this.declareTuple(node);\n      case TokenID.NT_ENUM_DECL:\n        return this.declareEnumeration(node);\n    }\n    return false;\n  }\n\n  private declareLocal(node: AstNode): boolean {\n    this.locals.pushLocal(node);\n    return true;\n  }\n\n  private declareTuple(node: AstNode): boolean {\n    for (let child = 0; child < node.children.length; child++) {\n      if (!this.visitChildDeclaration(node, child)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private declareEnumeration(node: AstNode): boolean {\n    for (const child of node.children) {\n      if (!this.dispatchDeclare(child)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private dispatchVisit(node: AstNode): boolean {\n    return this.processVisit(node);\n  }\n\n  private processVisit(node: AstNode): boolean {\n    switch (node.typeID) {\n      case TokenID.ID_GLOBAL:\n      case TokenID.ID_FUNCTION:\n      case TokenID.ID_PREDICATE:\n      case TokenID.ID_RADICAL:\n      case TokenID.LIT_INTEGER:\n      case TokenID.LIT_WHOLE_NUMBERS:\n      case TokenID.LIT_EMPTYSET:\n        return true;\n\n      case TokenID.CARD:\n      case TokenID.FILTER:\n      case TokenID.PLUS:\n      case TokenID.MINUS:\n      case TokenID.MULTIPLY:\n      case TokenID.LOGIC_AND:\n      case TokenID.LOGIC_OR:\n      case TokenID.LOGIC_IMPLICATION:\n      case TokenID.LOGIC_EQUIVALENT:\n      case TokenID.EQUAL:\n      case TokenID.NOTEQUAL:\n      case TokenID.GREATER:\n      case TokenID.LESSER:\n      case TokenID.GREATER_OR_EQ:\n      case TokenID.LESSER_OR_EQ:\n      case TokenID.SET_IN:\n      case TokenID.SET_NOT_IN:\n      case TokenID.SUBSET:\n      case TokenID.SUBSET_OR_EQ:\n      case TokenID.NOT_SUBSET:\n      case TokenID.DECART:\n      case TokenID.BOOLEAN:\n      case TokenID.BIGPR:\n      case TokenID.SMALLPR:\n      case TokenID.REDUCE:\n      case TokenID.BOOL:\n      case TokenID.DEBOOL:\n      case TokenID.SET_UNION:\n      case TokenID.SET_INTERSECTION:\n      case TokenID.SET_MINUS:\n      case TokenID.SET_SYMMETRIC_MINUS:\n      case TokenID.LOGIC_NOT:\n      case TokenID.NT_TUPLE:\n      case TokenID.NT_ENUMERATION:\n      case TokenID.NT_ARGUMENTS:\n        return this.visitAllAndReturn(node);\n\n      case TokenID.ID_LOCAL:\n        return this.visitLocal(node);\n\n      case TokenID.NT_ARG_DECL:\n        return this.visitArgument(node);\n\n      case TokenID.QUANTOR_UNIVERSAL:\n      case TokenID.QUANTOR_EXISTS:\n      case TokenID.NT_DECLARATIVE_EXPR:\n        return this.visitQuantifier(node);\n\n      case TokenID.NT_FUNC_DEFINITION:\n        return this.visitFunctionDefinition(node);\n\n      case TokenID.NT_FUNC_CALL:\n        return this.visitFunctionCall(node);\n\n      case TokenID.ITERATE:\n      case TokenID.ASSIGN:\n        return this.visitIterate(node);\n\n      case TokenID.NT_IMPERATIVE_EXPR:\n        return this.visitImperative(node);\n\n      case TokenID.NT_RECURSIVE_FULL:\n      case TokenID.NT_RECURSIVE_SHORT:\n        return this.visitRecursion(node);\n    }\n    return false;\n  }\n\n  private visitChild(node: AstNode, index: number): boolean {\n    return index < node.children.length && this.dispatchVisit(node.children[index]);\n  }\n\n  private visitChildDeclaration(node: AstNode, index: number): boolean {\n    return index < node.children.length && this.dispatchDeclare(node.children[index]);\n  }\n\n  private visitAllAndReturn(node: AstNode): boolean {\n    for (const child of node.children) {\n      if (!this.dispatchVisit(child)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private visitLocal(node: AstNode): boolean {\n    const alias = getNodeText(node);\n    if (!this.locals.checkLocal(node) && this.result.find(arg => arg.alias === alias) === undefined) {\n      this.result.push({ alias, type: readTypeAnnotation(node) });\n    }\n    return true;\n  }\n\n  private visitFunctionDefinition(node: AstNode): boolean {\n    this.locals.startScope();\n    if (!this.visitChild(node, 0)) {\n      return false;\n    }\n    if (!this.visitChild(node, 1)) {\n      return false;\n    }\n    this.locals.endScope();\n    return true;\n  }\n\n  private visitFunctionCall(node: AstNode): boolean {\n    for (let child = 1; child < node.children.length; child++) {\n      if (!this.visitChild(node, child)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private visitArgument(node: AstNode): boolean {\n    return this.visitChild(node, 1) && this.visitChildDeclaration(node, 0);\n  }\n\n  private visitQuantifier(node: AstNode): boolean {\n    this.locals.startScope();\n\n    if (!this.visitChild(node, 1)) {\n      return false;\n    }\n    if (!this.visitChildDeclaration(node, 0)) {\n      return false;\n    }\n    if (!this.visitChild(node, 2)) {\n      return false;\n    }\n\n    this.locals.endScope();\n    return true;\n  }\n\n  private visitImperative(node: AstNode): boolean {\n    this.locals.startScope();\n\n    for (let child = 1; child < node.children.length; child++) {\n      if (!this.visitChild(node, child)) {\n        return false;\n      }\n    }\n\n    if (!this.visitChild(node, 0)) {\n      return false;\n    }\n\n    this.locals.endScope();\n    return true;\n  }\n\n  private visitIterate(node: AstNode): boolean {\n    return this.visitChild(node, 1) && this.visitChildDeclaration(node, 0);\n  }\n\n  private visitRecursion(node: AstNode): boolean {\n    this.locals.startScope();\n\n    if (!this.visitChild(node, 1)) {\n      return false;\n    }\n    if (!this.visitChildDeclaration(node, 0)) {\n      return false;\n    }\n\n    const isFull = node.typeID === TokenID.NT_RECURSIVE_FULL;\n    const iterationIndex = isFull ? 3 : 2;\n\n    if (!this.visitChild(node, iterationIndex)) {\n      return false;\n    }\n\n    if (isFull) {\n      if (!this.visitChild(node, 2)) {\n        return false;\n      }\n    }\n\n    this.locals.endScope();\n    return true;\n  }\n}\n\n// ========= Internals ========\n\n/** Local variable data. */\ninterface LocalData {\n  alias: string;\n  level: number;\n}\n\n/** Local variables context. */\nclass LocalContext {\n  public data: LocalData[] = [];\n\n  clear(): void {\n    this.data = [];\n  }\n\n  startScope(): void {\n    for (const local of this.data) {\n      if (local.level > 0) {\n        local.level = local.level + 1;\n      }\n    }\n  }\n\n  endScope(): void {\n    for (const local of this.data) {\n      local.level--;\n    }\n  }\n\n  clearUnused(): void {\n    this.data = this.data.filter(data => data.level > 0);\n  }\n\n  pushLocal(node: AstNode) {\n    const alias = getNodeText(node);\n    const existing = this.data.find(data => data.alias === alias);\n    if (existing) {\n      if (existing.level > 0) {\n        return;\n      } else {\n        const index = this.data.indexOf(existing);\n        if (index !== -1) {\n          this.data.splice(index, 1);\n        }\n      }\n    }\n    this.data.push({ alias, level: 1 });\n  }\n\n  checkLocal(node: AstNode): boolean {\n    const alias = getNodeText(node);\n    const local = this.data.find(data => data.alias === alias);\n    return local !== undefined;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/rslang/semantic/type-auditor.d.ts

@@ -0,0 +1,73 @@
+import { AstNode } from '../../parsing/ast.js';
+import { ErrorReporter } from '../error.js';
+import { TypeContext, ExpressionType } from './typification.js';
+import '@lezer/common';
+import '../../shared/branded.js';
+
+/**
+ * Module: Type auditor for AST type checking.
+ */
+
+/** Type auditor for AST type checking. */
+declare class TypeAuditor {
+    private static readonly TYPE_DEDUCTION_DEPTH;
+    private context;
+    private reporter?;
+    private locals;
+    private annotateTypes;
+    private annotateErrors;
+    constructor(context: TypeContext);
+    run(ast: AstNode, annotateTypes: boolean, reporter?: ErrorReporter, annotateErrors?: boolean): ExpressionType | null;
+    private clear;
+    private dispatchDeclare;
+    private processDeclare;
+    private declareLocal;
+    private declareTuple;
+    private declareEnumeration;
+    private dispatchVisit;
+    private processVisit;
+    private onError;
+    private visitChild;
+    private visitChildDeclaration;
+    private visitAllAndReturn;
+    private childTypification;
+    private childLogic;
+    private childTypeDebool;
+    private visitLocal;
+    private visitGlobal;
+    private visitFunctionDefinition;
+    private visitFunctionCall;
+    private visitRadical;
+    private visitEmptySet;
+    private visitArgument;
+    private visitCard;
+    private visitArithmetic;
+    private visitIntegerPredicate;
+    private visitQuantifier;
+    private visitNegation;
+    private visitLogicBinary;
+    private visitEquals;
+    private visitSetexprPredicate;
+    private visitDecart;
+    private visitBoolean;
+    private visitTuple;
+    private visitEnumeration;
+    private visitBool;
+    private visitDebool;
+    private visitSetexprBinary;
+    private visitProjectSet;
+    private visitProjectTuple;
+    private visitFilter;
+    private visitReduce;
+    private visitArgumentsEnum;
+    private visitDeclarative;
+    private visitImperative;
+    private visitIterate;
+    private visitAssign;
+    private visitRecursion;
+    private isSubset;
+    private isInsideFuncArgument;
+    private checkFuncArguments;
+}
+
+export { TypeAuditor };