@rsconcept/domain 1.0.0

package/src/rslang/parser/normalize.ts

@@ -0,0 +1,462 @@
+/**
+ * Module: Transforming AST to a simple form.
+ */
+
+import { type AstNode, visitAstDFS } from '../../parsing';
+
+import {
+  Arguments,
+  BigPr,
+  Bool,
+  Boolean,
+  Card,
+  Debool,
+  Declaration,
+  Declarative,
+  EmptySet,
+  Enumeration,
+  Expr_enum_min2,
+  Expression,
+  Filter,
+  Filter_expression,
+  Function,
+  Function_decl,
+  Global,
+  Imp_blocks,
+  Imperative,
+  Integer,
+  IntegerSet,
+  Local,
+  Logic,
+  Logic_binary,
+  Logic_predicates,
+  Logic_quantor,
+  Logic_unary,
+  Predicate,
+  PrefixD,
+  Radical,
+  Recursion,
+  Red,
+  Setexpr,
+  Setexpr_binary,
+  SmallPr,
+  Tuple,
+  Variable,
+  Variable_pack
+} from './parser.terms';
+import { TokenID } from './token';
+
+/** Normalizes AST to a simple form. */
+export function normalizeAST(ast: AstNode, input: string) {
+  visitAstDFS(ast, node => normalizeNode(node, input));
+}
+
+// ====== Internals =========
+const idRecord: Record<number, TokenID> = {
+  [Global]: TokenID.ID_GLOBAL,
+  [Local]: TokenID.ID_LOCAL,
+  [Radical]: TokenID.ID_RADICAL,
+  [Function]: TokenID.ID_FUNCTION,
+  [Predicate]: TokenID.ID_PREDICATE,
+  [Integer]: TokenID.LIT_INTEGER,
+  [EmptySet]: TokenID.LIT_EMPTYSET,
+  [IntegerSet]: TokenID.LIT_WHOLE_NUMBERS,
+
+  [Boolean]: TokenID.BOOLEAN,
+
+  [BigPr]: TokenID.BIGPR,
+  [SmallPr]: TokenID.SMALLPR,
+  [Filter]: TokenID.FILTER,
+
+  [Bool]: TokenID.BOOL,
+  [Debool]: TokenID.DEBOOL,
+  [Red]: TokenID.REDUCE,
+  [Card]: TokenID.CARD,
+
+  [Enumeration]: TokenID.NT_ENUMERATION,
+  [Tuple]: TokenID.NT_TUPLE,
+  [Arguments]: TokenID.NT_ARGUMENTS,
+  [Declaration]: TokenID.NT_ARG_DECL,
+  [Function_decl]: TokenID.NT_FUNC_DEFINITION,
+  [Variable_pack]: TokenID.NT_ENUM_DECL,
+  [Declarative]: TokenID.NT_DECLARATIVE_EXPR,
+  [Imperative]: TokenID.NT_IMPERATIVE_EXPR
+};
+
+function normalizeNode(node: AstNode, input: string) {
+  if (node.hasError) {
+    return;
+  }
+  switch (node.typeID) {
+    case 0:
+      return;
+
+    case Expression:
+      promoteSingleChild(node);
+      return;
+
+    case EmptySet:
+    case IntegerSet:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      return;
+
+    case Integer:
+      node.typeID = idRecord[node.typeID];
+      node.data.dataType = 'number';
+      node.data.value = Number(input.slice(node.from, node.to));
+      return;
+
+    case Function:
+    case Predicate:
+    case Global:
+    case Local:
+    case Radical:
+    case Integer:
+      node.typeID = idRecord[node.typeID];
+      node.data.dataType = 'string';
+      node.data.value = input.slice(node.from, node.to);
+      return;
+
+    case Boolean:
+      node.typeID = idRecord[node.typeID];
+      if (node.children.length === 4) {
+        node.children = [node.children[2]];
+      } else {
+        node.children = [node.children[1]];
+      }
+      clearData(node);
+      return;
+
+    case Filter:
+    case BigPr:
+    case SmallPr:
+      node.typeID = idRecord[node.typeID];
+      node.data.dataType = 'string[]';
+      node.data.value = parseIndex(input.slice(node.from + 2, node.to));
+      return;
+
+    case Red:
+    case Debool:
+    case Bool:
+    case Card:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      return;
+
+    case Function_decl:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      node.children = [node.children[1], node.children[3]];
+      return;
+    case Declaration:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      node.children = [node.children[0], node.children[2]];
+      return;
+
+    case Arguments:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      if (node.children.length === 3) {
+        processLeftEnum(node);
+      }
+      return;
+
+    case Expr_enum_min2:
+      processLeftEnum(node);
+      return;
+
+    case Setexpr:
+      if (node.children.length === 1) {
+        promoteSingleChild(node);
+      } else if (node.children.length === 4) {
+        processTextFunction(node);
+      }
+      return;
+
+    case Tuple:
+    case Enumeration:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      if (node.children[1].typeID === Expr_enum_min2) {
+        for (const child of node.children[1].children) {
+          child.parent = node;
+        }
+        node.children = node.children[1].children;
+      } else {
+        node.children = [node.children[1]];
+      }
+      return;
+
+    case Logic_binary:
+    case Logic_predicates:
+    case Setexpr_binary:
+      if (node.children[0].data.value === '(') {
+        processParenthesis(node);
+      } else {
+        clearData(node);
+        node.typeID = symbolToToken(node.children[1].data.value as string);
+        if (node.typeID === TokenID.DECART) {
+          processDecartChildren(node);
+        } else {
+          node.children = [node.children[0], node.children[2]];
+        }
+      }
+      return;
+
+    case Filter_expression:
+      processFilter(node);
+      return;
+
+    case Logic:
+      if (node.children[0].data.value === '(') {
+        processParenthesis(node);
+      } else {
+        promoteSingleChild(node);
+      }
+      return;
+
+    case Logic_unary:
+      if (node.children[0].data.value === '¬') {
+        clearData(node);
+        node.typeID = TokenID.LOGIC_NOT;
+        node.children = [node.children[1]];
+      } else if (node.children[0].typeID === TokenID.ID_PREDICATE) {
+        processTextFunction(node);
+      } else {
+        promoteSingleChild(node);
+      }
+      return;
+
+    case Logic_quantor:
+      clearData(node);
+      node.typeID = symbolToToken(node.children[0].data.value as string);
+      node.children = [node.children[1], node.children[3], node.children[4]];
+      return;
+
+    case Variable:
+      convertTupleDeclaration(node.children[0]);
+      promoteSingleChild(node);
+      return;
+
+    case Variable_pack:
+      if (node.children.length === 1) {
+        promoteSingleChild(node);
+      } else {
+        node.typeID = idRecord[node.typeID];
+        processLeftEnum(node);
+      }
+      return;
+
+    case Declarative:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      if (node.children[0].typeID === PrefixD) {
+        node.children = [node.children[2], node.children[4], node.children[6]];
+      } else {
+        node.children = [node.children[1], node.children[3], node.children[5]];
+      }
+      return;
+
+    case Imp_blocks:
+      if (node.children.length === 1) {
+        if (node.parent?.typeID === Imp_blocks) {
+          promoteSingleChild(node);
+        }
+      } else {
+        processLeftEnum(node);
+      }
+      return;
+
+    case Imperative:
+      node.typeID = idRecord[node.typeID];
+      clearData(node);
+      for (const child of node.children[4].children) {
+        child.parent = node;
+      }
+      node.children = [node.children[2], ...node.children[4].children];
+      return;
+
+    case Recursion:
+      if (node.children.length > 9) {
+        node.typeID = TokenID.NT_RECURSIVE_FULL;
+        node.children = [node.children[2], node.children[4], node.children[6], node.children[8]];
+      } else {
+        node.typeID = TokenID.NT_RECURSIVE_SHORT;
+        node.children = [node.children[2], node.children[4], node.children[6]];
+      }
+      return;
+  }
+}
+
+function convertTupleDeclaration(node: AstNode) {
+  if (node.typeID !== TokenID.NT_TUPLE) {
+    return;
+  }
+  node.typeID = TokenID.NT_TUPLE_DECL;
+  for (const child of node.children) {
+    convertTupleDeclaration(child);
+  }
+}
+
+function clearData(node: AstNode) {
+  node.data.value = null;
+  node.data.dataType = 'null';
+}
+
+function promoteSingleChild(node: AstNode, index: number = 0) {
+  for (const child of node.children[index].children) {
+    child.parent = node;
+  }
+  node.typeID = node.children[index].typeID;
+  node.data = node.children[index].data;
+  node.parenthesis = node.children[index].parenthesis;
+  node.children = node.children[index].children;
+}
+
+function parseIndex(text: string): string[] {
+  return text.split(',');
+}
+
+function symbolToToken(symbol: string): TokenID {
+  switch (symbol) {
+    case '+':
+      return TokenID.PLUS;
+    case '-':
+      return TokenID.MINUS;
+    case '*':
+      return TokenID.MULTIPLY;
+
+    case '∪':
+      return TokenID.SET_UNION;
+    case '\\':
+      return TokenID.SET_MINUS;
+    case '∆':
+      return TokenID.SET_SYMMETRIC_MINUS;
+    case '∩':
+      return TokenID.SET_INTERSECTION;
+    case '×':
+      return TokenID.DECART;
+
+    case '∈':
+      return TokenID.SET_IN;
+    case '∉':
+      return TokenID.SET_NOT_IN;
+    case '⊆':
+      return TokenID.SUBSET_OR_EQ;
+    case '⊄':
+      return TokenID.NOT_SUBSET;
+    case '⊂':
+      return TokenID.SUBSET;
+
+    case '>':
+      return TokenID.GREATER;
+    case '≥':
+      return TokenID.GREATER_OR_EQ;
+    case '<':
+      return TokenID.LESSER;
+    case '≤':
+      return TokenID.LESSER_OR_EQ;
+
+    case '≠':
+      return TokenID.NOTEQUAL;
+    case '=':
+      return TokenID.EQUAL;
+
+    case ':∈':
+      return TokenID.ITERATE;
+    case ':=':
+      return TokenID.ASSIGN;
+
+    case '¬':
+      return TokenID.LOGIC_NOT;
+
+    case '⇔':
+      return TokenID.LOGIC_EQUIVALENT;
+    case '⇒':
+      return TokenID.LOGIC_IMPLICATION;
+    case '∨':
+      return TokenID.LOGIC_OR;
+    case '&':
+      return TokenID.LOGIC_AND;
+
+    case '∀':
+      return TokenID.QUANTOR_UNIVERSAL;
+    case '∃':
+      return TokenID.QUANTOR_EXISTS;
+  }
+  return TokenID.ERROR;
+}
+
+function processParenthesis(node: AstNode) {
+  promoteSingleChild(node, 1);
+  node.parenthesis = true;
+}
+
+function processLeftEnum(node: AstNode) {
+  if (node.children[0].typeID === node.typeID) {
+    for (const child of node.children[0].children) {
+      child.parent = node;
+    }
+    node.children = [...node.children[0].children, node.children[2]];
+  } else {
+    node.children = [node.children[0], node.children[2]];
+  }
+}
+
+function processDecartChildren(node: AstNode) {
+  const newChildren: AstNode[] = [];
+  if (node.children[0].typeID === TokenID.DECART && !node.children[0].parenthesis) {
+    for (const child of node.children[0].children) {
+      child.parent = node;
+      newChildren.push(child);
+    }
+  } else {
+    newChildren.push(node.children[0]);
+  }
+
+  if (node.children[2].typeID === TokenID.DECART && !node.children[2].parenthesis) {
+    for (const child of node.children[2].children) {
+      child.parent = node;
+      newChildren.push(child);
+    }
+  } else {
+    newChildren.push(node.children[2]);
+  }
+  node.children = newChildren;
+}
+
+function processTextFunction(node: AstNode) {
+  if (node.children[0].typeID === TokenID.ID_FUNCTION || node.children[0].typeID === TokenID.ID_PREDICATE) {
+    node.typeID = TokenID.NT_FUNC_CALL;
+    clearData(node);
+    if (node.children[2].typeID === Expr_enum_min2) {
+      for (const child of node.children[2].children) {
+        child.parent = node;
+      }
+      node.children = [node.children[0], ...node.children[2].children];
+    } else {
+      node.children = [node.children[0], node.children[2]];
+    }
+  } else {
+    node.typeID = node.children[0].typeID;
+    node.data = node.children[0].data;
+    node.children = [node.children[2]];
+  }
+}
+
+function processFilter(node: AstNode) {
+  const children: AstNode[] = [];
+  if (node.children[2].typeID === Expr_enum_min2) {
+    for (const child of node.children[2].children) {
+      child.parent = node;
+      children.push(child);
+    }
+  } else {
+    children.push(node.children[2]);
+  }
+  children.push(node.children[5]);
+  promoteSingleChild(node);
+  node.children = children;
+}

