@rsconcept/domain 1.5.2 → 1.6.1

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

@@ -45,15 +45,65 @@ describe('RSLang analyzer', () => {
   });
 
   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 });
+    expectError(
+      'X1',
+      { expected: TypeClass.logic },
+      {
+        code: RSErrorCode.expectedType,
+        from: 0,
+        to: 2,
+        params: [String(TypeClass.logic), labelType(bool(basic('X1')))]
+      }
+    );
+    expectError(
+      '1=1',
+      { expected: TypeClass.typification },
+      {
+        code: RSErrorCode.expectedType,
+        from: 0,
+        to: 3,
+        params: [String(TypeClass.typification), 'Logic']
+      }
+    );
+    expectError(
+      '1=1',
+      { expected: TypeClass.function },
+      {
+        code: RSErrorCode.expectedType,
+        from: 0,
+        to: 3,
+        params: [String(TypeClass.function), 'Logic']
+      }
+    );
+    expectError(
+      '[a ∈ X1] a=a',
+      { expected: TypeClass.function },
+      {
+        code: RSErrorCode.expectedType,
+        from: 0,
+        to: 12,
+        params: [String(TypeClass.function), '[X1] → Logic']
+      }
+    );
+    expectError(
+      '[a ∈ X1] a',
+      { expected: TypeClass.predicate },
+      {
+        code: RSErrorCode.expectedType,
+        from: 0,
+        to: 10,
+        params: [String(TypeClass.predicate), '[X1] → X1']
+      }
+    );
   });
 
   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 });
+    expect(result.errors[0]).toMatchObject({
+      code: RSErrorCode.expectedType,
+      from: 0,
+      to: 2,
+      params: [String(TypeClass.logic), labelType(bool(basic('X1')))]
+    });
   });
 });

package/src/rslang/semantic/analyzer.ts

@@ -1,6 +1,7 @@
 import { type AstNode, buildTree } from '../../parsing';
 import { annotateError } from '../ast-annotations';
 import { RSErrorCode, type RSErrorDescription } from '../error';
+import { labelType } from '../labels';
 import { normalizeAST } from '../parser/normalize';
 import { parser as rslangParser } from '../parser/parser';
 import { extractSyntaxErrors } from '../parser/syntax-errors';
@@ -136,13 +137,15 @@ export class RSLangAnalyzer {
       return { success: true, type: debool(type), valueClass: ValueClass.VALUE, errors, ast };
     }
     if (options?.expected && getTypeClass(type.typeID) !== options.expected) {
+      const errorParams = [String(options.expected), labelType(type)];
       reporter({
         code: RSErrorCode.expectedType,
         from: ast.from,
-        to: ast.to
+        to: ast.to,
+        params: errorParams
       });
       if (options?.annotateErrors) {
-        annotateError(ast, RSErrorCode.expectedType);
+        annotateError(ast, RSErrorCode.expectedType, errorParams);
       }
       return { success: false, type: null, valueClass: null, errors, ast };
     }

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

@@ -185,6 +185,7 @@ const errorData = [
   ['∀a∈X1 a=a & a=a', { code: RSErrorCode.localOutOfScopeParentheses, from: 12, to: 13, params: ['a'] }],
   ['∀a∈X1 a=a & debool(X1)=a', { code: RSErrorCode.localOutOfScopeParentheses, from: 23, to: 24, params: ['a'] }],
   ['∀ξ∈X1 ξ=ξ & ∀φ∈X1 φ=ξ', { code: RSErrorCode.localUndeclaredInSubexpr, from: 20, to: 21, params: ['ξ', 'X1'] }],
+  ['∀ξ∈X1 ξ=ξ & (ξ=ξ & ∀φ∈X1 φ=φ)', { code: RSErrorCode.localOutOfScopeParentheses, from: 13, to: 14, params: ['ξ'] }],
   ['D{t∈X1 | t=t} ∪ {t}', { code: RSErrorCode.localOutOfScope, from: 17, to: 18, params: ['t'] }],
   // Set predicates
   ['X1∈X1', { code: RSErrorCode.invalidElementPredicate, from: 0, to: 5, params: ['ℬ(X1)', '∈', 'ℬ(X1)'] }],
@@ -213,13 +214,22 @@ const errorData = [
   ['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)', '∪'] }],
