@rsconcept/domain 1.7.0 → 1.7.2

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

@@ -0,0 +1,255 @@
+/**
+ * Expression-level diagnostics (no AST required) and error deduplication.
+ */
+
+import { RSErrorCode, type RSErrorDescription } from '../../error';
+
+type OpenBracket = '(' | '[' | '{';
+type CloseBracket = ')' | ']' | '}';
+
+interface BracketFrame {
+  bracket: OpenBracket;
+  index: number;
+}
+
+const ALLOWED_EXPRESSION_CHARS = buildAllowedExpressionChars();
+
+function buildAllowedExpressionChars(): Set<string> {
+  const chars = new Set<string>();
+  for (const chunk of [
+    '0123456789',
+    'abcdefghijklmnopqrstuvwxyz',
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    '_',
+    '∅¬∀∃⇔⇒∨&ℬ+-*∪\\∆∩×∈∉⊆⊄⊂<>≥≤≠=,:;|[]{}()'
+  ]) {
+    for (const symbol of chunk) {
+      chars.add(symbol);
+    }
+  }
+  for (let codePoint = 0x03b1; codePoint <= 0x03c9; codePoint++) {
+    chars.add(String.fromCodePoint(codePoint));
+  }
+  return chars;
+}
+
+function isAllowedExpressionChar(symbol: string): boolean {
+  return /\s/u.test(symbol) || ALLOWED_EXPRESSION_CHARS.has(symbol);
+}
+
+export function extractForbiddenCharacterErrors(expression: string): RSErrorDescription[] {
+  const errors: RSErrorDescription[] = [];
+  let pos = 0;
+
+  while (pos < expression.length) {
+    const symbol = expression[pos];
+    if (isAllowedExpressionChar(symbol)) {
+      pos++;
+      continue;
+    }
+
+    const start = pos;
+    while (pos < expression.length && !isAllowedExpressionChar(expression[pos])) {
+      pos++;
+    }
+
+    errors.push({
+      code: RSErrorCode.forbiddenCharacter,
+      from: start,
+      to: pos,
+      params: [expression.slice(start, pos)]
+    });
+  }
+
+  return errors;
+}
+
+export function extractBracketErrors(expression: string): RSErrorDescription | null {
+  const stack: BracketFrame[] = [];
+
+  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 === undefined) {
+      return {
+        code: RSErrorCode.missingOpenBracket,
+        from: pos,
+        to: pos + 1,
+        params: [symbol]
+      };
+    }
+
+    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: RSErrorCode.missingCloseBracket,
+      from: unclosed.index,
+      to: unclosed.index + 1,
+      params: [unclosed.bracket]
+    };
+  }
+
+  return null;
+}
+
+export function deduplicateErrors(errors: RSErrorDescription[]): RSErrorDescription[] {
+  const result: RSErrorDescription[] = [];
+
+  for (const error of errors) {
+    const duplicate = result.some(
+      existing => existing.code === error.code && existing.from === error.from && existing.to === error.to
+    );
+    if (duplicate) {
+      continue;
+    }
+
+    if (error.code !== RSErrorCode.unknownSyntax) {
+      for (let index = result.length - 1; index >= 0; index--) {
+        if (result[index].code === RSErrorCode.unknownSyntax && rangesOverlap(error, result[index])) {
+          result.splice(index, 1);
+        }
+      }
+    }
+
+    result.push(error);
+  }
+
+  const specific = result.filter(error => error.code !== RSErrorCode.unknownSyntax);
+  const filtered = result.filter(
+    error => error.code !== RSErrorCode.unknownSyntax || !specific.some(item => rangesOverlap(error, item))
+  );
+  return collapseContiguousUnknownSyntax(filtered);
+}
+
+function collapseContiguousUnknownSyntax(errors: RSErrorDescription[]): RSErrorDescription[] {
+  const unknowns = errors.filter(error => error.code === RSErrorCode.unknownSyntax);
+  if (unknowns.length <= 1) {
+    return errors;
+  }
+
+  const others = errors.filter(error => error.code !== RSErrorCode.unknownSyntax);
+  const sorted = [...unknowns].sort((left, right) => left.from - right.from || left.to - right.to);
+  const merged: RSErrorDescription[] = [];
+
+  let clusterFrom = sorted[0].from;
+  let clusterTo = sorted[0].to;
+
+  for (let index = 1; index < sorted.length; index++) {
+    const error = sorted[index];
+    if (error.from <= clusterTo) {
+      clusterTo = Math.max(clusterTo, error.to);
+      continue;
+    }
+
+    merged.push({ code: RSErrorCode.unknownSyntax, from: clusterFrom, to: clusterTo });
+    clusterFrom = error.from;
+    clusterTo = error.to;
+  }
+
+  merged.push({ code: RSErrorCode.unknownSyntax, from: clusterFrom, to: clusterTo });
+  return [...others, ...merged];
+}
+
+function rangesOverlap(a: RSErrorDescription, b: RSErrorDescription): boolean {
+  return a.from < b.to && b.from < a.to;
+}
+
+function isOpenBracket(symbol: string): symbol is OpenBracket {
+  return symbol === '(' || symbol === '[' || symbol === '{';
+}
+
+function isCloseBracket(symbol: string): symbol is CloseBracket {
+  return symbol === ')' || symbol === ']' || symbol === '}';
+}
+
+function openToClose(symbol: OpenBracket): CloseBracket {
+  switch (symbol) {
+    case '(':
+      return ')';
+    case '[':
+      return ']';
+    case '{':
+      return '}';
+  }
+}
+
+function closeToOpen(symbol: CloseBracket): OpenBracket {
+  switch (symbol) {
+    case ')':
+      return '(';
+    case ']':
+      return '[';
+    case '}':
+      return '{';
+  }
+}
+
+function isDoubleParenthesis(expression: string, pos: number): boolean {
+  const isOpenDoubleParenthesis = expression[pos] === '(' && expression[pos + 1] === '(';
+  if (!isOpenDoubleParenthesis) {
+    return false;
+  }
+
+  const outerClose = findMatchingCloseParen(expression, pos);
+  const innerClose = findMatchingCloseParen(expression, pos + 1);
+  if (outerClose < 0 || innerClose < 0) {
+    return false;
+  }
+
+  return outerClose === innerClose + 1;
+}
+
+function findMatchingCloseParen(expression: string, openPos: number): number {
+  if (expression[openPos] !== '(') {
+    return -1;
+  }
+
+  const stack: OpenBracket[] = [];
+  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 === undefined || top !== closeToOpen(symbol)) {
+      return -1;
+    }
+    if (stack.length === 0) {
+      return index;
+    }
+  }
+
+  return -1;
+}