package/src/rslang/parser/parser.terms.ts

@@ -0,0 +1,42 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+export const
+  Expression = 1,
+  Logic = 2,
+  Logic_predicates = 3,
+  Variable = 4,
+  Local = 5,
+  Tuple = 8,
+  Expr_enum_min2 = 9,
+  Logic_unary = 24,
+  Predicate = 26,
+  Logic_quantor = 29,
+  Variable_pack = 31,
+  Logic_binary = 33,
+  Setexpr = 38,
+  Integer = 39,
+  EmptySet = 40,
+  IntegerSet = 41,
+  Global = 42,
+  Radical = 43,
+  Setexpr_binary = 44,
+  Enumeration = 55,
+  Boolean = 56,
+  Filter_expression = 58,
+  Filter = 59,
+  Declarative = 60,
+  PrefixD = 62,
+  PrefixI = 63,
+  Imperative = 64,
+  Imp_blocks = 65,
+  PrefixR = 67,
+  Recursion = 68,
+  Function = 69,
+  BigPr = 70,
+  SmallPr = 71,
+  Card = 72,
+  Bool = 73,
+  Debool = 74,
+  Red = 75,
+  Function_decl = 76,
+  Arguments = 77,
+  Declaration = 78

package/src/rslang/parser/parser.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildTree, printTree } from '../../parsing';
+import { RSErrorCode, type RSErrorDescription } from '../error';
+
+import { parser } from './parser';
+import { extractSyntaxErrors } from './syntax-errors';
+
+const testSuccess = [
+  ['a1', '[Expression[Setexpr[Local]]]'],
+  ['A1', '[Expression[Setexpr[Global]]]'],
+  ['∅', '[Expression[Setexpr[EmptySet]]]'],
+  ['Z', '[Expression[Setexpr[IntegerSet]]]'],
+  ['1', '[Expression[Setexpr[Integer]]]'],
+  ['¬2=2', '[Expression[Logic[Logic_unary[¬][Logic[Logic_predicates[Setexpr[Integer]][=][Setexpr[Integer]]]]]]]'],
+  ['12+41', '[Expression[Setexpr[Setexpr_binary[Setexpr[Integer]][+][Setexpr[Integer]]]]]'],
+  [
+    '1+2*5',
+    '[Expression[Setexpr[Setexpr_binary[Setexpr[Integer]][+][Setexpr[Setexpr_binary[Setexpr[Integer]][*][Setexpr[Integer]]]]]]]'
+  ],
+  ['a1∪Z', '[Expression[Setexpr[Setexpr_binary[Setexpr[Local]][∪][Setexpr[IntegerSet]]]]]'],
+  ['pr1(S1)', '[Expression[Setexpr[SmallPr][(][Setexpr[Global]][)]]]'],
+  ['Pr1,2(X1)', '[Expression[Setexpr[BigPr][(][Setexpr[Global]][)]]]'],
+  ['debool(X1)', '[Expression[Setexpr[Debool][(][Setexpr[Global]][)]]]'],
+  [
+    'Fi1,2[ξ, ξ](ξ)',
+    '[Expression[Setexpr[Filter_expression[Filter][[][Expr_enum_min2[Setexpr[Local]][,][Setexpr[Local]]][]][(][Setexpr[Local]][)]]]]'
+  ],
+  ['ℬℬ(X1)', '[Expression[Setexpr[Boolean[ℬ][Boolean[ℬ][(][Setexpr[Global]][)]]]]]'],
+  ['P2[S1]', '[Expression[Logic[Logic_unary[Predicate][[][Setexpr[Global]][]]]]]'],
+  [
+    '[σ∈R1×R1] F6[σ]',
+    '[Expression[Function_decl[[][Arguments[Declaration[Variable[Local]][∈][Setexpr[Setexpr_binary[Setexpr[Radical]][×][Setexpr[Radical]]]]]][]][Setexpr[Function][[][Setexpr[Local]][]]]]]'
+  ],
+  [
+    '[(α,β)∈Z×X1] (α,β)',
+    '[Expression[Function_decl[[][Arguments[Declaration[Variable[Tuple[(][Expr_enum_min2[Setexpr[Local]][,][Setexpr[Local]]][)]]][∈][Setexpr[Setexpr_binary[Setexpr[IntegerSet]][×][Setexpr[Global]]]]]][]][Setexpr[Tuple[(][Expr_enum_min2[Setexpr[Local]][,][Setexpr[Local]]][)]]]]]'
+  ],
+  [
+    'D{ξ∈red(S1) | ξ=ξ}',
+    '[Expression[Setexpr[Declarative[PrefixD][{][Variable[Local]][∈][Setexpr[Red][(][Setexpr[Global]][)]][|][Logic[Logic_predicates[Setexpr[Local]][=][Setexpr[Local]]]][}]]]]'
+  ],
+  [
+    'I{(σ, γ) | σ:∈X1; γ:=F1[σ]; P1[σ, γ]}',
+    '[Expression[Setexpr[Imperative[PrefixI][{][Setexpr[Tuple[(][Expr_enum_min2[Setexpr[Local]][,][Setexpr[Local]]][)]]][|][Imp_blocks[Imp_blocks[Imp_blocks[Logic[Logic_predicates[Variable[Local]][:∈][Setexpr[Global]]]]][;][Logic[Logic_predicates[Variable[Local]][:=][Setexpr[Function][[][Setexpr[Local]][]]]]]][;][Logic[Logic_unary[Predicate][[][Expr_enum_min2[Setexpr[Local]][,][Setexpr[Local]]][]]]]][}]]]]'
+  ],
+  [
+    'R{ξ:=D1 | F1[ξ]≠∅ | ξ∪F1[ξ]}',
+    '[Expression[Setexpr[Recursion[PrefixR][{][Variable[Local]][:=][Setexpr[Global]][|][Logic[Logic_predicates[Setexpr[Function][[][Setexpr[Local]][]]][≠][Setexpr[EmptySet]]]][|][Setexpr[Setexpr_binary[Setexpr[Local]][∪][Setexpr[Function][[][Setexpr[Local]][]]]]][}]]]]'
+  ],
+  [
+    '∀ξ∈∅ 1=1',
+    '[Expression[Logic[Logic_unary[Logic_quantor[∀][Variable_pack[Variable[Local]]][∈][Setexpr[EmptySet]][Logic[Logic_predicates[Setexpr[Integer]][=][Setexpr[Integer]]]]]]]]'
+  ],
+  [
+    '∀ξ1∈β (ξ1≠∅ & ∀ξ2∈β ξ1∩ξ2=∅)',
+    '[Expression[Logic[Logic_unary[Logic_quantor[∀][Variable_pack[Variable[Local]]][∈][Setexpr[Local]][Logic[(][Logic[Logic_binary[Logic[Logic_predicates[Setexpr[Local]][≠][Setexpr[EmptySet]]]][&][Logic[Logic_unary[Logic_quantor[∀][Variable_pack[Variable[Local]]][∈][Setexpr[Local]][Logic[Logic_predicates[Setexpr[Setexpr_binary[Setexpr[Local]][∩][Setexpr[Local]]]][=][Setexpr[EmptySet]]]]]]]]][)]]]]]]'
+  ],
+  [
+    '∀α1∈α2 1=1',
+    '[Expression[Logic[Logic_unary[Logic_quantor[∀][Variable_pack[Variable[Local]]][∈][Setexpr[Local]][Logic[Logic_predicates[Setexpr[Integer]][=][Setexpr[Integer]]]]]]]]'
+  ]
+];
+
+const testError = [
+  ['', '[Expression[⚠]]'],
+  ['!', '[Expression[⚠]]']
+];
+
+const testErrorData = [
+  ['(', { code: RSErrorCode.missingParenthesis, from: 1, to: 1 }],
+  ['{X1', { code: RSErrorCode.missingCurlyBrace, from: 3, to: 3 }],
+  ['∀∈X1 (1=1)', { code: RSErrorCode.expectedLocal, from: 1, to: 1 }],
+  ['∀σ∈S2 ∀(ξ,δ,π)∈σ (ξ∈δ & δ∈{pr1(π), pr2(π)}', { code: RSErrorCode.missingParenthesis, from: 42, to: 42 }],
+  ['Fi1[X1) (X1)', { code: RSErrorCode.bracketMismatch, from: 6, to: 7, params: [']', ')'] }],
+  [')X1', { code: RSErrorCode.missingOpenBracket, from: 0, to: 1, params: ['('] }],
+  ['Fi1[X1(X1)', { code: RSErrorCode.missingSquareBracket, from: 10, to: 10 }]
+];
+
+describe('Testing RSParser correct inputs', () => {
+  testSuccess.forEach(([input, expectedTree]) => {
+    it(`Parse "${input}"`, () => {
+      const tree = parser.parse(input);
+      expect(printTree(tree)).toBe(expectedTree);
+    });
+  });
+});
+
+describe('Testing RSParser error inputs AST', () => {
+  testError.forEach(([input, expectedTree]) => {
+    it(`Parse "${input}"`, () => {
+      const tree = parser.parse(input);
+      expect(printTree(tree)).toBe(expectedTree);
+    });
+  });
+});
+
+describe('Testing RSParser error data', () => {
+  testErrorData.forEach(([input, expectedError]) => {
+    it(`Parse "${input as string}"`, () => {
+      const tree = parser.parse(input as string);
+      const ast = buildTree(tree.cursor());
+      expect(ast.hasError).toBe(true);
+      const errors: RSErrorDescription[] = [];
+      extractSyntaxErrors(ast, input as string, error => errors.push(error));
+      expect(errors.length).toBe(1);
+      expect(errors[0]).toMatchObject(expectedError as RSErrorDescription);
+    });
+  });
+
+  it('Quantor expressions', () => {
+    const input = '∀X1∈X1 (1=1)';
+    const tree = parser.parse(input);
+    const ast = buildTree(tree.cursor());
+    const errors: RSErrorDescription[] = [];
+    extractSyntaxErrors(ast, input, error => errors.push(error));
+    expect(errors.length).toBe(2);
+    expect(errors[1]).toMatchObject({ code: RSErrorCode.expectedLocal, from: 3, to: 3 });
+  });
+
+  it('Includes end position for ranged syntax errors', () => {
+    const input = '∀∈X1 (1=1)';
+    const tree = parser.parse(input);
+    const ast = buildTree(tree.cursor());
+    const errors: RSErrorDescription[] = [];
+    extractSyntaxErrors(ast, input, error => errors.push(error));
+    expect(errors[0]).toMatchObject({
+      code: RSErrorCode.expectedLocal,
+      from: 1,
+      to: 1
+    });
+  });
+
+  it('Reports true double parentheses only', () => {
+    const withDoubleParentheses = 'R{ξ:=S1 | 1=1 | ξ∪((S2))}';
+    const treeDouble = parser.parse(withDoubleParentheses);
+    const astDouble = buildTree(treeDouble.cursor());
+    const errorsDouble: RSErrorDescription[] = [];
+    extractSyntaxErrors(astDouble, withDoubleParentheses, error => errorsDouble.push(error));
+
+    expect(errorsDouble.some(error => error.code === RSErrorCode.doubleParenthesis)).toBe(true);
+  });
+
+  it('Does not report tuple as double parentheses', () => {
+    const withTuple = 'R{ξ:={((S3, ∅),0)}| pr1(F8[ξ])∩S2=∅  | ξ∪((),card(ξ))}';
+    const treeTuple = parser.parse(withTuple);
+    const astTuple = buildTree(treeTuple.cursor());
+    const errorsTuple: RSErrorDescription[] = [];
+    extractSyntaxErrors(astTuple, withTuple, error => errorsTuple.push(error));
+
+    expect(errorsTuple.some(error => error.code === RSErrorCode.doubleParenthesis)).toBe(false);
+  });
+});

