@rsconcept/domain 1.4.1 → 1.4.3

package/src/rslang/eval/evaluator.ts

@@ -5,6 +5,7 @@
 import { type AstNode, getNodeIndices, getNodeText } from '../../parsing';
 import { annotateError } from '../ast-annotations';
 import { type ErrorReporter, RSErrorCode } from '../error';
+import { labelRSLangNode } from '../labels';
 import { TokenID } from '../parser/token';
 
 import { EvaluationCache, EvaluationMetadata } from './evaluation-cache';
@@ -162,7 +163,7 @@ export class Evaluator {
       return result;
     } catch (error) {
       if (error instanceof CalcInvalidDataError) {
-        return this.onError(RSErrorCode.calcInvalidData, node, [error.left, error.right]);
+        return this.onError(RSErrorCode.calcInvalidData, node, [error.left, error.right, labelRSLangNode(node)]);
       }
       this.onError(RSErrorCode.calcUnknownError, node);
       return null;

package/src/rslang/labels.ts

@@ -38,6 +38,7 @@ const labelTokenRecord: Partial<Record<TokenID, string>> = {
   [TokenID.NT_DECLARATIVE_EXPR]: 'D{}',
   [TokenID.NT_IMPERATIVE_EXPR]: 'I{}',
   [TokenID.NT_RECURSIVE_FULL]: 'R{}',
+  [TokenID.NT_RECURSIVE_SHORT]: 'R{}',
   [TokenID.BIGPR]: 'Pr1()',
   [TokenID.SMALLPR]: 'pr1()',
   [TokenID.FILTER]: 'Fi1[]()',

package/src/rslang/semantic/type-auditor.test.ts

@@ -170,14 +170,14 @@ const errorData = [
   ['card(S3)', { code: RSErrorCode.invalidCard, from: 5, to: 7, params: ['C1'] }],
   ['card(1)', { code: RSErrorCode.invalidCard, from: 5, to: 6, params: ['Z'] }],
   ['card((1,2))', { code: RSErrorCode.invalidCard, from: 5, to: 10, params: ['Z×Z'] }],
-  ['debool(X1)+1', { code: RSErrorCode.arithmeticNotSupported, from: 0, to: 10, params: ['X1'] }],
-  ['1+debool(X1)', { code: RSErrorCode.arithmeticNotSupported, from: 2, to: 12, params: ['X1'] }],
+  ['debool(X1)+1', { code: RSErrorCode.arithmeticNotSupported, from: 0, to: 10, params: ['X1', '+'] }],
+  ['1+debool(X1)', { code: RSErrorCode.arithmeticNotSupported, from: 2, to: 12, params: ['X1', '+'] }],
   // Logical
-  ['debool(X1)<1', { code: RSErrorCode.orderingNotSupported, from: 0, to: 10, params: ['X1'] }],
-  ['1<debool(X1)', { code: RSErrorCode.orderingNotSupported, from: 2, to: 12, params: ['X1'] }],
-  ['debool(X1)=1', { code: RSErrorCode.typesNotCompatible, from: 0, to: 12, params: ['X1', 'Z'] }],
-  ['1=debool(X1)', { code: RSErrorCode.typesNotCompatible, from: 0, to: 12, params: ['Z', 'X1'] }],
-  ['S1=S2', { code: RSErrorCode.typesNotCompatible, from: 0, to: 5, params: ['ℬ(X1×X1)', 'ℬℬ(X1)'] }],
+  ['debool(X1)<1', { code: RSErrorCode.orderingNotSupported, from: 0, to: 10, params: ['X1', '<'] }],
+  ['1<debool(X1)', { code: RSErrorCode.orderingNotSupported, from: 2, to: 12, params: ['X1', '<'] }],
+  ['debool(X1)=1', { code: RSErrorCode.typesNotCompatible, from: 0, to: 12, params: ['X1', 'Z', '='] }],
+  ['1=debool(X1)', { code: RSErrorCode.typesNotCompatible, from: 0, to: 12, params: ['Z', 'X1', '='] }],
+  ['S1=S2', { code: RSErrorCode.typesNotCompatible, from: 0, to: 5, params: ['ℬ(X1×X1)', 'ℬℬ(X1)', '='] }],
   ['∀a,a∈X1 a=a', { code: RSErrorCode.localShadowing, from: 3, to: 4, params: ['a'] }],
   ['∀(a,a)∈S1 a=a', { code: RSErrorCode.localShadowing, from: 4, to: 5, params: ['a'] }],
   ['∀(a,b)∈X1 a=b', { code: RSErrorCode.invalidCortegeDeclare, from: 2, to: 3 }],
@@ -190,9 +190,9 @@ const errorData = [
   ['(1,2)∈Z', { code: RSErrorCode.invalidElementPredicate, from: 0, to: 7, params: ['Z×Z', '∈', 'ℬ(Z)'] }],
   ['{1}∈Z', { code: RSErrorCode.invalidElementPredicate, from: 0, to: 5, params: ['ℬ(Z)', '∈', 'ℬ(Z)'] }],
   ['{1}∉Z', { code: RSErrorCode.invalidElementPredicate, from: 0, to: 5, params: ['ℬ(Z)', '∉', 'ℬ(Z)'] }],
-  ['X1⊆S2', { code: RSErrorCode.typesNotEqual, from: 0, to: 5, params: ['ℬ(X1)', 'ℬℬ(X1)'] }],
-  ['X1⊄S2', { code: RSErrorCode.typesNotEqual, from: 0, to: 5, params: ['ℬ(X1)', 'ℬℬ(X1)'] }],
-  ['X1⊂S2', { code: RSErrorCode.typesNotEqual, from: 0, to: 5, params: ['ℬ(X1)', 'ℬℬ(X1)'] }],
+  ['X1⊆S2', { code: RSErrorCode.typesNotEqual, from: 0, to: 5, params: ['ℬ(X1)', 'ℬℬ(X1)', '⊆'] }],
+  ['X1⊄S2', { code: RSErrorCode.typesNotEqual, from: 0, to: 5, params: ['ℬ(X1)', 'ℬℬ(X1)', '⊄'] }],
+  ['X1⊂S2', { code: RSErrorCode.typesNotEqual, from: 0, to: 5, params: ['ℬ(X1)', 'ℬℬ(X1)', '⊂'] }],
   // Constructors
   ['ℬ(S3)', { code: RSErrorCode.invalidBoolean, from: 2, to: 4, params: ['C1'] }],
   ['ℬ((1,2))', { code: RSErrorCode.invalidBoolean, from: 2, to: 7, params: ['Z×Z'] }],
@@ -202,15 +202,15 @@ const errorData = [
   ['{1, X1}', { code: RSErrorCode.invalidEnumeration, from: 4, to: 6, params: ['Z', 'ℬ(X1)'] }],
   ['{X1, 1}', { code: RSErrorCode.invalidEnumeration, from: 5, to: 6, params: ['ℬ(X1)', 'Z'] }],
   ['{(1,2), (X1,X1)}', { code: RSErrorCode.invalidEnumeration, from: 8, to: 15, params: ['Z×Z', 'ℬ(X1)×ℬ(X1)'] }],
-  ['R{a := S1 | {a}}', { code: RSErrorCode.typesNotEqual, from: 12, to: 15, params: ['ℬℬ(X1×X1)', 'ℬ(X1×X1)'] }],
+  ['R{a := S1 | {a}}', { code: RSErrorCode.typesNotEqual, from: 12, to: 15, params: ['ℬℬ(X1×X1)', 'ℬ(X1×X1)', 'R{}'] }],
   [
     'I{(a, b) | a:∈X1; b:={a}; a≠b}',
-    { code: RSErrorCode.typesNotCompatible, from: 26, to: 29, params: ['X1', 'ℬ(X1)'] }
+    { code: RSErrorCode.typesNotCompatible, from: 26, to: 29, params: ['X1', 'ℬ(X1)', '≠'] }
   ],
   // Set operations
   ['X1 ∪ ∅', { code: RSErrorCode.invalidEmptySetUsage, from: 5, to: 6 }],
-  ['X1 ∪ S1', { code: RSErrorCode.typesNotEqual, from: 0, to: 7, params: ['ℬ(X1)', 'ℬ(X1×X1)'] }],
-  ['S1 ∪ X1', { code: RSErrorCode.typesNotEqual, from: 0, to: 7, params: ['ℬ(X1×X1)', 'ℬ(X1)'] }],
+  ['X1 ∪ S1', { code: RSErrorCode.typesNotEqual, from: 0, to: 7, params: ['ℬ(X1)', 'ℬ(X1×X1)', '∪'] }],
+  ['S1 ∪ X1', { code: RSErrorCode.typesNotEqual, from: 0, to: 7, params: ['ℬ(X1×X1)', 'ℬ(X1)', '∪'] }],
   ['Pr1(X1)', { code: RSErrorCode.invalidProjectionSet, from: 4, to: 6, params: ['Pr1', 'ℬ(X1)'] }],
   ['Pr3(S1)', { code: RSErrorCode.invalidProjectionSet, from: 4, to: 6, params: ['Pr3', 'ℬ(X1×X1)'] }],
   ['Pr1,3(S1)', { code: RSErrorCode.invalidProjectionSet, from: 6, to: 8, params: ['Pr1,3', 'ℬ(X1×X1)'] }],
@@ -219,11 +219,11 @@ const errorData = [
   ['pr1(debool(X1))', { code: RSErrorCode.invalidProjectionTuple, from: 4, to: 14, params: ['pr1', 'X1'] }],
   ['pr3(debool(S1))', { code: RSErrorCode.invalidProjectionTuple, from: 4, to: 14, params: ['pr3', 'X1×X1'] }],
   ['Fi1[X1](ℬ(X1))', { code: RSErrorCode.invalidFilterArgumentType, from: 8, to: 13, params: ['Fi1', 'ℬℬ(X1)'] }],
-  ['Fi1[1](S1)', { code: RSErrorCode.typesNotEqual, from: 4, to: 5, params: ['Z', 'ℬ(X1)'] }],
-  ['Fi1[X1](ℬ(X1)×X1)', { code: RSErrorCode.typesNotEqual, from: 4, to: 6, params: ['ℬ(X1)', 'ℬℬ(X1)'] }],
+  ['Fi1[1](S1)', { code: RSErrorCode.typesNotEqual, from: 4, to: 5, params: ['Z', 'ℬ(X1)', 'Fi1'] }],
+  ['Fi1[X1](ℬ(X1)×X1)', { code: RSErrorCode.typesNotEqual, from: 4, to: 6, params: ['ℬ(X1)', 'ℬℬ(X1)', 'Fi1'] }],
   ['Fi3[X1](S1)', { code: RSErrorCode.invalidFilterArgumentType, from: 8, to: 10, params: ['Fi3', 'ℬ(X1×X1)'] }],
   ['Fi1[X1,X1](S1)', { code: RSErrorCode.invalidFilterArity, from: 0, to: 14 }],
-  ['Fi1,2[X1](S1)', { code: RSErrorCode.typesNotEqual, from: 6, to: 8, params: ['ℬ(X1)', 'ℬ(X1×X1)'] }],
+  ['Fi1,2[X1](S1)', { code: RSErrorCode.typesNotEqual, from: 6, to: 8, params: ['ℬ(X1)', 'ℬ(X1×X1)', 'Fi1,2'] }],
   ['red(X1)', { code: RSErrorCode.invalidReduce, from: 4, to: 6, params: ['ℬ(X1)'] }],
   ['debool(S3)', { code: RSErrorCode.invalidDebool, from: 7, to: 9, params: ['C1'] }],
   // Locals
@@ -236,7 +236,9 @@ const errorData = [
   // Logic vs setexpr discrimination
   ['D{α∈X1|F1[X1,X1]}', { code: RSErrorCode.expectedLogic, from: 7, to: 16, params: ['ℬ(X1)'] }],
   ['F1[1=1,X1]', { code: RSErrorCode.expectedSetexpr, from: 3, to: 6, params: ['Logic'] }],
-  ['∀a∈(1=1) a=a', { code: RSErrorCode.expectedSetexpr, from: 3, to: 8, params: ['Logic'] }],
+  ['∀a∈(1=1) a=a', { code: RSErrorCode.invalidQuantifierDomain, from: 3, to: 8, params: ['∀', 'Logic'] }],
+  ['∀a∈Z a=a', { code: RSErrorCode.invalidQuantifierDomain, from: 3, to: 4, params: ['∀', 'Z'] }],
+  ['∃a∈Z a=a', { code: RSErrorCode.invalidQuantifierDomain, from: 3, to: 4, params: ['∃', 'Z'] }],
   ['∀a∈X1 F1[{a},X1]', { code: RSErrorCode.expectedLogic, from: 6, to: 16, params: ['ℬ(X1)'] }],
   ['(1=1)∪X1', { code: RSErrorCode.expectedSetexpr, from: 0, to: 5, params: ['Logic'] }],
   ['X1 & 1=1', { code: RSErrorCode.expectedLogic, from: 0, to: 2, params: ['ℬ(X1)'] }],

package/src/rslang/semantic/type-auditor.ts

@@ -298,7 +298,12 @@ export class TypeAuditor {
     return true;
   }
 
-  private childTypeDebool(node: AstNode, index: number, errorCode: RSErrorCode): Typification | null {
+  private childTypeDebool(
+    node: AstNode,
+    index: number,
+    errorCode: RSErrorCode,
+    operation?: string
+  ): Typification | null {
     const result = this.childTypification(node, index);
     if (result === null) {
       return null;
@@ -307,7 +312,30 @@ export class TypeAuditor {
       return result;
     }
     if (result.typeID !== TypeID.collection) {
-      this.onError(errorCode, node.children[index], [labelType(result)]);
+      const params =
+        errorCode === RSErrorCode.invalidTypeOperation && operation !== undefined
+          ? [operation, labelType(result)]
+          : [labelType(result)];
+      this.onError(errorCode, node.children[index], params);
+      return null;
+    }
+    return debool(result);
+  }
+
+  private childQuantifierDomain(node: AstNode, index: number, operator: string): Typification | null {
+    const result = this.visitChild(node, index);
+    if (result === null) {
+      return null;
+    }
+    if (!isTypification(result)) {
+      this.onError(RSErrorCode.invalidQuantifierDomain, node.children[index], [operator, labelType(result)]);
+      return null;
+    }
+    if (result.typeID === TypeID.anyTypification) {
+      return result;
+    }
+    if (result.typeID !== TypeID.collection) {
+      this.onError(RSErrorCode.invalidQuantifierDomain, node.children[index], [operator, labelType(result)]);
       return null;
     }
     return debool(result);
@@ -415,7 +443,7 @@ export class TypeAuditor {
     if (variable.typeID === TokenID.NT_TUPLE_DECL) {
       return this.onError(RSErrorCode.invalidArgumentCortegeDeclare, variable);
     }
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation, labelToken(TokenID.ITERATE));
     if (domain === null) {
       return null;
     }
@@ -433,12 +461,13 @@ export class TypeAuditor {
   }
 
   private visitArithmetic(node: AstNode): ExpressionType | null {
+    const operator = labelRSLangNode(node);
     const type1 = this.childTypification(node, 0);
     if (type1 === null) {
       return null;
     }
     if (!('isArithmetic' in type1 && type1.isArithmetic)) {
-      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[0], [labelType(type1)]);
+      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[0], [labelType(type1), operator]);
     }
 
     const type2 = this.childTypification(node, 1);
@@ -446,23 +475,24 @@ export class TypeAuditor {
       return null;
     }
     if (!('isArithmetic' in type2 && type2.isArithmetic)) {
-      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[1], [labelType(type2)]);
+      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[1], [labelType(type2), operator]);
     }
 
     const result = mergeTypifications(type1, type2);
     if (result === null) {
-      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
+      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2), operator]);
     }
     return result;
   }
 
   private visitIntegerPredicate(node: AstNode): ExpressionType | null {
+    const operator = labelRSLangNode(node);
     const type1 = this.childTypification(node, 0);
     if (type1 === null) {
       return null;
     }
     if (!('isOrdered' in type1 && type1.isOrdered)) {
-      return this.onError(RSErrorCode.orderingNotSupported, node.children[0], [labelType(type1)]);
+      return this.onError(RSErrorCode.orderingNotSupported, node.children[0], [labelType(type1), operator]);
     }
 
     const type2 = this.childTypification(node, 1);
@@ -470,11 +500,11 @@ export class TypeAuditor {
       return null;
     }
     if (!('isOrdered' in type2 && type2.isOrdered)) {
-      return this.onError(RSErrorCode.orderingNotSupported, node.children[1], [labelType(type2)]);
+      return this.onError(RSErrorCode.orderingNotSupported, node.children[1], [labelType(type2), operator]);
     }
 
     if (!checkCompatibility(type1, type2)) {
-      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
+      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2), operator]);
     }
     return LogicT;
   }
