@rsconcept/domain 1.5.0 → 1.5.2

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

@@ -157,12 +157,12 @@ const errorData = [
   ['R1', { code: RSErrorCode.radicalUsage, from: 0, to: 2, params: ['R1'] }],
   ['[a∈ℬ(R1)] R1\\a', { code: RSErrorCode.radicalUsage, from: 10, to: 12, params: ['R1'] }],
   // Functions
-  ['F1[X1]', { code: RSErrorCode.invalidArgsArity, from: 3, to: 5, params: ['2', '1'] }],
-  ['F1[X1, X1, X1]', { code: RSErrorCode.invalidArgsArity, from: 3, to: 5, params: ['2', '3'] }],
+  ['F1[X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 6, params: ['2', '1'] }],
+  ['F1[X1, X1, X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 14, params: ['2', '3'] }],
   ['F1[X1, S1]', { code: RSErrorCode.invalidArgumentType, from: 7, to: 9, params: ['b∈ℬ(X1)', 'ℬ(X1×X1)'] }],
   ['F1[S1, X1]', { code: RSErrorCode.invalidArgumentType, from: 3, to: 5, params: ['a∈ℬ(X1)', 'ℬ(X1×X1)'] }],
-  ['P1[X1]', { code: RSErrorCode.invalidArgsArity, from: 3, to: 5, params: ['2', '1'] }],
-  ['P1[X1, X1, X1]', { code: RSErrorCode.invalidArgsArity, from: 3, to: 5, params: ['2', '3'] }],
+  ['P1[X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 6, params: ['2', '1'] }],
+  ['P1[X1, X1, X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 14, params: ['2', '3'] }],
   ['P1[X1, S1]', { code: RSErrorCode.invalidArgumentType, from: 7, to: 9, params: ['b∈ℬ(X1)', 'ℬ(X1×X1)'] }],
   ['P1[S1, X1]', { code: RSErrorCode.invalidArgumentType, from: 3, to: 5, params: ['a∈ℬ(X1)', 'ℬ(X1×X1)'] }],
   // Integral
@@ -182,8 +182,10 @@ const errorData = [
   ['∀(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 }],
   ['∀a∈X1 D{a∈S1| 1=1}=S1', { code: RSErrorCode.localShadowing, from: 8, to: 9, params: ['a'] }],
-  ['∀a∈X1 a=a & a=a', { code: RSErrorCode.localOutOfScope, from: 12, to: 13, params: ['a'] }],
-  ['∀a∈X1 a=a & debool(X1)=a', { code: RSErrorCode.localOutOfScope, from: 23, to: 24, params: ['a'] }],
+  ['∀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'] }],
+  ['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)'] }],
   ['(1,2)∈X1', { code: RSErrorCode.invalidElementPredicate, from: 0, to: 8, params: ['Z×Z', '∈', 'ℬ(X1)'] }],
@@ -223,10 +225,7 @@ const errorData = [
     { 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.invalidFilterBooleanEchelon, from: 4, to: 6, params: ['Fi1', 'ℬ(X1)', 'ℬℬ(X1)'] }
-  ],
+  ['Fi1[X1](ℬ(X1)×X1)', { code: RSErrorCode.invalidFilterBooleanEchelon, from: 4, to: 6, params: ['Fi1', 'ℬ(X1)'] }],
   ['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'] }],
   [
@@ -328,6 +327,33 @@ describe('TypeAuditor', () => {
     expectType('F4[Z]', 'ℬ(X1)');
   });
 
+  it('Highlights the function call site for invalidArgsArity', () => {
+    typeContext.set('F7', {
+      typeID: TypeID.function,
+      result: bool(basic('X1')),
+      args: [
+        { alias: 'a', type: bool(basic('X1')) },
+        { alias: 'b', type: bool(basic('X1')) },
+        { alias: 'c', type: bool(basic('X1')) }
+      ]
+    });
+    typeContext.set('F8', {
+      typeID: TypeID.function,
+      result: bool(basic('X1')),
+      args: [
+        { alias: 'a', type: bool(basic('X1')) },
+        { alias: 'b', type: bool(basic('X1')) },
+        { alias: 'c', type: bool(basic('X1')) }
+      ]
+    });
+    expectError('F8[X1,F7[X1,X1],X1]', {
+      code: RSErrorCode.invalidArgsArity,
+      from: 6,
+      to: 15,
+      params: ['3', '2']
+    });
+  });
+
   it('Templated nesting', () => {
     typeContext.set('F2', {
       typeID: TypeID.function,

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

@@ -837,8 +837,7 @@ export class TypeAuditor {
     if (checkEquality(wrapped, expected) || checkCompatibility(wrapped, expected)) {
       return this.onError(RSErrorCode.invalidFilterBooleanEchelon, node.children[childIndex], [
         operator,
-        labelType(param),
-        labelType(expected)
+        labelType(param)
       ]);
     }
     return this.onError(RSErrorCode.invalidFilterParameterType, node.children[childIndex], [
@@ -999,7 +998,7 @@ export class TypeAuditor {
 
   private checkFuncArguments(node: AstNode, alias: string, type: Parametrized): Map<string, Typification> | null {
     if (node.children.length - 1 !== type.args.length) {
-      return this.onError(RSErrorCode.invalidArgsArity, node.children[1], [
+      return this.onError(RSErrorCode.invalidArgsArity, node, [
         String(type.args.length),
         String(node.children.length - 1)
       ]);
@@ -1068,6 +1067,47 @@ interface LocalData {
   type: Typification;
 }
 
+function isLogicBinaryNode(typeID: number): boolean {
+  return (
+    typeID === TokenID.LOGIC_AND ||
+    typeID === TokenID.LOGIC_OR ||
+    typeID === TokenID.LOGIC_IMPLICATION ||
+    typeID === TokenID.LOGIC_EQUIVALENT
+  );
+}
+
+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)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Right operand subtree of the innermost logic binary containing `node`. */
+function findRightLogicOperandRoot(node: AstNode): AstNode | null {
+  let current: AstNode | null = node;
+  while (current !== null && current.parent !== null) {
+    const parent: AstNode = current.parent;
+    if (isLogicBinaryNode(parent.typeID)) {
+      const childIndex = parent.children.indexOf(current);
+      if (childIndex > 0) {
+        return current;
+      }
+    }
+    current = parent;
+  }
+  return null;
+}
+
 /** Local variables context. */
 class LocalContext {
   private onError: (code: RSErrorCode, node: AstNode, params: string[]) => null;
@@ -1125,6 +1165,13 @@ class LocalContext {
       this.onError(RSErrorCode.localUndeclared, node, [alias]);
       return null;
     } else if (local.level < 1) {
+      const subexprRoot = findRightLogicOperandRoot(node);
+      if (subexprRoot !== null) {
+        if (subtreeContainsQuantifier(subexprRoot)) {
+          return this.onError(RSErrorCode.localUndeclaredInSubexpr, node, [alias, labelType(local.type)]);
+        }
+        return this.onError(RSErrorCode.localOutOfScopeParentheses, node, [alias]);
+      }
       this.onError(RSErrorCode.localOutOfScope, node, [alias]);
       return null;
     } else {