package/src/rslang/parser/syntax-errors/function-calls.ts

@@ -0,0 +1,76 @@
+/**
+ * Malformed calls: `Fi…(…)`, `F1` / `P1` without or with wrong argument brackets.
+ */
+
+import type { AstNode } from '../../../parsing';
+import { RSErrorCode, type RSErrorDescription } from '../../error';
+
+import {
+  findAncestor,
+  findMatchingCloseBracket,
+  findRelatedNode,
+  isFilterNode,
+  isFunctionNode,
+  isPredicateNode
+} from './ast-utils';
+import type { ErrorClassifier } from './context';
+
+export const classifyFilterParenMismatch: ErrorClassifier = (node, expression) => {
+  const filterNode = findAncestor(node, isFilterNode) ?? findRelatedNode(node, isFilterNode);
+  if (filterNode === null || expression[filterNode.to] !== '(') {
+    return null;
+  }
+
+  return {
+    code: RSErrorCode.invalidFilterSyntax,
+    from: filterNode.from,
+    to: filterNode.to + 1
+  };
+};
+
+export const classifyGlobalFuncCall: ErrorClassifier = (node, expression) => {
+  const funcNode =
+    findAncestor(node, n => isFunctionNode(n) || isPredicateNode(n)) ??
+    findRelatedNode(node, n => isFunctionNode(n) || isPredicateNode(n));
+  if (funcNode === null) {
+    return null;
+  }
+  return classifyFuncWithoutArgs(funcNode, expression);
+};
+
+function classifyFuncWithoutArgs(funcNode: AstNode, expression: string): RSErrorDescription | null {
+  const name = expression.slice(funcNode.from, funcNode.to);
+  const rest = expression.slice(funcNode.to);
+
+  const withoutArgs: RSErrorDescription = {
+    code: RSErrorCode.globalFuncWithoutArgs,
+    from: funcNode.from,
+    to: funcNode.to,
+    params: [name]
+  };
+
+  if (/^\s*$/.test(rest)) {
+    return withoutArgs;
+  }
+
+  if (/^\s*\(/.test(rest)) {
+    return {
+      code: RSErrorCode.globalFuncParenCall,
+      from: funcNode.from,
+      to: funcNode.to,
+      params: [name]
+    };
+  }
+
+  const openBracket = /^\s*\[/.exec(rest);
+  if (openBracket === null) {
+    return null;
+  }
+
+  const closeIdx = findMatchingCloseBracket(rest, openBracket[0].length - 1);
+  if (closeIdx >= 0 && rest.slice(openBracket[0].length, closeIdx).trim().length === 0) {
+    return withoutArgs;
+  }
+
+  return null;
+}

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

@@ -0,0 +1,315 @@
+/**
+ * Incomplete generator bodies: declarative `D{…}`, imperative `I{…}`, recursive `R{…}`.
+ */
+
+import type { AstNode } from '../../../parsing';
+import { RSErrorCode, type RSErrorDescription } from '../../error';
+import { Declarative, Imp_blocks, Imperative, Recursion, Setexpr } from '../parser.terms';
+import { TokenID } from '../token';
+
+import { findAncestor, isDescendantOf, isErrorPlaceholder, subtreeHasError } from './ast-utils';
+import type { ErrorClassifier } from './context';
+import { errorAt, isTextToken } from './error-builders';
+
+export const classifyIncompleteGenerator: ErrorClassifier = (node, expression) =>
+  detectIncompleteDeclarative(node, expression) ??
+  detectIncompleteImperative(node, expression) ??
+  detectIncompleteRecursion(node, expression);
+
+export function isIncompleteGeneratorBodyCode(code: RSErrorCode): boolean {
+  return (
+    code === RSErrorCode.expectedDeclarativeBody ||
+    code === RSErrorCode.expectedImperativeBody ||
+    code === RSErrorCode.expectedRecursiveBody
+  );
+}
+
+interface GeneratorBodySlot {
+  nodes: AstNode[];
+  headerEndIndex: number;
+}
+
+function detectIncompleteDeclarative(node: AstNode, expression: string): RSErrorDescription | null {
+  const generatorNode = findAncestor(
+    node,
+    target => target.typeID === Declarative || target.typeID === TokenID.NT_DECLARATIVE_EXPR
+  );
+  return detectIncompleteGeneratorBody(node, expression, generatorNode, RSErrorCode.expectedDeclarativeBody, slot =>
+    isIncompleteDeclarativeBody(slot.nodes)
+  );
+}
+
+function detectIncompleteImperative(node: AstNode, expression: string): RSErrorDescription | null {
+  const generatorNode = findAncestor(
+    node,
+    target => target.typeID === Imperative || target.typeID === TokenID.NT_IMPERATIVE_EXPR
+  );
+  return detectIncompleteGeneratorBody(node, expression, generatorNode, RSErrorCode.expectedImperativeBody, slot =>
+    isIncompleteImperativeBody(slot, expression)
+  );
+}
+
+function detectIncompleteRecursion(node: AstNode, expression: string): RSErrorDescription | null {
+  const generatorNode = findAncestor(node, target => target.typeID === Recursion);
+  return detectIncompleteGeneratorBody(node, expression, generatorNode, RSErrorCode.expectedRecursiveBody, slot =>
+    isIncompleteRecursionBody(slot.nodes)
+  );
+}
+
+function detectIncompleteGeneratorBody(
+  node: AstNode,
+  expression: string,
+  generatorNode: AstNode | null,
+  code: RSErrorCode,
+  isIncomplete: (slot: GeneratorBodySlot) => boolean
+): RSErrorDescription | null {
+  if (generatorNode === null || expression.slice(generatorNode.to).trim().length > 0) {
+    return null;
+  }
+
+  const slot = getGeneratorBodySlot(generatorNode, expression);
+  if (slot === null || !isIncomplete(slot) || !generatorHeaderIsValid(generatorNode, expression, slot.headerEndIndex)) {
+    return null;
+  }
+
+  if (!isErrorInBodySlot(node, slot, generatorNode)) {
+    return null;
+  }
+
+  return errorAt(node, code);
+}
+
+function getGeneratorBodySlot(generatorNode: AstNode, expression: string): GeneratorBodySlot | null {
+  if (generatorNode.typeID === Declarative || generatorNode.typeID === TokenID.NT_DECLARATIVE_EXPR) {
+    return getDeclarativeBodySlot(generatorNode, expression);
+  }
+  if (generatorNode.typeID === Imperative || generatorNode.typeID === TokenID.NT_IMPERATIVE_EXPR) {
+    return getImperativeBodySlot(generatorNode, expression);
+  }
+  if (generatorNode.typeID === Recursion) {
+    return getRecursionBodySlot(generatorNode, expression);
+  }
+  return null;
+}
+
+function getDeclarativeBodySlot(declNode: AstNode, expression: string): GeneratorBodySlot | null {
+  const pipeIndex = declNode.children.findIndex(child => isTextToken(child, expression, '|'));
+  if (pipeIndex >= 0) {
+    return {
+      nodes: contentChildren(declNode, expression, pipeIndex + 1),
+      headerEndIndex: pipeIndex + 1
+    };
+  }
+
+  const domainNode = findDeclarativeDomain(declNode, expression);
+  if (domainNode === null) {
+    return null;
+  }
+
+  const domainIndex = declNode.children.indexOf(domainNode);
+  return {
+    nodes: contentChildren(declNode, expression, domainIndex + 1),
+    headerEndIndex: domainIndex + 1
+  };
+}
+
+function getImperativeBodySlot(impNode: AstNode, expression: string): GeneratorBodySlot | null {
+  const pipeIndex = impNode.children.findIndex(child => isTextToken(child, expression, '|'));
+  if (pipeIndex >= 0) {
+    return {
+      nodes: contentChildren(impNode, expression, pipeIndex + 1),
+      headerEndIndex: pipeIndex + 1
+    };
+  }
+
+  const tupleNode = findImperativeTuple(impNode);
+  if (tupleNode === null) {
+    return null;
+  }
+
+  const tupleIndex = impNode.children.indexOf(tupleNode);
+  return {
+    nodes: contentChildren(impNode, expression, tupleIndex + 1),
+    headerEndIndex: tupleIndex + 1
+  };
+}
+
+function getRecursionBodySlot(recNode: AstNode, expression: string): GeneratorBodySlot | null {
+  const initNode = findRecursionInit(recNode, expression);
+  if (initNode === null) {
+    return null;
+  }
+
+  const initIndex = recNode.children.indexOf(initNode);
+  const afterInit = contentChildren(recNode, expression, initIndex + 1);
+  const lastPipeIndex = findLastPipeIndex(afterInit, expression);
+  if (lastPipeIndex < 0) {
+    return {
+      nodes: afterInit,
+      headerEndIndex: initIndex + 1
+    };
+  }
+
+  return {
+    nodes: afterInit.slice(lastPipeIndex + 1),
+    headerEndIndex: recNode.children.indexOf(afterInit[lastPipeIndex]) + 1
+  };
+}
+
+function contentChildren(generatorNode: AstNode, expression: string, fromIndex: number): AstNode[] {
+  return generatorNode.children.slice(fromIndex).filter(child => !isClosingBrace(child, expression));
+}
+
+function findDeclarativeDomain(declNode: AstNode, expression: string): AstNode | null {
+  const inIndex = declNode.children.findIndex(child => isTextToken(child, expression, '∈'));
+  if (inIndex < 0) {
+    return null;
+  }
+
+  for (let index = inIndex + 1; index < declNode.children.length; index++) {
+    const child = declNode.children[index];
+    if (isTextToken(child, expression, '|') || isClosingBrace(child, expression)) {
+      break;
+    }
+    if (child.typeID === Setexpr) {
+      return child;
+    }
+  }
+
+  return null;
+}
+
+function findImperativeTuple(impNode: AstNode): AstNode | null {
+  for (const child of impNode.children) {
+    if (child.typeID === Setexpr) {
+      return child;
+    }
+  }
+  return null;
+}
+
+function findLastPipeIndex(nodes: AstNode[], expression: string): number {
+  for (let index = nodes.length - 1; index >= 0; index--) {
+    if (isTextToken(nodes[index], expression, '|')) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+function generatorHeaderIsValid(generatorNode: AstNode, expression: string, headerEndIndex: number): boolean {
+  for (let index = 0; index < headerEndIndex; index++) {
+    const child = generatorNode.children[index];
+    if (child.typeID === TokenID.ERROR) {
+      return false;
+    }
+    if (isStructuralGeneratorToken(child, expression)) {
+      continue;
+    }
+    if (subtreeHasError(child)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isIncompleteDeclarativeBody(nodes: AstNode[]): boolean {
+  return isEmptyOrErrorOnlyBody(nodes);
+}
+
+function isIncompleteImperativeBody(slot: GeneratorBodySlot, expression: string): boolean {
+  if (slot.nodes.length === 0) {
+    return true;
+  }
+  if (slot.nodes.length === 1 && slot.nodes[0].typeID === Imp_blocks) {
+    return isImpBlocksIncomplete(slot.nodes[0], expression);
+  }
+  return isEmptyOrErrorOnlyBody(slot.nodes);
+}
+
+function isIncompleteRecursionBody(nodes: AstNode[]): boolean {
+  return isEmptyOrErrorOnlyBody(nodes);
+}
+
+function isEmptyOrErrorOnlyBody(nodes: AstNode[]): boolean {
+  if (nodes.length === 0) {
+    return true;
+  }
+  if (nodes.length === 1) {
+    return isErrorPlaceholder(nodes[0]);
+  }
+  return false;
+}
+
+function isImpBlocksIncomplete(blocksNode: AstNode, expression: string): boolean {
+  if (blocksNode.children.length === 0) {
+    return true;
+  }
+
+  const lastChild = blocksNode.children[blocksNode.children.length - 1];
+  if (lastChild.typeID === TokenID.ERROR) {
+    return true;
+  }
+  if (isTextToken(lastChild, expression, ';')) {
+    return true;
+  }
+  if (lastChild.typeID === Setexpr && isErrorPlaceholder(lastChild)) {
+    return true;
+  }
+
+  return false;
+}
+
+function isErrorInBodySlot(errorNode: AstNode, slot: GeneratorBodySlot, generatorNode: AstNode): boolean {
+  if (slot.nodes.length === 0) {
+    const bodyStart = generatorNode.children[slot.headerEndIndex]?.from ?? generatorNode.from;
+    return errorNode.from >= bodyStart;
+  }
+
+  for (const bodyNode of slot.nodes) {
+    if (errorNode === bodyNode || isDescendantOf(bodyNode, errorNode)) {
+      if (isErrorPlaceholder(bodyNode)) {
+        return true;
+      }
+      if (bodyNode.typeID === Imp_blocks && isImpBlocksTailError(bodyNode, errorNode)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function isImpBlocksTailError(blocksNode: AstNode, errorNode: AstNode): boolean {
+  const lastChild = blocksNode.children[blocksNode.children.length - 1];
+  return lastChild.typeID === TokenID.ERROR && (errorNode === lastChild || isDescendantOf(lastChild, errorNode));
+}
+
+function findRecursionInit(recursionNode: AstNode, expression: string): AstNode | null {
+  const assignIndex = recursionNode.children.findIndex(child => isTextToken(child, expression, ':='));
+  if (assignIndex < 0) {
+    return null;
+  }
+
+  for (let index = assignIndex + 1; index < recursionNode.children.length; index++) {
+    const child = recursionNode.children[index];
+    if (child.typeID === TokenID.ERROR) {
+      break;
+    }
+    if (isTextToken(child, expression, '|') || isClosingBrace(child, expression)) {
+      continue;
+    }
+    return child;
+  }
+
+  return null;
+}
+
+function isClosingBrace(node: AstNode, expression: string): boolean {
+  return node.typeID !== TokenID.ERROR && isTextToken(node, expression, '}');
+}
+
+function isStructuralGeneratorToken(node: AstNode, expression: string): boolean {
+  const text = expression.slice(node.from, node.to);
+  return text === '{' || text === '}' || text === '|' || text === '∈' || text === ':=' || text === ';';
+}

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

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