-  ['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)'] }],
-  ['Pr1((1,2))', { code: RSErrorCode.invalidProjectionSet, from: 4, to: 9, params: ['Z×Z'] }],
-  ['pr1(X1)', { code: RSErrorCode.invalidProjectionTuple, from: 4, to: 6, params: ['pr1', 'ℬ(X1)'] }],
-  ['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'] }],
+  ['Pr1(X1)', { code: RSErrorCode.projectionSetArgumentNotTupleSet, from: 4, to: 6, params: ['Pr1', 'ℬ(X1)'] }],
+  [
+    'Pr3(S1)',
+    { code: RSErrorCode.projectionSetIndexOutOfRange, from: 4, to: 6, params: ['Pr3', '3', '2', 'ℬ(X1×X1)'] }
+  ],
+  [
+    'Pr1,3(S1)',
+    { code: RSErrorCode.projectionSetIndexOutOfRange, from: 6, to: 8, params: ['Pr1,3', '3', '2', 'ℬ(X1×X1)'] }
+  ],
+  ['Pr1((1,2))', { code: RSErrorCode.projectionSetArgumentNotSet, from: 4, to: 9, params: ['Pr1', 'Z×Z'] }],
+  ['pr1(X1)', { code: RSErrorCode.projectionTupleArgumentNotTuple, from: 4, to: 6, params: ['pr1', 'ℬ(X1)'] }],
+  ['pr1(debool(X1))', { code: RSErrorCode.projectionTupleArgumentNotTuple, from: 4, to: 14, params: ['pr1', 'X1'] }],
+  [
+    'pr3(debool(S1))',
+    { code: RSErrorCode.projectionTupleIndexOutOfRange, from: 4, to: 14, params: ['pr3', '3', '2', 'X1×X1'] }
+  ],
   [
     'Fi1[X1](ℬ(X1))',
     { code: RSErrorCode.invalidFilterArgumentType, from: 8, to: 13, params: ['Fi1', 'ℬℬ(X1)', 'ℬ(R0)'] }

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

@@ -673,18 +673,21 @@ export class TypeAuditor {
   }
 
   private visitProjectSet(node: AstNode): ExpressionType | null {
-    const argument = this.childTypeDebool(node, 0, RSErrorCode.invalidProjectionSet);
-    if (argument === null) {
+    const operator = labelRSLangNode(node);
+    const argNode = node.children[0];
+    const argType = this.childTypification(node, 0);
+    if (argType === null) {
       return null;
     }
-    if (argument.typeID === TypeID.anyTypification) {
+    if (argType.typeID === TypeID.anyTypification) {
       return EmptySetT;
     }
+    if (argType.typeID !== TypeID.collection) {
+      return this.onError(RSErrorCode.projectionSetArgumentNotSet, argNode, [operator, labelType(argType)]);
+    }
+    const argument = debool(argType);
     if (argument.typeID !== TypeID.tuple) {
-      return this.onError(RSErrorCode.invalidProjectionSet, node.children[0], [
-        labelRSLangNode(node),
-        labelType(bool(argument))
-      ]);
+      return this.onError(RSErrorCode.projectionSetArgumentNotTupleSet, argNode, [operator, labelType(bool(argument))]);
     }
 
     const indices = getNodeIndices(node);
@@ -692,8 +695,10 @@ export class TypeAuditor {
     for (const index of indices) {
       const newComponent = component(argument, index);
       if (newComponent === null) {
-        return this.onError(RSErrorCode.invalidProjectionSet, node.children[0], [
-          labelRSLangNode(node),
+        return this.onError(RSErrorCode.projectionSetIndexOutOfRange, argNode, [
+          operator,
+          String(index),
+          String(argument.factors.length),
           labelType(bool(argument))
         ]);
       } else {
@@ -708,6 +713,8 @@ export class TypeAuditor {
   }
 
   private visitProjectTuple(node: AstNode): ExpressionType | null {
+    const operator = labelRSLangNode(node);
+    const argNode = node.children[0];
     const argument = this.childTypification(node, 0);
     if (argument === null) {
       return null;
@@ -716,10 +723,7 @@ export class TypeAuditor {
       return argument;
     }
     if (argument.typeID !== TypeID.tuple) {
-      return this.onError(RSErrorCode.invalidProjectionTuple, node.children[0], [
-        labelRSLangNode(node),
-        labelType(argument)
-      ]);
+      return this.onError(RSErrorCode.projectionTupleArgumentNotTuple, argNode, [operator, labelType(argument)]);
     }
 
     const indices = getNodeIndices(node);
@@ -727,8 +731,10 @@ export class TypeAuditor {
     for (const index of indices) {
       const newComponent = component(argument, index);
       if (newComponent === null) {
-        return this.onError(RSErrorCode.invalidProjectionTuple, node.children[0], [
-          labelRSLangNode(node),
+        return this.onError(RSErrorCode.projectionTupleIndexOutOfRange, argNode, [
+          operator,
+          String(index),
+          String(argument.factors.length),
           labelType(argument)
         ]);
       } else {
@@ -1080,14 +1086,17 @@ function isQuantifierNode(typeID: number): boolean {
   return typeID === TokenID.QUANTOR_UNIVERSAL || typeID === TokenID.QUANTOR_EXISTS;
 }
 
-function subtreeContainsQuantifier(node: AstNode): boolean {
-  if (isQuantifierNode(node.typeID)) {
-    return true;
-  }
-  for (const child of node.children) {
-    if (subtreeContainsQuantifier(child)) {
+/** Quantifier on the path from `node` up through `stopAt` (inclusive). */
+function pathContainsQuantifier(node: AstNode, stopAt: AstNode): boolean {
+  let current: AstNode | null = node;
+  while (current !== null) {
+    if (isQuantifierNode(current.typeID)) {
       return true;
     }
+    if (current === stopAt) {
+      return false;
+    }
+    current = current.parent;
   }
   return false;
 }
@@ -1167,7 +1176,7 @@ class LocalContext {
     } else if (local.level < 1) {
       const subexprRoot = findRightLogicOperandRoot(node);
       if (subexprRoot !== null) {
-        if (subtreeContainsQuantifier(subexprRoot)) {
+        if (pathContainsQuantifier(node, subexprRoot)) {
           return this.onError(RSErrorCode.localUndeclaredInSubexpr, node, [alias, labelType(local.type)]);
         }
         return this.onError(RSErrorCode.localOutOfScopeParentheses, node, [alias]);