@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/compiler/checks.js

@@ -26,15 +26,17 @@ function check( model ) {       // = XSN
   const {
     error, warning, message, info,
   } = model.$messageFunctions;
-  forEachDefinition( model, checkArtifact );
-  forEachGeneric( model, 'vocabularies', checkAnnotationDefinition );
+
   checkSapCommonLocale( model );
   checkSapCommonTextsAspects( model );
+
+  forEachDefinition( model, checkDefinition );
+  forEachGeneric( model, 'vocabularies', checkAnnotationDefinition );
   return;
 
-  function checkArtifact( art ) {
+  function checkDefinition( art ) {
     checkGenericConstruct( art );
-    forEachGeneric( art, 'elements', checkElement );
+    forEachMember( art, member => checkMember(member) );
     if (art.$queries)
       art.$queries.forEach( checkQuery );
   }
@@ -59,36 +61,50 @@ function check( model ) {       // = XSN
     if (art.kind === 'enum')
       checkEnum( art );
     checkEnumType( art );
+  }
 
-    forEachMember( art, checkGenericConstruct );
+  function checkMember( member, parentProps = { key: false, virtual: false } ) {
+    // To avoid "bubble-up" checks, store required parent properties.
+    if (member.key?.val === true)
+      parentProps.key = member.key;
+    if (member.virtual?.val === true)
+      parentProps.virtual = member.virtual;
+
+    checkGenericConstruct(member);
+
+    if (member.kind === 'element')
+      checkElement( member, parentProps );
+
+    forEachMember( member, m => checkMember(m, parentProps) );
   }
 
-  function checkElement( elem ) {
-    checkLocalizedSubElement(elem);
-    if (elem.key?.val) {
-      if (elem.virtual?.val) {
-        error('def-unexpected-key', [ elem.key.location, elem ],
-              { '#': 'virtual', name: elem.name.element, prop: 'key' });
-      }
-      checkForUnmanagedAssociationsAsKey( elem, elem.key );
+  function checkVirtualKey( elem, parentProps ) {
+    const isKey = parentProps.key || (elem.key?.val && elem.key);
+    const isVirtual = parentProps.virtual?.val || (elem.virtual?.val && elem.virtual);
+    if (isKey && isVirtual) {
+      error('def-unexpected-key', [ isKey.location, elem ],
+            { '#': 'virtual', name: elem.name.element, prop: 'key' });
     }
-    checkAssociation( elem );
+  }
+
+  function checkElement( elem, parentProps ) {
+    checkLocalizedSubElement(elem);
+    checkVirtualKey(elem, parentProps);
+    checkForUnmanagedAssociationsAsKey( elem, parentProps );
     checkLocalizedElement( elem );
-    if (elem.on && !elem.on.$inferred)
-      checkExpression(elem.on, true);
+    checkAssociation( elem );
 
     if (elem.value) {
-      if (elem.$syntax === 'calc')
-        checkCalculatedElement( elem );
-      else
-        checkExpression( elem.value );
+      if (elem._main.query)
+        checkSelectItemValue(elem);
+      else if (elem.$syntax === 'calc')
+        checkCalculatedElementValue( elem );
     }
 
     checkCardinality(elem); // TODO: also for assoc types
-
-    forEachGeneric( elem, 'elements', checkElement );
   }
 
+
   function checkName( construct ) { // TODO: move to define.js
     if (model.options.$skipNameCheck)
       return;
@@ -125,62 +141,30 @@ function check( model ) {       // = XSN
     }
   }
 
-  function checkCalculatedElement( elem ) {
-    if (elem.value.path) {
-      checkExpressionsInPaths(elem.value);
-
-      const loc = [ elem.value.location, elem ];
-      if (isVirtualElement(elem.value._artifact))
-        error('ref-unexpected-virtual', loc, { '#': 'expr' });
-      else if (isStructuredElement(elem.value._artifact))
-        error('ref-unexpected-structured', loc, { '#': 'expr' } );
-      else if (elem.value._artifact?.target !== undefined)
-        error('ref-unexpected-assoc', loc, { '#': 'expr' });
-    }
-    else {
-      // TODO: The checks above should also be run for each path in expressions.
-      checkExpression( elem.value );
-    }
-  }
-
   function checkQuery( query ) {
     checkNoUnmanagedAssocsInGroupByOrderBy( query );
     // TODO: check too simple (just one source), as most of those in this file
     // Check expressions in the various places where they may occur
     if (query.from)
-      checkExpressionsInPaths(query.from);
+      visitSubExpression(query.from, query, checkGenericExpression);
+
+    if (query.where)
+      visitExpression(query.where, query, checkGenericExpression);
 
-    if (query.where) {
-      checkExpression(query.where);
-      checkExpressionsInPaths(query.where);
-    }
     if (query.groupBy) {
-      for (const groupByEntry of query.groupBy) {
-        checkExpression(groupByEntry);
-        checkExpressionsInPaths(groupByEntry);
-      }
-    }
-    if (query.having) {
-      checkExpression(query.having);
-      checkExpressionsInPaths(query.having);
+      for (const groupByEntry of query.groupBy)
+        visitExpression(groupByEntry, query, checkGenericExpression);
     }
+    if (query.having)
+      visitExpression(query.having, query, checkGenericExpression);
+
     if (query.orderBy) {
-      for (const orderByEntry of query.orderBy) {
-        checkExpression(orderByEntry);
-        checkExpressionsInPaths(orderByEntry);
-      }
+      for (const orderByEntry of query.orderBy)
+        visitExpression(orderByEntry, query, checkGenericExpression);
     }
     if (query.mixin) {
-      for (const mixinName in query.mixin) {
-        if (query.mixin[mixinName].on)
-          checkExpression(query.mixin[mixinName].on, true);
-      }
-    }
-    if (query.elements) {
-      for (const elemName in query.elements) {
-        checkStructureCasting(query.elements[elemName]);
-        checkExpressionsInPaths(query.elements[elemName].value);
-      }
+      for (const mixinName in query.mixin)
+        checkAssociation(query.mixin[mixinName]);
     }
   }
 
@@ -358,25 +342,27 @@ function check( model ) {       // = XSN
    * Check that a primary key element is not an unmanaged association or
    * contains unmanaged associations
    *
+   * TODO: ease check for subelements: using unmanaged assocs is OK there, as
+   *       long as the whole key is "closed", i.e., no ref in ON refers to element
+   *       outside.
+   *
    * @param {any} element Element to check recursively
    */
-  function checkForUnmanagedAssociationsAsKey( element, keyObj ) {
+  function checkForUnmanagedAssociationsAsKey( element, parentProps ) {
+    if (!parentProps.key?.val && !element.key?.val)
+      return;
     if (element.targetAspect) {
       // TODO: bad location / message
-      message('composition-as-key', [ keyObj.location, element ], {},
+      message('composition-as-key', [ parentProps.key.location, element ], {},
               // TODO: give semantics when error downgraded
               'Managed compositions can\'t be used as primary key');
     }
     else if (element.on) {
       // TODO: bad location / message
-      message('unmanaged-as-key', [ keyObj.location, element ], {},
+      message('unmanaged-as-key', [ parentProps.key.location, element ], {},
               // TODO: give semantics when error downgraded
               'Unmanaged associations can\'t be used as primary key');
     }
-    // TODO: ease check for subelements: using unmanaged assocs is OK there, as
-    // long as the whole key is "closed", i.e., no ref in ON refers to element
-    // outside.
-    forEachGeneric( element, 'elements', e => checkForUnmanagedAssociationsAsKey( e, keyObj ) );
   }
 
   // Check that min and max cardinalities of 'elem' in 'art' have legal values
@@ -438,27 +424,6 @@ function check( model ) {       // = XSN
     });
   }
 
-  // TODO: yes, a check similar to this could make it into the compiler)
-  // Check that a structured element ist not casted to a different type
-  function checkStructureCasting( elem ) {
-    if (elem.type && !elem.type.$inferred) {
-      const loc = elem.type.location || elem.location;
-
-      if (elem._effectiveType && elem._effectiveType.elements) {
-        error('type-cast-to-structured', [ loc, elem ], {},
-              'Can\'t cast to structured element');
-      }
-      else if (elem.value && elem.value._artifact && elem.value._artifact._effectiveType &&
-               elem.value._artifact._effectiveType.elements) {
-        error('type-cast-structured', [ loc, elem ], {},
-              'Structured elements can\'t be cast to a different type');
-      }
-    }
-    if (elem.value && Array.isArray( elem.value.args)) { // TODO named args?
-      elem.value.args.forEach(checkStructureCasting);
-    }
-  }
-
   // TODO: make this part of the name resolution in the compiler
   // Check that queries in 'art' do not contain unmanaged associations in GROUP BY or ORDER BY
   function checkNoUnmanagedAssocsInGroupByOrderBy( query ) {
@@ -481,22 +446,6 @@ function check( model ) {       // = XSN
     }
   }
 
-  // Traverses 'node' recursively and applies 'checkExpression' to all expressions
-  // found within paths (e.g. filters, parameters, ...)
-  function checkExpressionsInPaths( node ) {
-    foreachPath(node, (path) => {
-      for (const pathStep of path) {
-        if (pathStep.where)
-          checkExpression(pathStep.where);
-
-        // FIXME: I can't actually think of a way to make this check fail, because
-        // params are limited to actual values and params
-        if (pathStep.args)
-          checkExpression(pathStep.args);
-      }
-    });
-  }
-
   function checkAssociation( elem ) {
     // TODO: yes, a check similar to this could make it into the compiler)
     //       when virtual element is part of association
@@ -505,80 +454,20 @@ function check( model ) {       // = XSN
         const key = elem.foreignKeys[k].targetElement;
         if (key && isVirtualElement(key._artifact))
           error('ref-unexpected-virtual', [ key.location, elem ], { '#': 'fkey' });
+        else if (key._artifact?.$syntax === 'calc')
+          error( 'ref-unexpected-calculated', [ key.location, elem ], { '#': 'fkey' } );
       }
     }
-    if (elem.on && !elem.on.$inferred)
-      checkAssociationCondition(elem, elem.on);
-  }
 
-  function checkAssociationCondition( elem, onCond ) {
-    if (Array.isArray(onCond)) // condition in brackets results an array
-      onCond.forEach(Cond => checkAssociationCondition(elem, Cond));
-    else
-      checkAssociationConditionArgs(elem, onCond.args, getBinaryOp( onCond ));
+    checkOnCondition(elem);
   }
 
   function getBinaryOp( cond ) {
     const { op, args } = cond;
-    return op?.val === 'ixpr' && args.length === 3 && args[1].literal === 'token' &&
+    return op?.val === 'ixpr' && args?.length === 3 && args[1].literal === 'token' &&
       args[1] || op;
   }
 
-  function checkAssociationConditionArgs( elem, args, op ) {
-    if (args)
-      args.forEach(Arg => checkAssociationOnCondArg(elem, Arg, op));
-  }
-
-  function checkAssociationOnCondArg( elem, arg, op ) {
-    if (Array.isArray(arg)) {
-      arg.forEach(Arg => checkAssociationCondition(elem, Arg));
-    }
-    else {
-      checkAssociationCondition(elem, arg);
-      singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc(elem, arg, op);
-    }
-  }
-
-  // TODO: make it part of the name resolution in the compiler to check whether
-  // associations can be followed (in the ON condition)
-  //
-  // TODO: this function must be completely reworked, probably even before
-  // integration into name resolution - did the first step.
-  // It is also incomplete, as associations in structures are not checked.
-  // Additionally, `$self.assoc` references are also not found.
-  function singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc( elem, arg, op ) {
-    if (!arg.path)
-      return;
-    const path0 = arg.path[0];
-    if (!path0)
-      return;
-    if (path0.id === '$self' && arg.path.length === 1) { // $self (backlink) checks
-      checkAssociationArgumentStartingWithSelf( op, elem );
-      return;
-    }
-    const argTarget = path0._artifact;
-    if (!argTarget) // not resolved
-      return;
-    // the check is valid for unmanaged associations
-
-    // TODO clarify if the full resolved path to the target field should
-    // consist of managed associations or just the first
-    if (argTarget.on) {
-      const same = path0._artifact === elem;
-      if (!same) {
-        error(null, [ path0.location, elem ], {},
-              'Unmanaged association condition can\'t follow another unmanaged association');
-      }
-    }
-  }
-
-  function checkAssociationArgumentStartingWithSelf( op, elem ) {
-    if (op?.val === 'xpr') // no check for xpr, would require re-structuring
-      return;
-    if (op && op.val !== '=')
-      error(null, [ op.location, elem ], {}, '$self comparison is only allowed with \'=\'');
-  }
-
   // A function like this could be part of the compiler
   /**
    * Check that the given type has no conflicts between its `type` property
@@ -612,19 +501,92 @@ function check( model ) {       // = XSN
   // Former checkExpressions.js ----------------------------------------------
 
   /**
-   * Check an expression (or condition) for semantic validity
+   * Check a generic expression (or condition) for semantic validity.
    *
    * @param {any} xpr The expression to check
-   * @param {Boolean} allowAssocTail
+   * @param {XSN.Artifact} user User for semantic location
    * @returns {void}
    */
-  function checkExpression( xpr, allowAssocTail = false ) {
-    // Since the checks for tree-like and token-stream expressions differ,
-    // check here what kind of expression we are looking at
-    if (xpr.op?.val === 'xpr')
-      return checkTokenStreamExpression(xpr, allowAssocTail);
-    return checkTreeLikeExpression(xpr, allowAssocTail);
+  function checkGenericExpression( xpr, user ) {
+    checkExpressionNotVirtual(xpr, user);
+    checkExpressionAssociationUsage(xpr, user, false);
   }
+
+  function checkExpressionNotVirtual( xpr, user ) {
+    if (xpr._artifact && isVirtualElement(xpr._artifact))
+      error('ref-unexpected-virtual', [ xpr.location, user ], { '#': 'expr' });
+  }
+
+  function checkOnCondition( elem ) {
+    // TODO: Move to checkAssociation
+    if (elem.on && !elem.on.$inferred) {
+      visitExpression(elem.on, elem, (xpr, user) => {
+        checkExpressionNotVirtual(xpr, user);
+        checkExpressionAssociationUsage(xpr, user, true);
+        if (xpr._artifact?.$syntax === 'calc')
+          error( 'ref-unexpected-calculated', [ xpr.location, user ], { '#': 'on' } );
+      });
+      if (isDollarSelfOrProjectionOperand(elem.on)) {
+        // Bare $self usages are not allowed and don't work in A2J.
+        error('expr-missing-comparison', [ elem.on.location, elem ], { id: '$self', op: '=' } );
+      }
+    }
+  }
+
+  function checkSelectItemValue( elem ) {
+    checkExpressionAssociationUsage(elem.value, elem, false);
+
+    visitSubExpression(elem.value, elem, (xpr) => {
+      checkExpressionNotVirtual(xpr, elem);
+      checkExpressionAssociationUsage(xpr, elem, false);
+    });
+  }
+
+  function checkCalculatedElementValue( elem ) {
+    visitExpression(elem.value, elem, (xpr, user) => {
+      if (xpr._artifact) { // we only need to check artifact references
+        checkExpressionNotVirtual(xpr, user);
+        if (isStructuredElement(xpr._artifact))
+          error('ref-unexpected-structured', [ xpr.location, elem ], { '#': 'expr' } );
+        else if (xpr._artifact.target !== undefined)
+          error('ref-unexpected-assoc', [ xpr.location, elem ], { '#': 'expr' });
+      }
+    });
+    // Calc elements must not refer to keys, because that may lead to another key
+    // in an SQL view, which is missing in OData.
+    // Following associations does not lead to this issue.
+    if (elem.value.path && isKeyElement(elem.value._artifact) &&
+      !followsAnAssociation(elem.value.path)) {
+      error('ref-unexpected-key', [ elem.value.location, elem ], {},
+            'Calculated elements can\'t refer directly to key elements');
+    }
+  }
+
+  /**
+   * Returns true if any of the path steps follows an association.
+   *
+   * @param path
+   * @return {boolean}
+   */
+  function followsAnAssociation( path ) {
+    for (const step of path) {
+      if (step._artifact?.target)
+        return true;
+    }
+    return false;
+  }
+
+  function isKeyElement( elem ) {
+    let parent = elem;
+    while (parent) {
+      if (parent.key?.val === true)
+        return true;
+      parent = parent._parent;
+    }
+    return false;
+  }
+
+
   /**
    * Check whether the supplied argument is a virtual element
    *
@@ -650,60 +612,57 @@ function check( model ) {       // = XSN
     return !!(elem?._effectiveType || elem)?.elements;
   }
 
-  /**
-   * Check a token-stream expression for semantic validity
-   *
-   * @param {any} xpr The expression to check
-   * @returns {void}
-   */
-  function checkTokenStreamExpression( xpr, allowAssocTail ) {
-    const args = Array.isArray(xpr.args) ? xpr.args : Object.values(xpr.args || {});
-    // Check for illegal argument usage within the expression
-    for (const arg of args) {
-      if (isVirtualElement(arg._artifact || arg))
-        error('ref-unexpected-virtual', arg.location, { '#': 'expr' });
-
-      // Recursively traverse the argument expression
-      checkTokenStreamExpression(arg, allowAssocTail);
-    }
-  }
-
   /**
    * Check a tree-like expression for semantic validity
    *
    * @param {any} xpr The expression to check
+   * @param {XSN.Artifact} user
+   * @param {boolean} allowAssocTail
    * @returns {void}
    */
-  function checkTreeLikeExpression( xpr, allowAssocTail ) {
-    // No further checks regarding associations and $self required if this is a
-    // backlink-like expression (a comparison of $self with an assoc)
-    if (isBinaryDollarSelfComparisonWithAssoc(xpr))
+  function checkExpressionAssociationUsage( xpr, user, allowAssocTail ) {
+    if (!xpr.args)
       return;
 
-    // Check for illegal argument usage within the expression
-    for (const arg of Array.isArray(xpr.args) && xpr.args || []) { // TODO named args?
-      if (isVirtualElement(arg._artifact || arg))
-        error('ref-unexpected-virtual', arg.location, { '#': 'expr' });
-
-      // Arg must not be an association and not $self
-      // Only if path is not approved exists path (that is non-query position)
-      if (arg.path && arg.$expected !== undefined) { // not 'approved-exists'
-        if (arg.$expected === 'exists')
-          error('ref-unexpected-assoc', arg.location, { '#': 'expr' } );
-      }
-      else if (!allowAssocTail && isAssociationOperand(arg)) {
-        error('ref-unexpected-assoc', arg.location, { '#': 'expr' } );
+    // Only check associations and $self if this is not a backlink-like
+    // expression (a comparison of $self with an assoc).
+    // We don't check token-stream-like 'xpr's.
+    const isNotSelfComparison = xpr.op?.val !== 'xpr' &&
+      !isBinaryDollarSelfComparisonWithAssoc(xpr);
+    const args = Array.isArray(xpr.args) ? xpr.args : Object.values(xpr.args);
+    const op = getBinaryOp(xpr);
+
+    if (isNotSelfComparison) {
+      for (const arg of args) {
+        if (op?.val !== '=' && isDollarSelfOrProjectionOperand(arg)) {
+          // `nary` operators don't have a "good" location; use $self in that case.
+          const loc = (op?.location.endLine ? op : arg).location;
+          error('expr-invalid-operator', [ loc, user ], { op: '=', id: '$self' });
+        }
+        else {
+          checkExpressionIsNotAssocOrSelf(arg, user, allowAssocTail);
+        }
       }
+    }
+  }
 
-      if (isDollarSelfOrProjectionOperand(arg)) {
-        error(null, arg.location, { id: arg.path[0].id },
-              '$(ID) can only be used as a value in a comparison to an association');
-      }
+  function checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail ) {
+    // Arg must not be an association and not $self
+    // Only if path is not approved exists path (that is non-query position)
+    if (arg.path && arg.$expected !== undefined) { // not 'approved-exists'
+      if (arg.$expected === 'exists')
+        error('ref-unexpected-assoc', [ arg.location, user ], { '#': 'expr' } );
+    }
+    else if (!allowAssocTail && isAssociationOperand(arg)) {
+      error('ref-unexpected-assoc', [ arg.location, user ], { '#': 'expr' } );
+    }
 
-      // Recursively traverse the argument expression
-      checkTreeLikeExpression(arg, allowAssocTail);
+    if (isDollarSelfOrProjectionOperand(arg)) {
+      error(null, [ arg.location, user ], { id: arg.path[0].id },
+            '$(ID) can only be used as a value in a comparison to an association');
     }
   }
+
   // Return true if 'arg' is an expression argument of type association or composition
   function isAssociationOperand( arg ) {
     if (!arg.path) {
@@ -715,9 +674,11 @@ function check( model ) {       // = XSN
       (arg._artifact && arg._artifact._effectiveType && arg._artifact._effectiveType.target);
   }
 
-  // Return true if 'arg' is an expression argument denoting "$self" || "$projection"
+  /**
+   * Return true if 'arg' is an expression argument denoting "$self" || "$projection"
+   */
   function isDollarSelfOrProjectionOperand( arg ) {
-    return arg.path && arg.path.length === 1 &&
+    return arg.path?.length === 1 &&
       (arg.path[0].id === '$self' || arg.path[0].id === '$projection');
   }
 
@@ -739,6 +700,11 @@ function check( model ) {       // = XSN
       return (isAssociationOperand(xpr.args[0]) && isDollarSelfOrProjectionOperand(xpr.args[1]) ||
               isAssociationOperand(xpr.args[1]) && isDollarSelfOrProjectionOperand(xpr.args[0]));
     }
+    else if (xpr.args.length === 3 && xpr.args[1].val === '=') {
+      // Tree-ish expression from the compiler (not augmented)
+      return (isAssociationOperand(xpr.args[0]) && isDollarSelfOrProjectionOperand(xpr.args[2]) ||
+             isAssociationOperand(xpr.args[2]) && isDollarSelfOrProjectionOperand(xpr.args[0]));
+    }
 
     // Nothing else qualifies
     return false;
@@ -811,12 +777,12 @@ function check( model ) {       // = XSN
     // Must have literal or path unless it is a boolean
     if (!anno.literal && !anno.path && getFinalTypeNameOf(elementDecl) !== 'cds.Boolean') {
       if (elementDecl.type && elementDecl.type._artifact.name.absolute) {
-        warning(null, anno.location || anno.name.location, { type: elementDecl.type._artifact },
-                'Expecting a value of type $(TYPE) for the annotation');
+        warning('anno-expecting-value', anno.location || anno.name.location,
+                { '#': 'type', type: elementDecl.type._artifact });
       }
       else {
-        warning(null, anno.location || anno.name.location, {},
-                'Expecting a value for the annotation');
+        warning('anno-expecting-value', anno.location || anno.name.location,
+                { '#': 'std', anno: anno.name.absolute });
       }
 
       return;
@@ -950,12 +916,13 @@ function check( model ) {       // = XSN
 
     // Continue search with next path step
     const nextStepEnv = (from._effectiveType || from).artifacts ||
-          from._effectiveType.elements || [];
+          from._effectiveType?.elements || [];
     return resolvePathFrom(path.slice(1), nextStepEnv[path[0].id], result);
   }
 
-  // Return the absolute name of the final type of 'node'. May return 'undefined' for
-  // anonymous types
+  // Return the absolute name of the final type of 'node'. May return 'undefined'
+  // for anonymous types.  DO NOT USE THIS function, it has several assumptions
+  // which are not necessarily true.
   function getFinalTypeNameOf( node ) {
     let type = node._effectiveType;
     if (type.type)
@@ -1009,21 +976,49 @@ function checkSapCommonLocale( model ) {
   }
 }
 
-// For each property named 'path' in 'node' (recursively), call callback(path, node)
-//
-// TODO: remove - this is not a good way to traverse expressions
-function foreachPath( node, callback ) {
-  if (node === null || typeof node !== 'object') {
-    // Primitive node
-    return;
+
+/**
+ * Visits each expression.
+ *
+ * TODO: Properly visit expressions; will be improved step by step;
+ *       Currently only replaces old foreachPath().
+ *
+ * @param {any} xpr
+ * @param {XSN.Artifact} user
+ * @param {(xpr: any, user: any, parentExpr: any) => void} callback
+ */
+function visitExpression( xpr, user, callback ) {
+  callback( xpr, user, null );
+  visitSubExpression( xpr, user, callback );
+}
+
+/**
+ * Visits each sub-expression.
+ *
+ * @param {any} xpr
+ * @param {XSN.Artifact} user
+ * @param {(xpr: any, user: any, parentExpr: any) => void} callback
+ */
+function visitSubExpression( xpr, user, callback ) {
+  if (xpr.args) {
+    const args = Array.isArray(xpr.args) ? xpr.args : Object.values(xpr.args);
+    // Check for illegal argument usage within the expression
+    for (const arg of args) {
+      callback( arg, user, xpr.args );
+      // Recursively traverse the argument expression
+      visitSubExpression(arg, user, callback);
+    }
   }
-  for (const name in node) {
-    // If path found within a non-dictionary, call callback
-    if (name === 'path' && Object.getPrototypeOf(node))
-      callback(node.path, node);
-    // Descend recursively
-    foreachPath(node[name], callback);
+
+  if (xpr.path?.length) {
+    for (const arg of xpr.path) {
+      if (arg.where) {
+        callback( arg.where, user, arg );
+        visitSubExpression(arg.where, user, callback);
+      }
+    }
   }
 }
 
+
 module.exports = check;