@rsconcept/domain 1.3.0 → 1.4.1

package/src/library/rsengine.ts

@@ -23,7 +23,6 @@ export interface RSEngineServices {
 export interface RSEngineNotifications {
   onInvalidSetValue: () => void;
   onCalculationSuccess: (timeSpent: string) => void;
-  onEvaluationError: (message: string) => void;
 }
 
 /** Calculation engine for {@link RSModel}. */
@@ -274,26 +273,12 @@ export class RSEngine {
 
   /** Evaluates expression for {@link RSEngine}. */
   public evaluateExpression(expression: string, cstType: CstType): CalculatorResult {
-    return getEvaluationFor(expression, cstType, this.schema!, this.calculator, message =>
-      this.notifications?.onEvaluationError(message)
-    );
+    return getEvaluationFor(expression, cstType, this.schema!, this.calculator);
   }
 
   /** Evaluates AST for {@link RSEngine}. */
   public evaluateAst(ast: AstNode, options?: CalculatorEvaluateOptions): CalculatorResult {
-    try {
-      const evaluation = this.calculator.evaluateFull(ast, options);
-      return evaluation;
-    } catch (error) {
-      this.notifications?.onEvaluationError((error as Error).message);
-      console.error(error);
-      return {
-        value: null,
-        iterations: 0,
-        cacheHits: 0,
-        errors: []
-      };
-    }
+    return this.calculator.evaluateFull(ast, options);
   }
 
   /** Calculates value for {@link Constituenta}. */
@@ -307,9 +292,7 @@ export class RSEngine {
       const predecessors = this.schema.graph.expandAllInputs([cstID]);
       this.prepareEvaluation(predecessors);
     }
-    const result = getEvaluationFor(cst.definition_formal, cst.cst_type, this.schema, this.calculator, message =>
-      this.notifications?.onEvaluationError(message)
-    );
+    const result = getEvaluationFor(cst.definition_formal, cst.cst_type, this.schema, this.calculator);
 
     if (result.value === null) {
       this.calculator.resetValue(cst.alias);
@@ -492,9 +475,7 @@ export class RSEngine {
       if (dependencies.includes(cstID)) {
         const cst = this.schema!.cstByID.get(cstID)!;
         if (isInferrable(cst.cst_type)) {
-          const value = fastEvaluation(cst.definition_formal, cst.cst_type, this.schema!, this.calculator, message =>
-            this.notifications?.onEvaluationError(message)
-          );
+          const value = fastEvaluation(cst.definition_formal, cst.cst_type, this.schema!, this.calculator);
           if (value !== null) {
             this.calculator.setValue(cst.alias, value);
           } else {
@@ -537,8 +518,7 @@ function getEvaluationFor(
   expression: string,
   cstType: CstType,
   schema: RSForm,
-  calculator: RSCalculator,
-  onEvaluationError?: (message: string) => void
+  calculator: RSCalculator
 ): CalculatorResult {
   const parse = getAnalysisFor(expression, cstType, schema);
   if (!parse.success || !parse.ast) {
@@ -548,46 +528,21 @@ function getEvaluationFor(
       cacheHits: 0,
       errors: parse.errors
     };
-  } else {
-    try {
-      const result = calculator.evaluateFull(parse.ast);
-      return {
-        value: result.value,
-        iterations: result.iterations,
-        cacheHits: result.cacheHits,
-        errors: [...parse.errors, ...result.errors]
-      };
-    } catch (error) {
-      onEvaluationError?.((error as Error).message);
-      console.error(expression, error);
-      return {
-        value: null,
-        iterations: 0,
-        cacheHits: 0,
-        errors: []
-      };
-    }
   }
+  const result = calculator.evaluateFull(parse.ast);
+  return {
+    value: result.value,
+    iterations: result.iterations,
+    cacheHits: result.cacheHits,
+    errors: [...parse.errors, ...result.errors]
+  };
 }
 
 /** Evaluates expression for {@link RSModel}. */
-function fastEvaluation(
-  expression: string,
-  cstType: CstType,
-  schema: RSForm,
-  calculator: RSCalculator,
-  onEvaluationError?: (message: string) => void
-): Value | null {
+function fastEvaluation(expression: string, cstType: CstType, schema: RSForm, calculator: RSCalculator): Value | null {
   const parse = getAnalysisFor(expression, cstType, schema);
   if (!parse.success || !parse.ast) {
     return null;
-  } else {
-    try {
-      return calculator.evaluateFast(parse.ast);
-    } catch (error) {
-      onEvaluationError?.((error as Error).message);
-      console.error(expression, error);
-      return null;
-    }
   }
+  return calculator.evaluateFast(parse.ast);
 }

package/src/rslang/error.ts

@@ -84,6 +84,7 @@ export const RSErrorCode = {
   calcInvalidDebool: 0x8105, // 35333
   iterateInfinity: 0x8106, // 35334
   calculationNotSupported: 0x8107, // 35335
+  calcInvalidData: 0x8108, // 35336
 
   cstEmptyDerived: 0x8861, // 34913
   definitionNotAllowed: 0x8862 // 34914

package/src/rslang/eval/calculator.test.ts

@@ -73,6 +73,14 @@ describe('RSCalculator', () => {
     expectCalcFull('X11', { expectErrorCode: RSErrorCode.calcGlobalMissing });
   });
 
+  it('returns error for undeclared local variable', () => {
+    expectCalcFull('∀a∈X1 b=b', { expectErrorCode: RSErrorCode.localUndeclared });
+  });
+
+  it('returns error for incompatible value comparison', () => {
+    expectCalcFull('X1=1', { expectErrorCode: RSErrorCode.calcInvalidData });
+  });
+
   it('returns error for infinite quantifier', () => {
     expectCalcFull('∀a∈Z a=a', { expectErrorCode: RSErrorCode.iterateInfinity });
   });

package/src/rslang/eval/evaluator.test.ts

@@ -192,6 +192,7 @@ const correctValuesData = [
 const errorData = [
   ['[a∈ℬ(R1)] a=a', { code: RSErrorCode.calculationNotSupported, from: 0, to: 13 }],
   ['debool(X1)', { code: RSErrorCode.calcInvalidDebool, from: 7, to: 9 }],
+  ['Pr1(1)', { code: RSErrorCode.calcUnknownError, from: 0, to: 6 }],
   ['∀a∈Z a=a', { code: RSErrorCode.iterateInfinity, from: 3, to: 4 }],
   ['ℬℬ({1,2,3,4,5})', { code: RSErrorCode.booleanBaseLimit, from: 1, to: 15, params: [String(BOOL_INFINITY)] }],
   ['X1\\D1', { code: RSErrorCode.calcGlobalMissing, from: 3, to: 5, params: ['D1'] }],
@@ -227,7 +228,10 @@ const errorData = [
   ['R{a:=X1 | D1=D1 | a∪X1}', { code: RSErrorCode.calcGlobalMissing, from: 10, to: 12, params: ['D1'] }],
   ['I{(a,b) | a:∈D1; b:=a; b≠a}', { code: RSErrorCode.calcGlobalMissing, from: 13, to: 15, params: ['D1'] }],
   ['I{(a,b) | a:∈X1; b:=a; b≠D1}', { code: RSErrorCode.calcGlobalMissing, from: 25, to: 27, params: ['D1'] }],
-  ['I{(a,b) | a:∈X1; b:=D1; b≠a}', { code: RSErrorCode.calcGlobalMissing, from: 20, to: 22, params: ['D1'] }]
+  ['I{(a,b) | a:∈X1; b:=D1; b≠a}', { code: RSErrorCode.calcGlobalMissing, from: 20, to: 22, params: ['D1'] }],
+  ['∀a∈X1 b=b', { code: RSErrorCode.localUndeclared, from: 6, to: 7, params: ['b'] }],
+  ['X1=1', { code: RSErrorCode.calcInvalidData, from: 0, to: 4, params: ['{1, 2, 3}', '1'] }],
+  ['X1=1 & 1=1', { code: RSErrorCode.calcInvalidData, from: 0, to: 4, params: ['{1, 2, 3}', '1'] }]
 ];
 
 describe('Calculator', () => {

package/src/rslang/eval/evaluator.ts

@@ -10,6 +10,7 @@ import { TokenID } from '../parser/token';
 import { EvaluationCache, EvaluationMetadata } from './evaluation-cache';
 import {
   BOOL_INFINITY,
+  CalcInvalidDataError,
   compare,
   EmptySetV,
   set,
@@ -153,11 +154,19 @@ export class Evaluator {
       }
     }
 
-    const result = this.dispatchVisitImpl(node);
-    if (!this.disableCache && result !== null && info.cacheable && stamp !== null) {
-      this.evalCache.store(info.structuralKey, stamp, result);
+    try {
+      const result = this.dispatchVisitImpl(node);
+      if (!this.disableCache && result !== null && info.cacheable && stamp !== null) {
+        this.evalCache.store(info.structuralKey, stamp, result);
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof CalcInvalidDataError) {
+        return this.onError(RSErrorCode.calcInvalidData, node, [error.left, error.right]);
+      }
+      this.onError(RSErrorCode.calcUnknownError, node);
+      return null;
     }
-    return result;
   }
 
   private dispatchVisitImpl(node: AstNode): Value | null {
@@ -280,8 +289,8 @@ export class Evaluator {
 
   private visitGlobal(node: AstNode): Value | null {
     const alias = getNodeText(node);
-    const value = this.context.get(alias);
-    if (value === undefined) {
+    const value = this.context.get(alias) ?? null;
+    if (value === null) {
       return this.onError(RSErrorCode.calcGlobalMissing, node, [alias]);
     }
     return value;
@@ -289,7 +298,11 @@ export class Evaluator {
 
   private visitLocal(node: AstNode): Value | null {
     const alias = getNodeText(node);
-    return this.locals.getLocal(alias);
+    const value = this.locals.findLocal(alias);
+    if (value === null) {
+      return this.onError(RSErrorCode.localUndeclared, node, [alias]);
+    }
+    return value;
   }
 
   private visitFunctionCall(node: AstNode): Value | null {
@@ -910,12 +923,8 @@ class LocalContext {
     }
   }
 
-  getLocal(alias: string): Value {
-    const binding = this.data.get(alias);
-    if (binding === undefined) {
-      throw new Error(`Local variable "${alias}" not found`);
-    }
-    return binding.value;
+  findLocal(alias: string): Value | null {
+    return this.data.get(alias)?.value ?? null;
   }
 
   buildDependencyStamp(reads: ReadonlySet<string>): string | null {

package/src/rslang/eval/value.ts

@@ -41,6 +41,19 @@ export function makeValuePath(path: number[]): ValuePath {
 /** Empty set ∅. */
 export const EmptySetV = [];
 
+/** Thrown when a runtime value operation cannot be applied to the given operands. */
+export class CalcInvalidDataError extends Error {
+  readonly left: string;
+  readonly right: string;
+
+  constructor(left: string, right: string) {
+    super(`Cannot compare different types ${left} and ${right}`);
+    this.name = 'CalcInvalidDataError';
+    this.left = left;
+    this.right = right;
+  }
+}
+
 /** Compare two structured data without recursive calls. */
 export function compare(v1: Value, v2: Value): number {
   const stack1: Value[] = [v1];
@@ -64,7 +77,7 @@ export function compare(v1: Value, v2: Value): number {
     const isArray1 = Array.isArray(el1);
     const isArray2 = Array.isArray(el2);
     if (!isArray1 || !isArray2) {
-      throw new Error(`Cannot compare different types ${printValue(el1!)} and ${printValue(el2!)}`);
+      throw new CalcInvalidDataError(printValue(el1!), printValue(el2!));
     }
 
     const arr1 = el1;