@rsconcept/domain 1.0.0

package/src/rslang/parser/rslang.grammar

@@ -0,0 +1,251 @@
+///////////////////////////////////////////////////////////
+// ------------- Generator Definitions --------------------
+///////////////////////////////////////////////////////////
+@detectDelim
+
+///////////////////////////////////////////////////////////
+// ------------- Precedence Definitions --------------------
+///////////////////////////////////////////////////////////
+@precedence {
+  decl @cut,
+  set_bool @right,
+  times @left,
+  plus @left minus @left,
+  set_decart @left set_union @left set_intersect @left set_minus @left set_symminus @left,
+  expr_pred @left,
+  not @right,
+  quant @right,
+  log_and @left,
+  log_or @left,
+  log_impl @left,
+  log_equiv @left
+}
+
+///////////////////////////////////////////////////////////
+// ------------- Terminal Tokens --------------------------
+///////////////////////////////////////////////////////////
+@tokens {
+  space             { @whitespace+ }
+  Integer           { $[0-9]+ }
+  EmptySet          { "∅" }
+  IntegerSet        { "Z" }
+
+  BigPr             { "Pr"$[1-9]$[0-9]*(","$[1-9]$[0-9]*)* }
+  SmallPr           { "pr"$[1-9]$[0-9]*(","$[1-9]$[0-9]*)* }
+  Filter            { "Fi"$[1-9]$[0-9]*(","$[1-9]$[0-9]*)* }
+  Card              { "card" }
+  Bool              { "bool" }
+  Debool            { "debool" }
+  Red               { "red" }
+
+  Global            { $[XCSDATN]$[0-9]+ }
+  Function          { "F"$[0-9]+ }
+  Predicate         { "P"$[0-9]+ }
+  Radical           { "R"$[0-9]+ }
+  Local             { $[_a-zα-ω]($[a-zα-ω])*$[0-9]* }
+  PrefixR           { "R" }
+  PrefixI           { "I" }
+  PrefixD           { "D" }
+
+  "¬"
+  "∀" "∃" "⇔" "⇒" "∨" "&"
+  "ℬ"
+  "+" "-" "*" "∪" "\\" "∆" "∩" "×"
+  "∈" "∉" "⊆" "⊄" "⊂" ">" "≥" "≤" "<" "≠" "="
+  ":∈" ":="
+  
+  "," ";" "|"
+  "[" "]"
+  "{" "}"
+  "(" ")"
+  
+  @precedence {
+    Filter
+    BigPr
+    Predicate
+    Function
+    Global
+    Radical
+    PrefixR
+    PrefixI
+    PrefixD
+  }
+  @precedence {
+    Card
+    Bool
+    Debool
+    Red
+    SmallPr
+    Local
+  }
+}
+
+@skip { space }
+
+
+///////////////////////////////////////////////////////////////////////////////
+// ------------------------- Grammar Rules ------------------------------------
+///////////////////////////////////////////////////////////////////////////////
+
+// ------------------------- Language Expression ------------------------------
+@top Expression {
+  expr_atom |
+  Function_decl
+}
+
+expr_atom	{
+  Logic |
+  Setexpr
+}
+
+Function_decl {
+  "[" Arguments "]" expr_atom
+}
+
+
+// -------------------------  Variables and arguments -------------------------
+Arguments {
+  Declaration |
+  Arguments "," Declaration
+}
+Declaration {
+  Variable "∈" expr_atom
+}
+Variable {
+  Local |
+  Tuple
+}
+Variable_pack {
+  Variable |
+  Variable_pack "," Variable
+}
+
+
+// ------------------------- Logic Expressions --------------------------------
+Logic {
+  Logic_predicates |
+  Logic_unary |
+  Logic_binary |
+  "(" Logic ")"
+}
+
+Logic_predicates {
+  Variable ":∈" expr_atom |
+  Variable ":=" expr_atom |
+  expr_atom !expr_pred "∈" expr_atom |
+  expr_atom !expr_pred "∉" expr_atom |
+  expr_atom !expr_pred "⊆" expr_atom |
+  expr_atom !expr_pred "⊄" expr_atom |
+  expr_atom !expr_pred "⊂" expr_atom |
+  expr_atom !expr_pred ">" expr_atom |
+  expr_atom !expr_pred "≥" expr_atom |
+  expr_atom !expr_pred "<" expr_atom |
+  expr_atom !expr_pred "≤" expr_atom |
+  expr_atom !expr_pred "≠" expr_atom |
+  expr_atom !expr_pred "=" expr_atom
+}
+
+Logic_unary {
+  !not "¬" expr_atom |
+  Predicate "[" expr_enum "]" |
+  Logic_quantor
+}
+
+Logic_quantor {
+  "∀" Variable_pack "∈" expr_atom !quant expr_atom |
+  "∃" Variable_pack "∈" expr_atom !quant expr_atom
+}
+
+Logic_binary {
+  expr_atom !log_equiv "⇔" expr_atom |
+  expr_atom !log_impl "⇒" expr_atom |
+  expr_atom !log_or "∨" expr_atom |
+  expr_atom !log_and "&" expr_atom
+}
+
+
+// ------------------------- Set Expressions ----------------------------------
+Setexpr {
+  literal |
+  identifier |
+  Setexpr_binary |
+  setexpr_generators |
+  Function "[" expr_enum "]" |
+  textFunction "(" expr_atom ")"
+}
+textFunction {
+  BigPr |
+  SmallPr |
+  Card |
+  Bool |
+  Debool |
+  Red
+}
+expr_enum {
+  expr_atom |
+  Expr_enum_min2
+}
+Expr_enum_min2 {
+  expr_enum "," expr_atom
+}
+
+literal {
+  Integer |
+  EmptySet |
+  IntegerSet
+}
+identifier {
+  Local ~local_decl |
+  Global |
+  Radical
+}
+
+Setexpr_binary {
+  expr_atom !times "*" expr_atom |
+  expr_atom !plus "+" expr_atom |
+  expr_atom !minus "-" expr_atom |
+  expr_atom !set_union "∪" expr_atom |
+  expr_atom !set_minus "\\" expr_atom |
+  expr_atom !set_symminus "∆" expr_atom |
+  expr_atom !set_intersect "∩" expr_atom |
+  expr_atom !set_decart "×" expr_atom |
+  "(" Setexpr_binary ")"
+}
+
+setexpr_generators {
+  Enumeration |
+  Tuple |
+  Boolean |
+  Filter_expression |
+  Declarative |
+  Imperative |
+  Recursion
+}
+Enumeration {
+  "{" expr_enum "}"
+}
+Tuple {
+  "(" Expr_enum_min2 ")"
+}
+Boolean {
+  !set_bool "ℬ" "(" expr_atom ")" |
+  !set_bool "ℬ" Boolean
+}
+Filter_expression {
+  Filter "[" expr_enum "]" "(" expr_atom ")"
+}
+
+Declarative {
+  "{" Local ~local_decl "∈" expr_atom "|" expr_atom "}" |
+  PrefixD "{" Variable "∈" expr_atom "|" expr_atom "}"
+}
+Recursion {
+  PrefixR "{" Variable ":=" expr_atom ("|" expr_atom)? "|" expr_atom "}"
+}
+Imperative {
+  PrefixI "{" expr_atom "|" Imp_blocks "}"
+}
+Imp_blocks {
+  expr_atom |
+  Imp_blocks ";" expr_atom
+}

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

