@rsconcept/domain 1.4.4 → 1.4.6

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

@@ -218,14 +218,17 @@ const errorData = [
   ['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'] }],
-  ['Fi1[X1](ℬ(X1))', { code: RSErrorCode.invalidFilterArgumentType, from: 8, to: 13, params: ['Fi1', 'ℬℬ(X1)'] }],
+  [
+    'Fi1[X1](ℬ(X1))',
+    { code: RSErrorCode.invalidFilterArgumentType, from: 8, to: 13, params: ['Fi1', 'ℬℬ(X1)', 'ℬ(R0)'] }
+  ],
   ['Fi1[1](S1)', { code: RSErrorCode.invalidFilterParameterType, from: 4, to: 5, params: ['Z', 'ℬ(X1)', 'Fi1'] }],
   [
     'Fi1[X1](ℬ(X1)×X1)',
-    { code: RSErrorCode.invalidFilterParameterType, from: 4, to: 6, params: ['ℬ(X1)', 'ℬℬ(X1)', 'Fi1'] }
+    { code: RSErrorCode.invalidFilterBooleanEchelon, from: 4, to: 6, params: ['Fi1', 'ℬ(X1)', 'ℬℬ(X1)'] }
   ],
-  ['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 }],
+  ['Fi3[X1](S1)', { code: RSErrorCode.invalidFilterIndex, from: 8, to: 10, params: ['Fi3', 'ℬ(X1×X1)', '3', '2'] }],
+  ['Fi1[X1,X1](S1)', { code: RSErrorCode.invalidFilterArity, from: 7, to: 9, params: ['1', '2', 'Fi1'] }],
   [
     'Fi1,2[X1](S1)',
     { code: RSErrorCode.invalidFilterParameterType, from: 6, to: 8, params: ['ℬ(X1)', 'ℬ(X1×X1)', 'Fi1,2'] }

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

@@ -351,6 +351,9 @@ export class TypeAuditor {
     if (!type) {
       return this.onError(RSErrorCode.globalNotTyped, node, [alias]);
     }
+    if (type.typeID === TypeID.function || type.typeID === TypeID.predicate) {
+      return this.onError(RSErrorCode.globalFuncWithoutArgs, node, [alias]);
+    }
     return type;
   }
 
@@ -744,7 +747,12 @@ export class TypeAuditor {
     const indices = getNodeIndices(node);
     const tupleParam = indices.length === node.children.length - 1;
     if (!tupleParam && node.children.length > 2) {
-      return this.onError(RSErrorCode.invalidFilterArity, node);
+      const extraParam = node.children[indices.length];
+      return this.onError(RSErrorCode.invalidFilterArity, extraParam ?? node, [
+        String(indices.length),
+        String(node.children.length - 1),
+        operator
+      ]);
     }
 
     const argument = this.childTypification(node, node.children.length - 1);
@@ -757,10 +765,12 @@ export class TypeAuditor {
     ) {
       return EmptySetT;
     }
+    const expectedArgument = this.expectedFilterArgumentLabel(indices);
     if (argument.typeID !== TypeID.collection || argument.base.typeID !== TypeID.tuple) {
       return this.onError(RSErrorCode.invalidFilterArgumentType, node.children[node.children.length - 1], [
-        labelRSLangNode(node),
-        labelType(argument)
+        operator,
+        labelType(argument),
+        expectedArgument
       ]);
     }
 
@@ -769,9 +779,11 @@ export class TypeAuditor {
     for (const index of indices) {
       const newBase = component(argBase, index);
       if (newBase === null) {
-        return this.onError(RSErrorCode.invalidFilterArgumentType, node.children[node.children.length - 1], [
-          labelRSLangNode(node),
-          labelType(argument)
+        return this.onError(RSErrorCode.invalidFilterIndex, node.children[node.children.length - 1], [
+          operator,
+          labelType(argument),
+          String(index),
+          String(argBase.factors.length)
         ]);
       }
       bases.push(newBase);
@@ -783,12 +795,9 @@ export class TypeAuditor {
         if (param === null) {
           return null;
         }
+        const expectedParam = bool(bases[child]);
         if (param.typeID !== TypeID.collection || !checkCompatibility(bases[child], debool(param))) {
-          return this.onError(RSErrorCode.invalidFilterParameterType, node.children[child], [
-            labelType(param),
-            labelType(bool(bases[child])),
-            operator
-          ]);
+          return this.reportFilterParameterError(node, child, param, expectedParam, operator);
         }
       }
     } else {
@@ -799,16 +808,46 @@ export class TypeAuditor {
       const paramType = param;
       const expected = bool(tuple(bases));
       if (paramType.typeID !== TypeID.collection || !checkCompatibility(expected, paramType)) {
-        return this.onError(RSErrorCode.invalidFilterParameterType, node.children[0], [
-          labelType(paramType),
-          labelType(expected),
-          operator
-        ]);
+        return this.reportFilterParameterError(node, 0, paramType, expected, operator);
       }
     }
     return argument;
   }
 
+  private expectedFilterArgumentLabel(indices: number[]): string {
+    const maxIndex = Math.max(...indices, 0);
+    if (maxIndex <= 1) {
+      return labelType(bool({ typeID: TypeID.anyTypification }));
+    }
+    const factors: Typification[] = [];
+    for (let index = 1; index <= maxIndex; index++) {
+      factors.push({ typeID: TypeID.anyTypification });
+    }
+    return labelType(bool(tuple(factors)));
+  }
+
+  private reportFilterParameterError(
+    node: AstNode,
+    childIndex: number,
+    param: Typification,
+    expected: Typification,
+    operator: string
+  ): null {
+    const wrapped = bool(param);
+    if (checkEquality(wrapped, expected) || checkCompatibility(wrapped, expected)) {
+      return this.onError(RSErrorCode.invalidFilterBooleanEchelon, node.children[childIndex], [
+        operator,
+        labelType(param),
+        labelType(expected)
+      ]);
+    }
+    return this.onError(RSErrorCode.invalidFilterParameterType, node.children[childIndex], [
+      labelType(param),
+      labelType(expected),
+      operator
+    ]);
+  }
+
   private visitReduce(node: AstNode): ExpressionType | null {
     const argument = this.childTypification(node, 0);
     if (argument === null) {