@@ -482,7 +512,8 @@ export class TypeAuditor {
   private visitQuantifier(node: AstNode): ExpressionType | null {
     this.locals.startScope();
 
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    const operator = labelRSLangNode(node);
+    const domain = this.childQuantifierDomain(node, 1, operator);
     if (domain === null) {
       return null;
     } else if (!this.visitChildDeclaration(node, 0, domain)) {
@@ -510,6 +541,7 @@ export class TypeAuditor {
   }
 
   private visitEquals(node: AstNode): ExpressionType | null {
+    const operator = labelRSLangNode(node);
     const type1 = this.childTypification(node, 0);
     if (type1 === null) {
       return null;
@@ -520,13 +552,14 @@ export class TypeAuditor {
       return null;
     }
     if (!checkCompatibility(type1, type2)) {
-      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
+      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2), operator]);
     }
     return LogicT;
   }
 
   private visitSetexprPredicate(node: AstNode): ExpressionType | null {
-    let type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    const operator = labelRSLangNode(node);
+    let type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation, operator);
     if (type2 === null) {
       return null;
     }
@@ -541,11 +574,11 @@ export class TypeAuditor {
 
     if (!checkCompatibility(type1, type2)) {
       if (isSubset) {
-        return this.onError(RSErrorCode.typesNotEqual, node, [labelType(type1), labelType(type2)]);
+        return this.onError(RSErrorCode.typesNotEqual, node, [labelType(type1), labelType(type2), operator]);
       } else {
         return this.onError(RSErrorCode.invalidElementPredicate, node, [
           labelType(type1),
-          labelToken(node.typeID as TokenID),
+          operator,
           labelType(bool(type2))
         ]);
       }
@@ -618,19 +651,20 @@ export class TypeAuditor {
   }
 
   private visitSetexprBinary(node: AstNode): ExpressionType | null {
-    const type1 = this.childTypeDebool(node, 0, RSErrorCode.invalidTypeOperation);
+    const operator = labelRSLangNode(node);
+    const type1 = this.childTypeDebool(node, 0, RSErrorCode.invalidTypeOperation, operator);
     if (type1 === null) {
       return null;
     }
 
-    const type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    const type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation, operator);
     if (type2 === null) {
       return null;
     }
 
     const result = mergeTypifications(type1, type2);
     if (result === null) {
-      return this.onError(RSErrorCode.typesNotEqual, node, [labelType(bool(type1)), labelType(bool(type2))]);
+      return this.onError(RSErrorCode.typesNotEqual, node, [labelType(bool(type1)), labelType(bool(type2)), operator]);
     }
     return bool(result);
   }
@@ -706,6 +740,7 @@ export class TypeAuditor {
   }
 
   private visitFilter(node: AstNode): ExpressionType | null {
+    const operator = labelRSLangNode(node);
     const indices = getNodeIndices(node);
     const tupleParam = indices.length === node.children.length - 1;
     if (!tupleParam && node.children.length > 2) {
@@ -751,7 +786,8 @@ export class TypeAuditor {
         if (param.typeID !== TypeID.collection || !checkCompatibility(bases[child], debool(param))) {
           return this.onError(RSErrorCode.typesNotEqual, node.children[child], [
             labelType(param),
-            labelType(bool(bases[child]))
+            labelType(bool(bases[child])),
+            operator
           ]);
         }
       }
@@ -763,7 +799,11 @@ export class TypeAuditor {
       const paramType = param;
       const expected = bool(tuple(bases));
       if (paramType.typeID !== TypeID.collection || !checkCompatibility(expected, paramType)) {
-        return this.onError(RSErrorCode.typesNotEqual, node.children[0], [labelType(paramType), labelType(expected)]);
+        return this.onError(RSErrorCode.typesNotEqual, node.children[0], [
+          labelType(paramType),
+          labelType(expected),
+          operator
+        ]);
       }
     }
     return argument;
@@ -793,7 +833,12 @@ export class TypeAuditor {
   private visitDeclarative(node: AstNode): ExpressionType | null {
     this.locals.startScope();
 
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    const domain = this.childTypeDebool(
+      node,
+      1,
+      RSErrorCode.invalidTypeOperation,
+      labelToken(TokenID.NT_DECLARATIVE_EXPR)
+    );
     if (domain === null) {
       return null;
     } else if (!this.visitChildDeclaration(node, 0, domain)) {
@@ -825,7 +870,7 @@ export class TypeAuditor {
   }
 
   private visitIterate(node: AstNode): ExpressionType | null {
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation, labelToken(TokenID.ITERATE));
     if (domain === null) {
       return null;
     }
@@ -867,7 +912,8 @@ export class TypeAuditor {
     if (!checkCompatibility(iterationValue, initType)) {
       return this.onError(RSErrorCode.typesNotEqual, node.children[iterationIndex], [
         labelType(iterationValue),
-        labelType(initType)
+        labelType(initType),
+        labelToken(node.typeID as TokenID)
       ]);
     }