@@ -0,0 +1,209 @@
+/**
+ * Module: Syntactic errors reporting.
+ */
+
+import { type AstNode, visitAstDFS } from '../../parsing';
+import { annotateError } from '../ast-annotations';
+import { type ErrorReporter, RSErrorCode, type RSErrorDescription } from '../error';
+
+import { Variable } from './parser.terms';
+import { TokenID } from './token';
+
+export function extractSyntaxErrors(
+  ast: AstNode,
+  expression: string,
+  reporter: ErrorReporter,
+  annotateErrors: boolean = 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));
+}
+
+// ====== Internals =========
+function extractInternal(
+  node: AstNode,
+  reporter: ErrorReporter,
+  annotateErrors: boolean,
+  ignoreUnknownErrors: boolean
+) {
+  if (node.typeID !== TokenID.ERROR) {
+    return;
+  }
+
+  function emit(target: AstNode, code: RSErrorCode) {
+    reporter({ code: 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);
+  }
+}
+
+type OpenBracket = '(' | '[' | '{';
+type CloseBracket = ')' | ']' | '}';
+
+interface BracketFrame {
+  bracket: OpenBracket;
+  index: number;
+}
+
+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: [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;
+}
+
+function missingBracketCode(bracket: OpenBracket): RSErrorCode {
+  switch (bracket) {
+    case '(':
+      return RSErrorCode.missingParenthesis;
+    case '[':
+      return RSErrorCode.missingSquareBracket;
+    case '{':
+      return RSErrorCode.missingCurlyBrace;
+  }
+}
+
+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 = findMatchingCloseBracket(expression, pos);
+  const innerClose = findMatchingCloseBracket(expression, pos + 1);
+  if (outerClose < 0 || innerClose < 0) {
+    return false;
+  }
+
+  return outerClose === innerClose + 1;
+}
+
+function findMatchingCloseBracket(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/token.ts

@@ -0,0 +1,106 @@
+import { TOKEN_ERROR } from '../../parsing';
+
+/** Represents RSLang token types. */
+export const 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
+} as const;
+export type TokenID = (typeof TokenID)[keyof typeof TokenID];

