@sap/cds-compiler 4.1.2 → 4.2.4

package/lib/compiler/checks.js

@@ -15,13 +15,14 @@ const {
   forEachGeneric,
   forEachDefinition,
   forEachMember,
+  forEachMemberRecursively,
   isBetaEnabled,
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { pathName } = require('./utils');
-const { forEachMemberRecursively } = require('../model/csnUtils');
 const { typeParameters } = require('./builtins');
-const $location = Symbol.for('cds.$location');
+
+const $location = Symbol.for( 'cds.$location' );
 
 /**
  * Run compiler checks on the given XSN model.
@@ -38,13 +39,14 @@ function check( model ) {
 
   forEachDefinition( model, checkDefinition );
   forEachGeneric( model, 'vocabularies', checkAnnotationDefinition );
+
   return;
 
   function checkDefinition( def ) {
     checkGenericConstruct( def );
     if (def.includes && def.elements)
       checkElementIncludeOverride( def );
-    forEachMember( def, member => checkMember(member) );
+    forEachMember( def, member => checkMember( member ) );
     if (def.$queries)
       def.$queries.forEach( checkQuery );
   }
@@ -55,7 +57,7 @@ function check( model ) {
     forEachMemberRecursively( art, (member) => {
       if (member.localized?.val)
         warning( 'def-unexpected-localized-anno', [ member.localized.location, member ] );
-    });
+    } );
   }
 
   function checkGenericConstruct( art ) {
@@ -92,8 +94,8 @@ function check( model ) {
     const isKey = parentProps.key?.val || elem.key?.val;
     const isVirtual = parentProps.virtual?.val || elem.virtual?.val;
     if (isKey && isVirtual) {
-      error('def-unexpected-key', [ isKey.location, elem ],
-            { '#': 'virtual', art: elem.name.element, prop: 'key' });
+      error( 'def-unexpected-key', [ isKey.location, elem ],
+             { '#': 'virtual', art: elem.name.element, prop: 'key' } );
     }
   }
 
@@ -119,9 +121,11 @@ function check( model ) {
     // TODO: Move a corrected version of this check to definer (but do not rely on it!):
     //       The code below misses to consider CSN input!
     //       Maybe remove the check? But consider runtimes that rely on '.' as element separator.
-    if (construct.name.id?.includes( '.' )) {
-      error(null, [ construct.name.location, construct ], {},
-            'The character \'.\' is not allowed in identifiers');
+    if (construct.kind === 'element' || construct.kind === 'action' || construct.kind === 'param') {
+      if (construct.name.id?.includes( '.' )) {
+        error( null, [ construct.name.location, construct ], {},
+               'The character \'.\' is not allowed in identifiers' );
+      }
     }
   }
 
@@ -140,7 +144,7 @@ function check( model ) {
     if (art.items)
       checkTypeArguments( art.items, art );
 
-    const actualParams = typeParameters.list.filter(param => art[param] !== undefined);
+    const actualParams = typeParameters.list.filter( param => art[param] !== undefined );
     if (actualParams.length === 0)
       return;
 
@@ -156,17 +160,17 @@ function check( model ) {
       return; // e.g. illegal definition references, cycles, ...
     }
     else if (!art.type && !effectiveType.type && !effectiveType?.builtin) {
-      error('type-missing-type', [ art.location, user ],
-            { otherprop: 'type', prop: actualParams[0] },
-            'Missing $(OTHERPROP) property next to $(PROP)');
+      error( 'type-missing-type', [ art.location, user ],
+             { otherprop: 'type', prop: actualParams[0] },
+             'Missing $(OTHERPROP) property next to $(PROP)' );
       return;
     }
 
     const expectedParams = effectiveType.parameters &&
-      effectiveType.parameters.map(p => p.name || p) || [];
+      effectiveType.parameters.map( p => p.name || p ) || [];
 
     for (const param of actualParams) {
-      if (!expectedParams.includes(param)) {
+      if (!expectedParams.includes( param )) {
         // Whether the type ref itself is a builtin or a custom type with a builtin as base.
         let variant;
         if ((art.type?._artifact || art._effectiveType).builtin)
@@ -176,18 +180,18 @@ function check( model ) {
         else // effectiveType is not a builtin -> array or structured
           variant = 'non-scalar';
 
-        error('type-unexpected-argument', [ art[param].location, user ], {
+        error( 'type-unexpected-argument', [ art[param].location, user ], {
           '#': variant, prop: param, art: art.type || art._effectiveType, type: effectiveType,
-        });
+        } );
         break; // Avoid spam: Only emit the first error.
       }
-      else if (!typeParameters.expectedLiteralsFor[param].includes(art[param].literal)) {
-        error('type-unexpected-argument', [ art[param].location, user ], {
+      else if (!typeParameters.expectedLiteralsFor[param].includes( art[param].literal )) {
+        error( 'type-unexpected-argument', [ art[param].location, user ], {
           '#': 'incorrect-type',
           prop: param,
           code: art[param].literal,
           names: typeParameters.expectedLiteralsFor[param],
-        });
+        } );
         break; // Avoid spam: Only emit the first error.
       }
     }
@@ -195,8 +199,8 @@ function check( model ) {
 
   function requireExplicitTypeInSqlCast( art, user ) {
     if (!art.type) {
-      error('expr-missing-type', [ art.location, user ], { },
-            'Missing type in SQL cast function');
+      error( 'expr-missing-type', [ art.location, user ], { },
+             'Missing type in SQL cast function' );
     }
   }
 
@@ -205,9 +209,9 @@ function check( model ) {
       const type = elem._effectiveType;
       // See discussion issue #6520: should we allow all scalar types?
       if (!type || !type.builtin || type.category !== 'string') {
-        info('ref-expecting-localized-string', [ elem.type?.location, elem ],
-             { keyword: 'localized' },
-             'Expecting a string type in combination with keyword $(KEYWORD)');
+        info( 'ref-expecting-localized-string', [ elem.type?.location, elem ],
+              { keyword: 'localized' },
+              'Expecting a string type in combination with keyword $(KEYWORD)' );
       }
     }
 
@@ -217,36 +221,35 @@ function check( model ) {
       // original element is localized but not key, as that would have
       // already resulted in a warning by localized.js
       if (elem._origin?.localized?.val && !elem._origin.key?.val) {
-        warning('def-ignoring-localized', [ elem.key.location, elem ], { keyword: 'localized' },
-                'Keyword $(KEYWORD) is ignored for primary keys');
+        warning( 'def-ignoring-localized', [ elem.key.location, elem ], { keyword: 'localized' },
+                 'Keyword $(KEYWORD) is ignored for primary keys' );
       }
     }
   }
 
   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)
-      visitSubExpression(query.from, query, checkGenericExpression);
+      visitSubExpression( query.from, query, checkGenericExpression );
 
     if (query.where)
-      visitExpression(query.where, query, checkGenericExpression);
+      visitExpression( query.where, query, checkGenericExpression );
 
     if (query.groupBy) {
       for (const groupByEntry of query.groupBy)
-        visitExpression(groupByEntry, query, checkGenericExpression);
+        visitExpression( groupByEntry, query, checkGenericExpression );
     }
     if (query.having)
-      visitExpression(query.having, query, checkGenericExpression);
+      visitExpression( query.having, query, checkGenericExpression );
 
     if (query.orderBy) {
       for (const orderByEntry of query.orderBy)
-        visitExpression(orderByEntry, query, checkGenericExpression);
+        visitExpression( orderByEntry, query, checkGenericExpression );
     }
     if (query.mixin) {
       for (const mixinName in query.mixin)
-        checkAssociation(query.mixin[mixinName]);
+        checkAssociation( query.mixin[mixinName] );
     }
   }
 
@@ -265,8 +268,8 @@ function check( model ) {
     // Special handling to print a more detailed error message.
     // Other cases like `null` as enum value are handled in `checkEnumValueType()`
     if (type === 'enum') {
-      warning('ref-unexpected-enum', [ loc, enumNode ], {},
-              'References to other values are not allowed as enum values');
+      warning( 'ref-unexpected-enum', [ loc, enumNode ], {},
+               'References to other values are not allowed as enum values' );
     }
   }
 
@@ -297,17 +300,17 @@ function check( model ) {
       else if (type.items)
         typeClass = 'items';
 
-      error('type-invalid-enum', [ enumNode.type.location, enumNode ], { '#': typeClass }, {
+      error( 'type-invalid-enum', [ enumNode.type.location, enumNode ], { '#': typeClass }, {
         std: 'Only builtin types are allowed as enums',
         binary: 'Binary types are not allowed as enums',
         relation: 'Relational types are not allowed as enums',
         struct: 'Structured types are not allowed as enums',
         items: 'Arrayed types are not allowed as enums',
-      });
+      } );
       return;
     }
 
-    checkEnumValue(enumNode);
+    checkEnumValue( enumNode );
   }
 
   /**
@@ -327,16 +330,16 @@ function check( model ) {
 
     if (!isString) {
       // Non-string enums MUST have a value as the value is only deducted for string types.
-      const emptyValue = Object.keys(enumNode.enum)
-        .find(name => !enumNode.enum[name].value);
+      const emptyValue = Object.keys( enumNode.enum )
+        .find( name => !enumNode.enum[name].value );
       if (emptyValue) {
         const failedEnum = enumNode.enum[emptyValue];
-        warning('type-missing-value', [ failedEnum.location, failedEnum ], {
+        warning( 'type-missing-value', [ failedEnum.location, failedEnum ], {
           '#': isNumeric ? 'numeric' : 'std', name: emptyValue,
         }, {
           std: 'Missing value for non-string enum element $(NAME)',
           numeric: 'Missing value for numeric enum element $(NAME)',
-        });
+        } );
       }
     }
 
@@ -353,17 +356,17 @@ function check( model ) {
           (element.value.literal !== expectedType) &&
           (element.value.literal !== 'enum');
 
-    for (const key of Object.keys(enumNode.enum)) {
+    for (const key of Object.keys( enumNode.enum )) {
       const element = enumNode.enum[key];
-      if (hasWrongType(element)) {
+      if (hasWrongType( element )) {
         const actualType = element.value.literal;
-        warning('type-unexpected-value', [ element.value.location, element ], {
-          '#': expectedType, name: key, prop: actualType,
+        warning( 'type-unexpected-value', [ element.value.location, element ], {
+          '#': expectedType, name: key, prop: actualType || 'unknown',
         }, {
           std: 'Incorrect value type $(PROP) for enum element $(NAME)', // Not used
           number: 'Expected numeric value for enum element $(NAME) but was $(PROP)',
           string: 'Expected string value for enum element $(NAME) but was $(PROP)',
-        });
+        } );
       }
     }
   }
@@ -392,18 +395,18 @@ function check( model ) {
    * @param {XSN.Artifact} element
    */
   function checkLocalizedSubElement( element ) {
-    if (element._parent.kind !== 'element')
+    if (element._parent?.kind !== 'element')
       return;
 
     const isLocalizedSubElement = element.localized?.val;
     if (isLocalizedSubElement || element.type?._artifact?.localized?.val) {
       const loc = isLocalizedSubElement ? element.localized.location : element.type.location;
-      warning('localized-sub-element', [ loc, element ],
-              { type: element.type, '#': isLocalizedSubElement ? 'std' : 'type' },
-              {
-                std: 'Keyword "localized" is ignored for sub elements',
-                type: 'Keyword "localized" in type $(TYPE) is ignored for sub elements',
-              } );
+      warning( 'localized-sub-element', [ loc, element ],
+               { type: element.type, '#': isLocalizedSubElement ? 'std' : 'type' },
+               {
+                 std: 'Keyword "localized" is ignored for sub elements',
+                 type: 'Keyword "localized" in type $(TYPE) is ignored for sub elements',
+               } );
     }
   }
 
@@ -429,51 +432,18 @@ function check( model ) {
       }
     }
 