package/src/rslang/parser/parser.ts

@@ -0,0 +1,20 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+import {LRParser} from "@lezer/lr"
+export const parser = LRParser.deserialize({
+  version: 14,
+  states: "2lO!sQPOOOVQPO'#CdO$qQPO'#C`O&pQPO'#C`O*bQPO'#C_Q*jQPOOO,TQPO'#CyOVQPO'#CtO,]QPO'#CtOOQO'#Ct'#CtOOQO'#C^'#C^OOQO'#ES'#ESOOQO'#ET'#ETO,bQPO'#DeO,iQPO'#DfO,qQPO'#DhO,vQPO'#DjO,{QPO'#DnO-QQPO'#DrOOQO'#EU'#EUOOQO'#EV'#EVOOQO'#DS'#DSO-VQPO'#DSO-[QPO'#DSOOQO'#EQ'#EQO,TQPO'#DzQOQPOOO-aQPO'#ERO-nQPO,59OO-vQPO'#CeO-{QPO,58xO/lQPO,59tOVQPO,58yOVQPO,58yOVQPO,59iOVQPO,59iOVQPO,59iOVQPO,59iOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO'#CdOOQO'#C`'#C`OOQO'#C{'#C{O1]QPO,59eO2rQPO,59`OVQPO,59`OOQO'#ER'#ERO5TQPO,5:PO5]QPO,5:UOVQPO,5:QOOQO,5:Q,5:QOVQPO,5:SO,TQPO,5:UOVQPO,5:YO,TQPO,5:^OVQPO,59nOVQPO,59nO5dQPO'#D|OOQO'#D{'#D{O5iQPO,5:fOOQO1G.j1G.jOVQPO,59POOQO1G.d1G.dOOQO1G/`1G/`O5qQPO1G.eO7vQPO1G.eO:zQPO1G/TO=]QPO1G/TO?nQPO1G/TOBPQPO1G/TOGyQPO1G/`OHQQPO1G/`OKpQPO1G/`O! `QPO1G/`O! gQPO1G/`O! nQPO1G/`O! uQPO1G/`O,TQPO,59gOVQPO1G/PO!%aQPO1G.zOOQO1G/k1G/kOVQPO1G/pO!%iQPO1G/lO!%pQPO1G/nO!%xQPO1G/pO!%}QPO1G/tO!&UQPO1G/xO!&ZQPO1G/YO!&cQPO1G/YOVQPO,5:hO,TQPO,5:gOVQPO1G0QO!&jQPO1G.kOOQO1G/R1G/RO!&zQPO7+$kOOQO7+$f7+$fO!(gQPO7+%[OOQO7+%W7+%WO!(nQPO7+%YOVQPO7+%[OVQPO7+%`OVQPO7+%dOOQO7+$t7+$tO!(sQPO1G0SOOQO1G0R1G0RO!(}QPO7+%lO!)UQPO<<HVOVQPO<<HvOVQPO<<HtO!+gQPO<<HvO!+nQPO'#DoO!+xQPO<<HzO!,QQPO<<IOO!,XQPOAN>bO!,`QPOAN>`OVQPOAN>bOVQPO,5:ZOOQOAN>fAN>fOVQPOAN>jOOQOG23|G23|OOQOG23zG23zO!,gQPOG23|O!,nQPO1G/uO!,xQPOG24UOOQOLD)hLD)hOOQOLD)pLD)pOVQPOLD)pO!-SQPO!$'M[OOQO!)9Bv!)9Bv",
+  stateData: "!-l~O!sOS~OTQOVPOiVOjWOnUOpUOwZOxZOyZOz[O{[O!W]O!Z^O!]_O!``O!aaO!ebO!gfO!hdO!idO!jdO!kdO!ldO!mdO~OkiO~PVOZSX[SX]!wX^!wX_!wX`!wXa!wXb!wXc!wXd!wXe!wXf!wXg!wXr!wXs!wXt!wXu!wX}!wX!O!wX!P!wX!Q!wX!R!wX!S!wX!T!wX!U!wXY!wX!V!wX~O!q!wXU!wXl!wX!_!wXT!wXV!wXi!wXj!wXn!wXp!wXw!wXx!wXy!wXz!wX{!wX!W!wX!Z!wX!]!wX!`!wX!a!wX!e!wX!g!wX!h!wX!i!wX!j!wX!k!wX!l!wX!m!wX!d!wX~P!zOZSX[SX]!xX^!xX_!xX`!xXa!xXb!xXc!xXd!xXe!xXf!xXg!xXr!xXs!xXt!xXu!xX}!xX!O!xX!P!xX!Q!xX!R!xX!S!xX!T!xX!U!xX!q!xXY!xX!V!xXU!xXl!xX!_!xXT!xXV!xXi!xXj!xXn!xXp!xXw!xXx!xXy!xXz!xX{!xX!W!xX!Z!xX!]!xX!`!xX!a!xX!e!xX!g!xX!h!xX!i!xX!j!xX!k!xX!l!xX!m!xX!d!xX~OZpO[pO~O]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqOrrOssOttOuuO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~OT!POV!OO~Ok!TO~OT!WO~PYOV!XO!Z^O~Ok!ZO~O!W![O~O!W!]O~O!W!^O~Ok!_O~OV!`O~OY!uX!V!uXl!uX~P*jOU!dOY!uX~OY!eO~OU!fOY!tX]!tX^!tX_!tX`!tXa!tXb!tXc!tXd!tXe!tXf!tXg!tXr!tXs!tXt!tXu!tX}!tX!O!tX!P!tX!Q!tX!R!tX!S!tX!T!tX!U!tX~OU!gOYvX]vX^vX_vX`vXavXbvXcvXdvXevXfvXgvXrvXsvXtvXuvX}vX!OvX!PvX!QvX!RvX!SvX!TvX!UvX~OY!uO]!vO~O]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~Orhashathauha!qhaUhaYha!Vhalha!_haThaVhaihajhanhaphawhaxhayhazha{ha!Wha!Zha!]ha!`ha!aha!eha!gha!hha!iha!jha!kha!lha!mha!dha~P1eOY!eO!V!xO~O]!yO~P!zO]#RO~OY#SOl#TO~O!qRiURiYRi!VRilRi!_RiTRiVRiiRijRinRipRiwRixRiyRizRi{Ri!WRi!ZRi!]Ri!`Ri!aRi!eRi!gRi!hRi!iRi!jRi!kRi!lRi!mRi!dRi~P*jO]Ri^Ri_Ri`RiaRibRicRidRieRifRigRirRisRitRiuRi!qRiURiYRi!VRilRi!_RiTRiVRiiRijRinRipRiwRixRiyRizRi{Ri!WRi!ZRi!]Ri!`Ri!aRi!eRi!gRi!hRi!iRi!jRi!kRi!lRi!mRi!dRi~P+iOssOttOuuOrqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOttOuuOrqisqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOuuOrqisqitqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOrqisqitqiuqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eO}vO]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!P|i!Q|i!R|i!S|i!T|i!U|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!O|i~PDbO!OwO~PDbO}vO!OwO!PxO!U}O]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!R|i!S|i!T|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!Q|i~PHXO}vO!OwO!PxO!QyO!T|O!U}O]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!S|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!R|i~PKwO!RzO~PKwO!QyO~PHXO}vO!OwO!PxO]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!Q|i!R|i!S|i!T|i!U|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~OY!eOl#XO~OU#ZO~P*jOY!eOl#[O~O]#]O~O!_#^O~P*jO[#_O~OY!eOl#`O~OU#`O~P*jOUXiYXi!VXilXi~P*jO]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqOrrOssOttOuuO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~PVO!_#eO~P*jOV#fO~OY!pil!pi~P*jO!q!nq~P*jOrmysmytmyumy!qmyUmyYmy!Vmylmy!_myTmyVmyimyjmynmypmywmyxmyymyzmy{my!Wmy!Zmy!]my!`my!amy!emy!gmy!hmy!imy!jmy!kmy!lmy!mmy!dmy~P1eO!_#mO~P*jO!V!cX!d!cX~P*jO!V#oO!d#nO~O!_#pO~P*jO!V#qO~P*jOU#rO~P*jO!V#vO~P*jO!V!ci!d!ci~P*jO!V#wO!_#xO~P*jO!V#zO~P*jO!]!hj!gz{!j!k!l!m!iT!e!a!`!a~",
+  goto: "1O!zPP!{#y$uPPP&R'VPPPPPPPPPPPPPP#yPPPP'aP(]P#yPPPP(`PPPPP)[PPPPPPPPPP*Y+UP*YP*YPPP*Y,TPP*YPPPPPPP,W,Z,^PPP,d.v/W/W/W0S!phOV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xRnP!sYOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!rSOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xQ!QUS!ai#SQ!|![Q#O!^R#V!u!rROPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x]!PUi![!^!u#SSlP!OX!U]!T!Z!_!sXOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xR!RU!shOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!peOV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xRoP!scOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!rcOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xR!Y^R#i#^RjOR!ciQ!biR#b#SQTO[kP]!O!T!Z!_Q!SVQ!gvQ!hpQ!iqQ!jrQ!ksQ!ltQ!muQ!nwQ!oxQ!pyQ!qzQ!r{Q!s|Q!t}Q!z!XQ!}!]Q#Q!`Q#U!eQ#W!vQ#Y!yQ#a#RQ#c#TQ#d#WQ#g#]Q#h#^Q#j#_Q#k#eQ#l#fQ#s#mQ#t#nQ#u#pR#y#xSmP!OQ!V]Q!w!TQ!{!ZR#P!_!seOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!sgOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x",
+  nodeNames: "⚠ Expression Logic Logic_predicates Variable Local ) ( Tuple Expr_enum_min2 , :∈ := ∈ ∉ ⊆ ⊄ ⊂ > ≥ < ≤ ≠ = Logic_unary ¬ Predicate [ ] Logic_quantor ∀ Variable_pack ∃ Logic_binary ⇔ ⇒ ∨ & Setexpr Integer EmptySet IntegerSet Global Radical Setexpr_binary * + - ∪ \\ ∆ ∩ × } { Enumeration Boolean ℬ Filter_expression Filter Declarative | PrefixD PrefixI Imperative Imp_blocks ; PrefixR Recursion Function BigPr SmallPr Card Bool Debool Red Function_decl Arguments Declaration",
+  maxTerm: 87,
+  nodeProps: [
+    ["openedBy", 6,"(",53,"{"],
+    ["closedBy", 7,")",54,"}"]
+  ],
+  skippedNodes: [0],
+  repeatNodeCount: 0,
+  tokenData: "6j~R!jX^%spq%svw&hxy&myz&rz{&w{|&||}'R}!O'W!Q![']![!]'e!]!^'x!^!_'}!_!`(S!`!a(X!c!d(^!e!f(^!f!g(l!h!i(t!k!l)h!p!q(^!r!s)m!t!u*a!u!v(^!v!w(^!z!{(^!|!}*q!}#O*v#O#P*{#P#Q+Q#R#S+V#T#U+V#U#V+m#V#W-]#W#X.x#X#d+V#d#e1b#e#f+V#f#g2w#g#o+V#o#p4R#p#q4W#q#r4]#y#z%s$f$g%s$r$s4b%o%p4g5i6S+V#BY#BZ%s$IS$I_%s$I|$JO%s$JT$JU%s$KV$KW%s% l% m4l%%Y%%Z4q%%[%%]4v%&Y%&Z4{%&]%&^5Q%&_%&`5V%&`%&a5[%&b%&c5a%&c%&d5f%'S%'T5k%'T%'U5p%'U%'V5u%(^%(_5z%(b%(c6P%(c%(d6U%)Q%)R6Z%)S%)T6`%)U%)V6e&FU&FV%s~%xY!s~X^%spq%s#y#z%s$f$g%s#BY#BZ%s$IS$I_%s$I|$JO%s$JT$JU%s$KV$KW%s&FU&FV%s~&mOu~~&rOV~~&wOU~~&|O}~~'RO!O~~'WOY~~']O!P~~'bPw~!Q![']~'hQ!_!`'n%&b%&c's~'sO[~~'xOZ~~'}O!d~~(SOd~~(XOg~~(^Ob~~(aP!Q![(d~(iPz~!Q![(d~(qP!`~!Q![(d~(wQ!Q![(}#]#^)V~)SP!g~!Q![(}~)YP!R![)]~)bQ!]~|})V!Q![)]~)mO!a~~)pQ!Q![)v#f#g*O~){Pj~!Q![)v~*RP!R![*U~*ZQ!h~|}*O!Q![*U~*fP!e~!Q![*i~*nP{~!Q![*i~*vOy~~*{Ok~~+QO!R~~+VOl~~+[RT~!Q![+e#T#o+V5i6S+V~+jPT~!Q![+e~+rTT~!Q![+e#T#c+V#c#d,R#d#o+V5i6S+V~,WTT~!Q![+e#T#c+V#c#d,g#d#o+V5i6S+V~,lTT~!Q![+e#T#`+V#`#a,{#a#o+V5i6S+V~-SR!k~T~!Q![+e#T#o+V5i6S+V~-bST~!Q![+e#T#U-n#U#o+V5i6S+V~-sTT~!Q![+e#T#f+V#f#g.S#g#o+V5i6S+V~.XTT~!Q![+e#T#W+V#W#X.h#X#o+V5i6S+V~.oR!j~T~!Q![+e#T#o+V5i6S+V~.}TT~!Q![+e#T#X+V#X#Y/^#Y#o+V5i6S+V~/cTT~!Q![+e#T#U+V#U#V/r#V#o+V5i6S+V~/wTT~!Q![+e#T#c+V#c#d0W#d#o+V5i6S+V~0]TT~!Q![+e#T#c+V#c#d0l#d#o+V5i6S+V~0qTT~!Q![+e#T#`+V#`#a1Q#a#o+V5i6S+V~1XR!l~T~!Q![+e#T#o+V5i6S+V~1gTT~!Q![+e#T#f+V#f#g1v#g#o+V5i6S+V~1{ST~!Q!R+e!R![2X#T#o+V5i6S+V~2`Q!i~T~|}2f!Q![2X~2iP!R![2l~2qQ!i~|}2f!Q![2l~2|TT~!Q![+e#T#X+V#X#Y3]#Y#o+V5i6S+V~3bTT~!Q![+e#T#W+V#W#X3q#X#o+V5i6S+V~3xR!m~T~!Q![+e#T#o+V5i6S+V~4WO!W~~4]O!_~~4bO!V~~4gOi~~4lO!U~~4qO!Z~~4vOs~~4{Or~~5QOn~~5VOp~~5[Ox~~5aO!S~~5fO]~~5kO^~~5pOt~~5uO!T~~5zO!Q~~6POf~~6UOe~~6ZOc~~6`Oa~~6eO`~~6jO_~",
+  tokenizers: [0],
+  topRules: {"Expression":[0,1]},
+  tokenPrec: 2679
+})