package/src/rslang/semantic/analyzer.test.ts

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { RSErrorCode, type RSErrorDescription } from '../error';
+import { labelType } from '../labels';
+
+import { type AnalysisOptions, RSLangAnalyzer } from './analyzer';
+import { basic, bool, tuple, TypeClass } from './typification';
+import { ValueClass } from './value-class';
+
+describe('RSLang analyzer', () => {
+  let analyzer: RSLangAnalyzer;
+
+  function expectError(input: string, options: AnalysisOptions, expectedError: RSErrorDescription) {
+    const result = analyzer.checkFull(input, options);
+    expect(result.success).toBe(false);
+    expect(result.errors.length).toBe(1);
+    expect(result.errors[0]).toMatchObject(expectedError);
+  }
+
+  beforeEach(() => {
+    analyzer = new RSLangAnalyzer();
+    analyzer.addBase('X1');
+    analyzer.addBase('C1', true);
+    analyzer.setGlobal('S1', bool(tuple([basic('X1'), basic('X1')])), ValueClass.VALUE);
+    analyzer.setGlobal('D1', bool(basic('X1')), ValueClass.PROPERTY);
+  });
+
+  it('Empty expression', () => {
+    const result = analyzer.checkFull('');
+    expect(result.success).toBe(false);
+    expect(result.type).toBe(null);
+    expect(result.valueClass).toBe(null);
+    expect(result.errors.length).toBe(1);
+    expect(result.errors[0]).toMatchObject({ code: RSErrorCode.cstEmptyDerived, from: 0, to: 0 });
+  });
+
+  it('Domain', () => {
+    const result = analyzer.checkFull('ℬ(X1)', { isDomain: true });
+    expect(result.success).toBe(true);
+    expect(labelType(result.type)).toBe('ℬ(X1)');
+    expect(result.valueClass).toBe(ValueClass.VALUE);
+    expect(result.errors.length).toBe(0);
+
+    expectError('X1∩X1', { isDomain: true }, { code: RSErrorCode.globalStructure, from: 0, to: 5 });
+  });
+
+  it('Expected type', () => {
+    expectError('X1', { expected: TypeClass.logic }, { code: RSErrorCode.expectedType, from: 0, to: 2 });
+    expectError('1=1', { expected: TypeClass.typification }, { code: RSErrorCode.expectedType, from: 0, to: 3 });
+    expectError('1=1', { expected: TypeClass.function }, { code: RSErrorCode.expectedType, from: 0, to: 3 });
+    expectError('[a ∈ X1] a=a', { expected: TypeClass.function }, { code: RSErrorCode.expectedType, from: 0, to: 12 });
+    expectError('[a ∈ X1] a', { expected: TypeClass.predicate }, { code: RSErrorCode.expectedType, from: 0, to: 10 });
+  });
+
+  it('Reports analyzer-level ranges for whole-expression errors', () => {
+    const result = analyzer.checkFull('X1', { expected: TypeClass.logic });
+    expect(result.errors[0]).toMatchObject({ code: RSErrorCode.expectedType, from: 0, to: 2 });
+  });
+});