-    // Min cardinality must be a non-negative number
-    // Note: Already checked by parser (syntax error if -1 is used) and
-    //       from-csn.json (expected non-negative number)
-    for (const prop of [ 'sourceMin', 'targetMin' ]) {
-      if (art.cardinality[prop]) {
-        const { literal, val, location } = art.cardinality[prop];
-        if (!(literal === 'number' && val >= 0))
-          error( 'type-invalid-cardinality', [ location, art ], { '#': prop, prop: val } );
-      }
-    }
-
     // If provided, min cardinality must not exceed max cardinality (note that
     // '*' is considered to be >= any number)
     const pair = [
       [ 'sourceMin', 'sourceMax', 'sourceVal' ],
       [ 'targetMin', 'targetMax', 'targetVal' ],
     ];
-    pair.forEach(([ lhs, rhs, variant ]) => {
+    pair.forEach( ([ lhs, rhs, variant ]) => {
       if (art.cardinality[lhs] && art.cardinality[rhs] &&
           art.cardinality[rhs].literal === 'number' &&
           art.cardinality[lhs].val > art.cardinality[rhs].val)
         error( 'type-invalid-cardinality', [ art.cardinality.location, art ], { '#': variant } );
-    });
-  }
-
-  // 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 ) {
-    const art = query._main;    // TODO - remove, use query for semantic location
-    for (const groupByEntry of query.groupBy || []) {
-      if (groupByEntry._artifact && groupByEntry._artifact._effectiveType &&
-          groupByEntry._artifact._effectiveType.on) {
-        // Unmanaged association - complain
-        error(null, [ groupByEntry.location, art ], {},
-              'Unmanaged associations are not allowed in GROUP BY');
-      }
-    }
-    for (const orderByEntry of query.orderBy || []) {
-      if (orderByEntry._artifact && orderByEntry._artifact._effectiveType &&
-          orderByEntry._artifact._effectiveType.on) {
-        // Unmanaged association - complain
-        error(null, [ orderByEntry.location, art ], {},
-              'Unmanaged associations are not allowed in ORDER BY');
-      }
-    }
+    } );
   }
 
   function checkAssociation( elem ) {
@@ -486,8 +456,8 @@ function check( model ) {
       for (const k in elem.foreignKeys) {
         ++fkCount;
         const key = elem.foreignKeys[k].targetElement;
-        if (key && isVirtualElement(key._artifact))
-          error('ref-unexpected-virtual', [ key.location, elem ], { '#': 'fkey' });
+        if (key && isVirtualElement( key._artifact ))
+          error( 'ref-unexpected-virtual', [ key.location, elem ], { '#': 'fkey' } );
         else if (key._artifact?.$syntax === 'calc' && !key._artifact.value.stored?.val)
           error( 'ref-unexpected-calculated', [ key.location, elem ], { '#': 'fkey' } );
       }
@@ -508,7 +478,7 @@ function check( model ) {
         } );
       }
       else {
-        const fkName = Object.keys(elem.foreignKeys)[0];
+        const fkName = Object.keys( elem.foreignKeys )[0];
         if (elem.foreignKeys[fkName].targetElement._artifact?._effectiveType?.elements) {
           error( 'type-unexpected-default', [ elem.default.location, elem ], {
             '#': 'structured', keyword: 'default', name: fkName,
@@ -517,7 +487,7 @@ function check( model ) {
       }
     }
 
-    checkOnCondition(elem);
+    checkOnCondition( elem );
   }
 
   function getBinaryOp( cond ) {
@@ -543,18 +513,18 @@ function check( model ) {
       const finalType = artifact.type._artifact._effectiveType || artifact.type._artifact;
 
       if (artifact.items && !finalType.items) {
-        warning('type-items-mismatch', [ artifact.type.location, artifact ],
-                { type: artifact.type, prop: 'items' },
-                'Used type $(TYPE) is not arrayed and conflicts with $(PROP) property');
+        warning( 'type-items-mismatch', [ artifact.type.location, artifact ],
+                 { type: artifact.type, prop: 'items' },
+                 'Used type $(TYPE) is not arrayed and conflicts with $(PROP) property' );
       }
       else if (artifact.elements && !finalType.elements) {
-        warning('type-elements-mismatch', [ artifact.type.location, artifact ],
-                { type: artifact.type, prop: 'elements' },
-                'Used type $(TYPE) is not structured and conflicts with $(PROP) property');
+        warning( 'type-elements-mismatch', [ artifact.type.location, artifact ],
+                 { type: artifact.type, prop: 'elements' },
+                 'Used type $(TYPE) is not structured and conflicts with $(PROP) property' );
       }
     }
     if (artifact.items)
-      checkTypeStructure(artifact.items);
+      checkTypeStructure( artifact.items );
   }
 
   /**
@@ -571,7 +541,7 @@ function check( model ) {
       if (element.$inferred !== 'include') {
         for (const include of def.includes) {
           if (include._artifact?.elements?.[name] !== undefined)
-            checkElementOverride( element, include._artifact.elements[name]);
+            checkElementOverride( element, include._artifact.elements[name] );
         }
       }
     }
@@ -586,12 +556,12 @@ function check( model ) {
         const name = elem.name.id;
         // Position at type/struct, not name
         const loc = elem.type?.location || elem.elements?.[$location] || elem.location;
-        error('ref-invalid-override', [ loc, elem ],
-              { '#': prop, art: original._main, name });
+        error( 'ref-invalid-override', [ loc, elem ],
+               { '#': prop, art: original._main, name } );
         return false;
       }
       else if (original.elements &&
-               !checkSubStructureOverride(elem, elem.elements, original.elements)) {
+               !checkSubStructureOverride( elem, elem.elements, original.elements )) {
         return false;
       }
       return true;
@@ -606,10 +576,10 @@ function check( model ) {
         const orig = originals[element];
         if (elem === undefined) {
           const loc = [ elements[$location], user ];
-          error('ref-invalid-override', loc, { '#': 'missing', id: user.name.id, name: element });
+          error( 'ref-invalid-override', loc, { '#': 'missing', id: user.name.id, name: element } );
           return false; // only report once
         }
-        else if (!checkElementOverride(elem, orig)) {
+        else if (!checkElementOverride( elem, orig )) {
           return false;
         }
       }
@@ -626,8 +596,8 @@ function check( model ) {
    * @returns {void}
    */
   function checkGenericExpression( xpr, user ) {
-    checkExpressionNotVirtual(xpr, user);
-    checkExpressionAssociationUsage(xpr, user, false);
+    checkExpressionNotVirtual( xpr, user );
+    checkExpressionAssociationUsage( xpr, user, false );
     if (xpr.op?.val === 'cast') {
       requireExplicitTypeInSqlCast( xpr, user );
       checkTypeArguments( xpr, user );
@@ -635,25 +605,24 @@ function check( model ) {
   }
 
   function checkExpressionNotVirtual( xpr, user ) {
-    if (xpr._artifact && isVirtualElement(xpr._artifact))
-      error('ref-unexpected-virtual', [ xpr.location, user ], { '#': 'expr' });
+    if (xpr._artifact && isVirtualElement( xpr._artifact ))
+      error( 'ref-unexpected-virtual', [ xpr.location, user ], { '#': 'expr' } );
   }
 
   function checkOnCondition( elem ) {
+    if (elem.$inferred === 'localized')
+      return; // ignore
+
     // TODO: Move to checkAssociation
     if (elem.on && !elem.on.$inferred) {
-      visitExpression(elem.on, elem, (xpr, user) => {
-        checkExpressionNotVirtual(xpr, user);
-        checkExpressionAssociationUsage(xpr, user, true);
+      visitExpression( elem.on, elem, (xpr, user) => {
+        checkExpressionNotVirtual( xpr, user );
+        checkExpressionAssociationUsage( xpr, user, true );
         // Essential check. Dependency handling for `on` conditions must change if
         // this is allowed.  See test3/Associations/Dependencies/.
         if (xpr._artifact?.$syntax === 'calc' && !xpr._artifact.value.stored?.val)
           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: '=' } );
-      }
+      } );
     }
   }
 
@@ -666,37 +635,41 @@ function check( model ) {
       requireExplicitTypeInSqlCast( elem.value, elem );
       checkTypeArguments( elem.value, elem );
     }
-    visitSubExpression(elem.value, elem, (xpr) => {
+    visitSubExpression( elem.value, elem, (xpr) => {
       checkGenericExpression( xpr, elem );
-    });
+    } );
   }
 
   function checkCalculatedElementValue( elem ) {
-    visitExpression(elem.value, elem, (xpr, user) => {
-      if (xpr._artifact) { // we only need to check artifact references
+    visitExpression( elem.value, elem, (xpr, user) => {
+      // We only need to check artifact references.  To avoid false positives and conflicts
+      // with $self comparison-checks, ignore bare $self.
+      const isArtRef = xpr._artifact && !(xpr.path?.length === 1 &&
+          xpr.path[0]._navigation?.kind === '$self');
+      if (isArtRef) {
         const sourceLoc = xpr.path?.[xpr.path.length - 1].location || xpr.location;
-        checkExpressionNotVirtual(xpr, user);
+        checkExpressionNotVirtual( xpr, user );
         // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
         // And users can't change structured to non-structured elements.
         if (!elem.$inferred && xpr._artifact._effectiveType?.elements) {
-          error('ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
+          error( 'ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
         }
         else if (xpr._artifact.target !== undefined) {
-          const variant = isComposition(model, xpr._artifact) ? 'expr-comp' : 'expr';
-          error('ref-unexpected-assoc', [ sourceLoc, elem ], { '#': variant });
+          const variant = isComposition( model, xpr._artifact ) ? 'expr-comp' : 'expr';
+          error( 'ref-unexpected-assoc', [ sourceLoc, elem ], { '#': variant } );
         }
         else if (xpr._artifact.localized?.val && elem.value.stored?.val) {
-          error('ref-unexpected-localized', [ sourceLoc, elem ], { '#': 'calc' });
+          error( 'ref-unexpected-localized', [ sourceLoc, elem ], { '#': 'calc' } );
         }
       }
-    });
+    } );
     // Calculated elements must not refer to keys, because that may lead to another
     // key in an SQL view, which is missing in OData (for on-read).
     // 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');
+    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' );
     }
   }
 
@@ -758,21 +731,15 @@ function check( model ) {
     // 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);
+    const args = Array.isArray( xpr.args ) ? xpr.args : Object.values( xpr.args );
+    const isNotSelfComparison = args.length > 0 && xpr.op?.val !== 'xpr' &&
+        !isBinaryDollarSelfComparisonWithAssoc( xpr );
 
     if (isNotSelfComparison) {
+      const op = getBinaryOp( xpr );
       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 (arg && !(op?.val !== '=' && isDollarSelfOrProjectionOperand( arg )))
+          checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail );
       }
     }
   }
@@ -782,18 +749,13 @@ function check( model ) {
     // 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') {
-        const variant = isComposition(model, arg._artifact) ? 'expr-comp' : 'expr';
-        error('ref-unexpected-assoc', [ arg.location, user ], { '#': variant });
+        const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
+        error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
       }
     }
-    else if (!allowAssocTail && isAssociationOperand(arg)) {
-      const variant = isComposition(model, arg._artifact) ? 'expr-comp' : 'expr';
-      error('ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
-    }
-
-    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');
+    else if (!allowAssocTail && isAssociationOperand( arg )) {
+      const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
+      error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
     }
   }
 
@@ -827,13 +789,17 @@ function check( model ) {
     // One argument must be "$self" and the other an assoc
     if (xpr.op.val === '=' && xpr.args.length === 2) {
       // Tree-ish expression from the compiler (not augmented)
-      return (isAssociationOperand(xpr.args[0]) && isDollarSelfOrProjectionOperand(xpr.args[1]) ||
-              isAssociationOperand(xpr.args[1]) && isDollarSelfOrProjectionOperand(xpr.args[0]));
+      // eslint-disable-next-line max-len
+      return (isAssociationOperand( xpr.args[0] ) && isDollarSelfOrProjectionOperand( xpr.args[1] ) ||
+      // eslint-disable-next-line max-len
+              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]));
+      // eslint-disable-next-line max-len
+      return (isAssociationOperand( xpr.args[0] ) && isDollarSelfOrProjectionOperand( xpr.args[2] ) ||
+      // eslint-disable-next-line max-len
+             isAssociationOperand( xpr.args[2] ) && isDollarSelfOrProjectionOperand( xpr.args[0] ));
     }
 
     // Nothing else qualifies
