@rsconcept/domain 1.5.1 → 1.6.0

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 {
@@ -1067,6 +1073,50 @@ 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;
+}
+
+/** 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;
+}
+
+/** 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;
@@ -1124,6 +1174,13 @@ class LocalContext {
       this.onError(RSErrorCode.localUndeclared, node, [alias]);
       return null;
     } else if (local.level < 1) {
+      const subexprRoot = findRightLogicOperandRoot(node);
+      if (subexprRoot !== null) {
+        if (pathContainsQuantifier(node, 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 {