@@ -858,7 +824,7 @@ function check( model ) {
     let fromArtifact = null;
     let pathStepsFound = 0;
     for (let i = anno.name.path.length; i > 0; i--) {
-      const absoluteName = anno.name.path.slice(0, i).map(path => path.id).join('.');
+      const absoluteName = anno.name.path.slice( 0, i ).map( path => path.id ).join( '.' );
       if (model.vocabularies[absoluteName]) {
         fromArtifact = model.vocabularies[absoluteName];
         pathStepsFound = i;
@@ -871,8 +837,8 @@ function check( model ) {
       return;
     }
 
-    const { artifact, endOfPath } = resolvePathFrom(anno.name.path.slice(pathStepsFound),
-                                                    fromArtifact);
+    const { artifact, endOfPath } = resolvePathFrom( anno.name.path.slice( pathStepsFound ),
+                                                     fromArtifact );
 
     // Check what we actually want to check
     checkAnnotationAssignment( anno, artifact, endOfPath, art );
@@ -892,33 +858,33 @@ function check( model ) {
 
     // Element must exist in annotation
     if (!elementDecl) {
-      warning(null, [ anno.location || anno.name.location, art ],
-              { name: pathName(anno.name.path), anno: annoDecl.name.absolute },
-              'Element $(NAME) not found for annotation $(ANNO)');
+      warning( null, [ anno.location || anno.name.location, art ],
+               { name: pathName( anno.name.path ), anno: annoDecl.name.absolute },
+               'Element $(NAME) not found for annotation $(ANNO)' );
       return;
     }
 
     // Sanity checks
     if (!elementDecl._effectiveType)
-      throw new CompilerAssertion(`Expecting annotation declaration to have _finalType: ${ JSON.stringify(annoDecl) }`);
+      throw new CompilerAssertion(`Expecting annotation declaration to have _finalType: ${ JSON.stringify( annoDecl ) }`);
 
 
     // Must have literal or path unless it is a boolean
-    if (!anno.literal && !anno.path && getFinalTypeNameOf(elementDecl) !== 'cds.Boolean') {
+    if (!anno.literal && !anno.path && getFinalTypeNameOf( elementDecl ) !== 'cds.Boolean') {
       if (elementDecl.type?._artifact.name.absolute) {
-        warning('anno-expecting-value', [ anno.location || anno.name.location, art ],
-                { '#': 'type', type: elementDecl.type._artifact });
+        warning( 'anno-expecting-value', [ anno.location || anno.name.location, art ],
+                 { '#': 'type', type: elementDecl.type._artifact } );
       }
       else {
-        warning('anno-expecting-value', [ anno.location || anno.name.location, art ],
-                { '#': 'std', anno: anno.name.absolute });
+        warning( 'anno-expecting-value', [ anno.location || anno.name.location, art ],
+                 { '#': 'std', anno: anno.name.absolute } );
       }
 
       return;
     }
 
     // Value must be assignable to type
-    checkValueAssignableTo(anno, anno, elementDecl, art);
+    checkValueAssignableTo( anno, anno, elementDecl, art );
   }
 
   // Check that annotation assignment 'value' (having 'path or 'literal' and
@@ -937,12 +903,12 @@ function check( model ) {
     if (elementDecl._effectiveType.items) {
       // Make sure we have an array value
       if (value.literal !== 'array') {
-        warning(null, loc, { anno }, 'An array value is required for annotation $(ANNO)');
+        warning( null, loc, { anno }, 'An array value is required for annotation $(ANNO)' );
         return;
       }
       // Check each element
       for (const valueItem of value.val)
-        checkValueAssignableTo(value, valueItem, elementDecl._effectiveType.items, art);
+        checkValueAssignableTo( value, valueItem, elementDecl._effectiveType.items, art );
 
       return;
     }
@@ -950,7 +916,7 @@ function check( model ) {
     // Struct expected (can only happen within arrays)?
     if (elementDecl._effectiveType.elements) {
       if (value.literal !== 'struct') {
-        warning(null, loc, { anno }, 'A struct value is required here for annotation $(ANNO)');
+        warning( null, loc, { anno }, 'A struct value is required here for annotation $(ANNO)' );
         return;
       }
       // FIXME: Should check each element
@@ -959,44 +925,44 @@ function check( model ) {
 
     // Handle each (primitive) expected element type separately
     // TODO: Don't rely on name; use actual type
-    const type = getFinalTypeNameOf(elementDecl);
-    if (builtins.isStringTypeName(type)) {
+    const type = getFinalTypeNameOf( elementDecl );
+    if (builtins.isStringTypeName( type )) {
       if (value.literal !== 'string' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum) {
-        warning(null, loc, { type, anno },
-                'A string value is required for type $(TYPE) for annotation $(ANNO)');
+        warning( null, loc, { type, anno },
+                 'A string value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isBinaryTypeName(type)) {
+    else if (builtins.isBinaryTypeName( type )) {
       if (value.literal !== 'string' && value.literal !== 'x') {
-        warning(null, loc, { type, anno },
-                'A hexadecimal string value is required for type $(TYPE) for annotation $(ANNO)');
+        warning( null, loc, { type, anno },
+                 'A hexadecimal string value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isNumericTypeName(type)) {
+    else if (builtins.isNumericTypeName( type )) {
       if (value.literal !== 'number' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum) {
-        warning(null, loc, { type, anno },
-                'A numerical value is required for type $(TYPE) for annotation $(ANNO)');
+        warning( null, loc, { type, anno },
+                 'A numerical value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isDateOrTimeTypeName(type)) {
+    else if (builtins.isDateOrTimeTypeName( type )) {
       if (value.literal !== 'date' && value.literal !== 'time' &&
           value.literal !== 'timestamp' && value.literal !== 'string') {
-        warning(null, loc, { type, anno },
-                // eslint-disable-next-line max-len
-                'A date/time value or a string is required for type $(TYPE) for annotation $(ANNO)');
+        warning( null, loc, { type, anno },
+          // eslint-disable-next-line max-len
+                 'A date/time value or a string is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isBooleanTypeName(type)) {
+    else if (builtins.isBooleanTypeName( type )) {
       if (value.literal && value.literal !== 'boolean') {
-        warning(null, loc, { type, anno },
-                'A boolean value is required for type $(TYPE) for annotation $(ANNO)');
+        warning( null, loc, { type, anno },
+                 'A boolean value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isRelationTypeName(type) || builtins.isGeoTypeName(type)) {
-      warning(null, loc, { type, anno },
-              'Type $(TYPE) can\'t be assigned a value for annotation $(ANNO)');
+    else if (builtins.isRelationTypeName( type ) || builtins.isGeoTypeName( type )) {
+      warning( null, loc, { type, anno },
+               'Type $(TYPE) can\'t be assigned a value for annotation $(ANNO)' );
     }
     else if (!elementDecl._effectiveType.enum) {
       throw new CompilerAssertion(`Unknown primitive type name: ${ type }`);
@@ -1009,22 +975,22 @@ function check( model ) {
         // Enum symbol provided and expected
         if (!expectedEnum[value.sym.id]) {
           // ... but no such constant
-          warning(null, loc, { id: `#${ value.sym.id }`, anno }, 'Enum symbol $(ID) not found in enum for annotation $(ANNO)');
+          warning( null, loc, { id: `#${ value.sym.id }`, anno }, 'Enum symbol $(ID) not found in enum for annotation $(ANNO)' );
         }
       }
       else {
         // Enum symbol provided but not expected
-        warning(null, loc, { id: `#${ value.sym.id }`, type, anno },
-                'Can\'t use enum symbol $(ID) for non-enum type $(TYPE) for annotation $(ANNO)');
+        warning( null, loc, { id: `#${ value.sym.id }`, type, anno },
+                 'Can\'t use enum symbol $(ID) for non-enum type $(TYPE) for annotation $(ANNO)' );
       }
     }
     else if (expectedEnum) {
       // Enum symbol not provided but expected
-      const hasValidValue = Object.keys(expectedEnum)
-        .some(symbol => getEnumValue(expectedEnum[symbol]) === value.val);
+      const hasValidValue = Object.keys( expectedEnum )
+        .some( symbol => getEnumValue( expectedEnum[symbol] ) === value.val );
       if (!hasValidValue) {
         // ... and none of the valid enum symbols matches the value
-        warning(null, loc, { anno }, 'An enum value is required for annotation $(ANNO)');
+        warning( null, loc, { anno }, 'An enum value is required for annotation $(ANNO)' );
       }
     }
   }
@@ -1059,7 +1025,7 @@ function check( model ) {
     // Continue search with next path step
     const nextStepEnv = (from._effectiveType || from).artifacts ||
           from._effectiveType?.elements || [];
-    return resolvePathFrom(path.slice(1), nextStepEnv[path[0].id], result);
+    return resolvePathFrom( path.slice(1), nextStepEnv[path[0].id], result );
   }
 
   // TODO: remove
@@ -1094,7 +1060,7 @@ function checkSapCommonTextsAspects( model ) {
         elemref: 'locale',
         type: 'cds.String',
         othertype: 'sap.common.Locale',
-      });
+      } );
     }
   }
 }
@@ -1129,6 +1095,9 @@ function checkSapCommonLocale( model ) {
  * @param {(xpr: any, user: any, parentExpr: any) => void} callback
  */
 function visitExpression( xpr, user, callback ) {
+  if (!xpr)
+    return; // e.g. parse error
+
   callback( xpr, user, null );
   visitSubExpression( xpr, user, callback );
 }
@@ -1142,12 +1111,14 @@ function visitExpression( xpr, user, callback ) {
  */
 function visitSubExpression( xpr, user, callback ) {
   if (xpr.args) {
-    const args = Array.isArray(xpr.args) ? xpr.args : Object.values(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);
+      if (arg) { // null for parse errors
+        callback( arg, user, xpr.args );
+        // Recursively traverse the argument expression
+        visitSubExpression( arg, user, callback );
+      }
     }
   }
 
@@ -1155,7 +1126,7 @@ function visitSubExpression( xpr, user, callback ) {
     for (const arg of xpr.path) {
       if (arg.where) {
         callback( arg.where, user, arg );
-        visitSubExpression(arg.where, user, callback);
+        visitSubExpression( arg.where, user, callback );
       }
     }
   }