@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/checks.js

@@ -1,33 +1,37 @@
-// Checks on XSN performed during compile()
-//
-// TODO: to be reworked.  It is not the intention to include more checks,
-// rather the opposite.  Therefore, this file will become smaller.
+// Checks on XSN performed during compile() that are useful for the user
+// but not necessary for the compiler to work.
 
-// Major issues so far:
+// TODO: Major issues so far:
 //  * Different ad-hoc value/type checks (associations, enum, ...) -
 //    specify a proper one and use consistently
 //  * Using name comparisons instead proper object comparisons.
 //  * effectiveType issues.
 //  * Often forgot to consider CSN input
-//  * Bad message texts/locations.
 
 'use strict';
 
-// const { hasArtifactTypeInformation } = require('../model/csnUtils')
 const builtins = require('../compiler/builtins');
 const {
   forEachGeneric,
   forEachDefinition,
   forEachMember,
+  forEachMemberRecursively,
+  isBetaEnabled,
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { pathName } = require('./utils');
-const { forEachMemberRecursively } = require('../model/csnUtils');
-const $location = Symbol.for('cds.$location');
+const { typeParameters } = require('./builtins');
 
-function check( model ) {       // = XSN
+const $location = Symbol.for( 'cds.$location' );
+
+/**
+ * Run compiler checks on the given XSN model.
+ *
+ * @param {XSN.Model} model
+ */
+function check( model ) {
   const {
-    error, warning, message, info,
+    error, warning, info,
   } = model.$messageFunctions;
 
   checkSapCommonLocale( model );
@@ -35,34 +39,37 @@ function check( model ) {       // = XSN
 
   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 );
   }
 
   function checkAnnotationDefinition( art ) {
+    // TODO: Should we check elements similar to definition-elements as well?
     checkEnumType( art );
     forEachMemberRecursively( art, (member) => {
       if (member.localized?.val)
         warning( 'def-unexpected-localized-anno', [ member.localized.location, member ] );
-    });
-    // TODO: Should we check elements similar to definition-elements as well?
+    } );
   }
 
   function checkGenericConstruct( art ) {
     checkName( art );
+    checkTypeArguments( art );
     if (model.vocabularies) {
       Object.keys( art )
-        .filter( a => a.startsWith('@') )
+        .filter( a => a.startsWith( '@' ) )
         .forEach( a => checkAnnotationAssignment1( art, art[a] ) );
     }
-    checkTypeStructure(art);
+    checkTypeStructure( art );
+    checkAssociation( art ); // type def could be assoc
     if (art.kind === 'enum')
       checkEnum( art );
     checkEnumType( art );
@@ -75,106 +82,177 @@ function check( model ) {       // = XSN
     if (member.virtual?.val === true)
       parentProps.virtual = member.virtual;
 
-    checkGenericConstruct(member);
+    checkGenericConstruct( member );
 
     if (member.kind === 'element')
       checkElement( member, parentProps );
 
-    forEachMember( member, m => checkMember(m, parentProps) );
+    forEachMember( member, m => checkMember( m, parentProps ) );
   }
 
   function checkVirtualKey( elem, parentProps ) {
-    const isKey = parentProps.key || (elem.key?.val && elem.key);
-    const isVirtual = parentProps.virtual?.val || (elem.virtual?.val && elem.virtual);
+    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', name: elem.name.element, prop: 'key' });
+      error( 'def-unexpected-key', [ isKey.location, elem ],
+             { '#': 'virtual', art: elem.name.element, prop: 'key' } );
     }
   }
 
   function checkElement( elem, parentProps ) {
-    checkLocalizedSubElement(elem);
-    checkVirtualKey(elem, parentProps);
-    checkForUnmanagedAssociationsAsKey( elem, parentProps );
+    checkLocalizedSubElement( elem );
+    checkVirtualKey( elem, parentProps );
     checkLocalizedElement( elem );
-    checkAssociation( elem );
 
     if (elem.value) {
       if (elem._main.query)
-        checkSelectItemValue(elem);
+        checkSelectItemValue( elem );
       else if (elem.$syntax === 'calc')
         checkCalculatedElementValue( elem );
     }
 
-    checkCardinality(elem); // TODO: also for assoc types
+    checkCardinality( elem ); // TODO: also for assoc types
   }
 
 
   function checkName( construct ) { // TODO: move to define.js
     if (model.options.$skipNameCheck)
       return;
-    // TODO: Move a corrected version of this check to definer (but do not rely
-    // on it!): The code below misses to consider CSN input.
-    if (construct.name.id && construct.name.id.indexOf('.') !== -1) {
-      // TODO: No, we should not forbid this
-      error(null, [ construct.name.location, construct ], {},
-            'The character \'.\' is not allowed in identifiers');
+    // 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.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' );
+      }
+    }
+  }
+
+
+  /**
+   * Check the type arguments on `art`, e.g. cds.Decimal can't have a `length`, structures
+   * can't have `precision`, etc.
+   *
+   * @param {XSN.Artifact} art
+   * @param {XSN.Artifact} user
+   */
+  function checkTypeArguments( art, user = art ) {
+    if (art.builtin || art.kind === 'context' || art.kind === 'service')
+      return;
+
+    if (art.items)
+      checkTypeArguments( art.items, art );
+
+    const actualParams = typeParameters.list.filter( param => art[param] !== undefined );
+    if (actualParams.length === 0)
+      return;
+
+    const typeArt = art.type?._artifact || art;
+
+    // Note: `_effectiveType` points to `art` itself, if it is an enum type,
+    //       descend to the origin in this case.
+    let effectiveType = typeArt._effectiveType;
+    while (effectiveType?.enum)
+      effectiveType = (effectiveType._origin || effectiveType.type?._artifact)?._effectiveType;
+
+    if (!effectiveType) {
+      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)' );
+      return;
+    }
+
+    const expectedParams = effectiveType.parameters &&
+      effectiveType.parameters.map( p => p.name || p ) || [];
+
+    for (const param of actualParams) {
+      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)
+          variant = 'builtin';
+        else if (effectiveType.builtin)
+          variant = 'type';
+        else // effectiveType is not a builtin -> array or structured
+          variant = 'non-scalar';
+
+        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 ], {
+          '#': 'incorrect-type',
+          prop: param,
+          code: art[param].literal,
+          names: typeParameters.expectedLiteralsFor[param],
+        } );
+        break; // Avoid spam: Only emit the first error.
+      }
+    }
+  }
+
+  function requireExplicitTypeInSqlCast( art, user ) {
+    if (!art.type) {
+      error( 'expr-missing-type', [ art.location, user ], { },
+             'Missing type in SQL cast function' );
     }
   }
 
   function checkLocalizedElement( elem ) {
-    // if it is directly a localized element
-    if (elem.localized && elem.localized.val) {
+    if (elem.localized?.val) {
       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)' );
       }
     }
-    // "key" keyword at localized element in SELECT list.
+
     // TODO: This check should be moved to localized.js
-    if (elem.key && elem.key.val && elem._main && elem._main.query) {
+    // "key" keyword at localized element in SELECT list.
+    if (elem.key?.val && elem._main?.query) {
       // original element is localized but not key, as that would have
-      // already resulted in a warning
-      if (elem._origin && elem._origin.localized && elem._origin.localized.val &&
-        ( !elem._origin.key || !elem._origin.key.val)) {
-        warning('localized-key', [ elem.key.location, elem ], { keyword: 'localized' },
-                'Keyword $(KEYWORD) is ignored for primary keys');
+      // 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' );
       }
     }
   }
 
   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] );
     }
   }
 
-  // Individual checks -------------------------------------------------------
-
   /**
    * The enumNode is a single enum element and not the whole type.
    *
@@ -190,8 +268,8 @@ function check( model ) {       // = XSN
     // Special handling to print a more detailed error message.
     // Other cases like `null` as enum value are handled in `checkEnumValueType()`
     if (type === 'enum') {
-      warning('enum-value-ref', [ loc, enumNode ], {}, // TODO: make this an error in v4
-              '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' );
     }
   }
 
@@ -201,8 +279,7 @@ function check( model ) {       // = XSN
     enumNode = enumNode.enum ? enumNode : enumNode.items;
     if (!enumNode || !enumNode.enum)
       return;
-    const type = enumNode.type && enumNode.type._artifact &&
-                 enumNode.type._artifact._effectiveType;
+    const type = enumNode?.type?._artifact?._effectiveType;
 
     // We can't distinguish (in CSN) between these two cases:
     //   type Base : String enum { b;a = 'abc'; };
@@ -212,64 +289,57 @@ function check( model ) {       // = XSN
     if (!type || type.enum)
       return;
 
-    const name = type.name.absolute;
-
     // All builtin types are allowed except binary and relational types.
     // The latter are "internal" types.
-    const isBinary = builtins.isBinaryTypeName(name);
-
-    if (!type.builtin || type.internal || isBinary) {
-      let typeclass = 'std';
-
-      if (isBinary)
-        typeclass = 'binary';
-      else if (builtins.isRelationTypeName(name))
-        typeclass = 'relation';
+    if (!type.builtin || type.internal || type.category === 'binary') {
+      let typeClass = 'std';
+      if (type.category === 'binary' || type.category === 'relation')
+        typeClass = type.category;
       else if (type.elements)
-        typeclass = 'struct';
+        typeClass = 'struct';
       else if (type.items)
-        typeclass = 'items';
+        typeClass = 'items';
 
-      error('enum-invalid-type', [ 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 );
   }
 
   /**
-   * Check the given enum's elements and their values.  For example
+   * Check the given enum's elements and their values.  For example,
    * whether the value types are valid for the used enum type.
    * `enumNode` can be also be `type.items` if the type is an arrayed enum.
    *
    * @param {XSN.Definition} enumNode
    */
   function checkEnumValue( enumNode ) {
-    const type = enumNode.type && enumNode.type._artifact &&
-                 enumNode.type._artifact._effectiveType;
-    if (!enumNode.enum || !type || !type.builtin)
+    const type = enumNode.type?._artifact?._effectiveType;
+    if (!type || !enumNode.enum || !type.builtin)
       return;
 
-    const isNumeric = builtins.isNumericTypeName(type.name.absolute);
-    const isString = builtins.isStringTypeName(type.name.absolute);
+    const isNumeric = type.category === 'decimal' || type.category === 'integer';
+    const isString = type.category === 'string';
 
     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('enum-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)',
-                });
+        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)',
+        } );
       }
     }
 
@@ -286,29 +356,31 @@ function check( model ) {       // = XSN
           (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))
-        continue;
-
-      const actualType = element.value.literal;
-      warning('enum-value-type', [ element.value.location, element ],
-              { '#': expectedType, name: key, prop: actualType }, {
-                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)',
-              });
+      if (hasWrongType( element )) {
+        const actualType = element.value.literal;
+        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)',
+        } );
+      }
     }
   }
 
-  // TODO: check inside compiler as it is a compiler restriction - improve
   /**
+   * TODO: check inside compiler as it is a compiler restriction - improve
+   * TODO: Recursive check; use "parentProps" as other member checks
+   *
    * Non-recursive check if sub-elements have a "localized" keyword since this is
    * not yet supported.
    *
    * This check is not recursive to avoid a runtime overhead. Because of this it fails
    * to detect scenarios with indirections, e.g.
-   *
+   *   ```cds
    *   type L : localized String;
    *   type L1 : L;
    *   type L2 : L1;
@@ -318,153 +390,104 @@ function check( model ) {       // = XSN
    *       subElement : L2;
    *     }
    *   }
+   *   ```
    *
    * @param {XSN.Artifact} element
    */
   function checkLocalizedSubElement( element ) {
-    if (element._parent.kind !== 'element')
+    if (element._parent?.kind !== 'element')
       return;
 
-    const isLocalizedSubElement = element.localized && element.localized.val;
-    if (isLocalizedSubElement || (element.type && isTypeLocalized(element.type._artifact))) {
+    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',
-              } );
-    }
-    return;
-
-    // TODO: Recursive check
-    function isTypeLocalized( type ) {
-      return (type && type.localized && type.localized.val);
+      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',
+               } );
     }
   }
 
   /**
-   * Check that a primary key element is not an unmanaged association or
-   * contains unmanaged associations
+   * Check that min and max cardinalities of 'art' have legal values
    *
-   * 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.
+   * TODO: move to define.js or parsers
    *
-   * @param {any} element Element to check recursively
+   * @param {XSN.Artifact} art
    */
-  function checkForUnmanagedAssociationsAsKey( element, parentProps ) {
-    if (!parentProps.key?.val && !element.key?.val)
-      return;
-    if (element.targetAspect) {
-      // TODO: bad location / message
-      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', [ parentProps.key.location, element ], {},
-              // TODO: give semantics when error downgraded
-              'Unmanaged associations can\'t be used as primary key');
-    }
-  }
-
-  // Check that min and max cardinalities of 'elem' in 'art' have legal values
-  // TODO: move to define.js or parsers
-  function checkCardinality( elem ) {
-    if (!elem.cardinality)
+  function checkCardinality( art ) {
+    if (!art.cardinality)
       return;
 
     // Max cardinalities must be a positive number or '*'
     for (const prop of [ 'sourceMax', 'targetMax' ]) {
-      if (elem.cardinality[prop]) {
-        const { literal, val, location } = elem.cardinality[prop];
-        if (!(literal === 'number' && val > 0 ||
-              literal === 'string' && val === '*')) {
-          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val, newcode: '*' }, {
-            // eslint-disable-next-line max-len
-            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or $(NEWCODE)',
-            // eslint-disable-next-line max-len
-            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or $(NEWCODE)',
-            // eslint-disable-next-line max-len
-            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or $(NEWCODE)',
-          });
-        }
-      }
-    }
-
-    // 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 (elem.cardinality[prop]) {
-        const { literal, val, location } = elem.cardinality[prop];
-        if (!(literal === 'number' && val >= 0)) {
-          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
-            // eslint-disable-next-line max-len
-            std: 'Value $(CODE) is invalid for minimum cardinality, expecting a non-negative number',
-            // eslint-disable-next-line max-len
-            targetMin: 'Value $(CODE) is invalid for minimum target cardinality, expecting a non-negative number',
-            // eslint-disable-next-line max-len
-            sourceMin: 'Value $(CODE) is invalid for minimum source cardinality, expecting a non-negative number',
-          });
+      if (art.cardinality[prop]) {
+        const { literal, val, location } = art.cardinality[prop];
+        if (!(literal === 'number' && val > 0 || literal === 'string' && val === '*')) {
+          error( 'type-invalid-cardinality', [ location, art ],
+                 { '#': prop, prop: val, otherprop: '*' } );
         }
       }
     }
 
     // If provided, min cardinality must not exceed max cardinality (note that
     // '*' is considered to be >= any number)
-    const pair = [ [ 'sourceMin', 'sourceMax', 'source' ], [ 'targetMin', 'targetMax', 'target' ] ];
-    pair.forEach((p) => {
-      if (elem.cardinality[p[0]] && elem.cardinality[p[1]] &&
-          elem.cardinality[p[1]].literal === 'number' &&
-          elem.cardinality[p[0]].val > elem.cardinality[p[1]].val) {
-        error(null, [ elem.cardinality.location, elem ], { '#': p[2] }, {
-          std: 'Minimum cardinality must not be greater than maximum cardinality', // variant unused
-          source: 'Source minimum cardinality must not be greater than source maximum cardinality',
-          target: 'Target minimum cardinality must not be greater than target maximum cardinality',
-        });
-      }
-    });
-  }
-
-  // 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');
-      }
-    }
+    const pair = [
+      [ 'sourceMin', 'sourceMax', 'sourceVal' ],
+      [ 'targetMin', 'targetMax', 'targetVal' ],
+    ];
+    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 } );
+    } );
   }
 
   function checkAssociation( elem ) {
+    if (!elem.target && !elem.targetAspect)
+      return;
     // TODO: yes, a check similar to this could make it into the compiler)
     //       when virtual element is part of association
+    let fkCount = 0;
     if (elem.foreignKeys) {
       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' } );
       }
     }
+    if (elem.default) {
+      if (!isBetaEnabled( model.options, 'associationDefault' )) {
+        error( 'type-unsupported-default', [ elem.default.location, elem ], {
+          '#': isComposition( model, elem ) ? 'comp' : 'std',
+        }, {
+          std: 'Unsupported default value on an association',
+          comp: 'Unsupported default value on a composition',
+        } );
+      }
+      else if (elem.targetAspect || elem.on || fkCount !== 1) {
+        const variant = (elem.targetAspect && 'targetAspect') || (elem.on && 'onCond') || 'multi';
+        error( 'type-unexpected-default', [ elem.default.location, elem ], {
+          '#': variant, keyword: 'default', count: fkCount,
+        } );
+      }
+      else {
+        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,
+          } );
+        }
+      }
+    }
 
-    checkOnCondition(elem);
+    checkOnCondition( elem );
   }
 
   function getBinaryOp( cond ) {
@@ -473,8 +496,9 @@ function check( model ) {       // = XSN
       args[1] || op;
   }
 
-  // A function like this could be part of the compiler
   /**
+   * TODO: A function like this could be part of the compiler
+   *
    * Check that the given type has no conflicts between its `type` property
    * and its `elements` or `items` property. For example if `type` is not
    * structured but the artifact has an `elements` property then the user
@@ -485,22 +509,22 @@ function check( model ) {       // = XSN
   function checkTypeStructure( artifact ) {
     // Just a basic check. We do not check that the inner structure of `items`
     // is the same as the type but only that all are arrayed or structured.
-    if (artifact.type && artifact.type._artifact) {
+    if (artifact.type?._artifact) {
       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 );
   }
 
   /**
@@ -517,7 +541,7 @@ function check( model ) {       // = XSN
       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] );
         }
       }
     }
@@ -532,12 +556,12 @@ function check( model ) {       // = XSN
         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;
@@ -552,10 +576,10 @@ function check( model ) {       // = XSN
         const orig = originals[element];
         if (elem === undefined) {
           const loc = [ elements[$location], user ];
-          error('ref-invalid-override', loc, { '#': 'missing', id: user.name.id, name: element });
-          return false; // only report one
+          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;
         }
       }
@@ -564,8 +588,6 @@ function check( model ) {       // = XSN
   }
 
 
-  // Former checkExpressions.js ----------------------------------------------
-
   /**
    * Check a generic expression (or condition) for semantic validity.
    *
@@ -574,62 +596,80 @@ function check( model ) {       // = XSN
    * @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 );
+    }
   }
 
   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: '=' } );
-      }
+      } );
     }
   }
 
   function checkSelectItemValue( elem ) {
-    checkExpressionAssociationUsage(elem.value, elem, false);
-
-    visitSubExpression(elem.value, elem, (xpr) => {
-      checkExpressionNotVirtual(xpr, elem);
-      checkExpressionAssociationUsage(xpr, elem, false);
-    });
+    checkExpressionAssociationUsage( elem.value, elem, false );
+    // If a direct SQL-style cast() has no type, but type props, the compiler does not copy the type
+    // props/does not use the cast().  To avoid duplicate messages, only run this check if there is
+    // no explicit type, as otherwise we will check the cast() twice (once here, once via element).
+    if (elem.value?.op?.val === 'cast' && !elem.type) {
+      requireExplicitTypeInSqlCast( elem.value, elem );
+      checkTypeArguments( elem.value, elem );
+    }
+    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 && isStructuredElement(xpr._artifact))
-          error('ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
-        else if (xpr._artifact.target !== undefined)
-          error('ref-unexpected-assoc', [ sourceLoc, elem ], { '#': 'expr' });
-        else if (xpr._artifact.localized?.val)
-          error('ref-unexpected-localized', [ sourceLoc, elem ], { '#': 'calc' });
+        if (!elem.$inferred && xpr._artifact._effectiveType?.elements) {
+          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 } );
+        }
+        else if (xpr._artifact.localized?.val && elem.value.stored?.val) {
+          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' );
     }
   }
 
@@ -676,13 +716,6 @@ function check( model ) {       // = XSN
     return false;
   }
 
-  function isStructuredElement( elem ) {
-    // The effective type always points to something with elements _if_ the
-    // type is structured.  But `elem` should already have `elements` if its
-    // structured due to element expansion.
-    return !!(elem?._effectiveType || elem)?.elements;
-  }
-
   /**
    * Check a tree-like expression for semantic validity
    *
@@ -698,21 +731,15 @@ function check( model ) {       // = XSN
     // 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 );
       }
     }
   }
@@ -721,28 +748,23 @@ function check( model ) {       // = XSN
     // 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' } );
+      if (arg.$expected === 'exists') {
+        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 } );
     }
   }
 
-  // Return true if 'arg' is an expression argument of type association or composition
+  /**
+   * Return true if 'arg' is an expression argument of type association or composition.
+   */
   function isAssociationOperand( arg ) {
-    if (!arg.path) {
-      // Not a path, hence not an association (literal, expression, function, whatever ...)
-      return false;
-    }
     // If it has a target, it is an association or composition
-    return (arg._artifact && arg._artifact.target) ||
-      (arg._artifact && arg._artifact._effectiveType && arg._artifact._effectiveType.target);
+    return !!arg._artifact?._effectiveType?.target;
   }
 
   /**
@@ -764,17 +786,20 @@ function check( model ) {       // = XSN
     if (!xpr.op || !xpr.args)
       return false;
 
-
     // 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
@@ -787,19 +812,19 @@ function check( model ) {       // = XSN
   // Check the annotation assignments (if any) of 'annotatable', possibly using annotation
   // definitions from 'model'. Report errors on 'options.messages.
   //
-  // TODO: rework completely
+  // TODO: rework completely!
 
   // Has been slightly adapted for model.vocabularies but comments need to be
   // adapted, etc.
   function checkAnnotationAssignment1( art, anno ) {
     // Sanity checks (ignore broken assignments)
-    if (!anno.name || !anno.name.path || !anno.name.path.length)
+    if (!anno.name?.path?.length)
       return;
     // Annotation artifact for longest path step of annotation path
     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;
@@ -812,8 +837,8 @@ function check( model ) {       // = XSN
       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 );
@@ -827,40 +852,39 @@ function check( model ) {       // = XSN
     if (!annoDecl || annoDecl.artifacts && !elementDecl)
       return;
 
-
     // Must be an annotation if found
     if (annoDecl.kind !== 'annotation') // i.e namespace
       return;
 
     // 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 (elementDecl.type && elementDecl.type._artifact.name.absolute) {
-        warning('anno-expecting-value', [ anno.location || anno.name.location, art ],
-                { '#': 'type', type: elementDecl.type._artifact });
+    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 } );
       }
       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
@@ -868,7 +892,7 @@ function check( model ) {       // = XSN
   // if not
   function checkValueAssignableTo( annoDef, value, elementDecl, art ) {
     // FIXME: We currently do not have any element declaration that could match
-    // a 'path' value, so we simply leave those alone
+    //        a 'path' value, so we simply leave those alone
     if (value.path)
       return;
 
@@ -879,12 +903,12 @@ function check( model ) {       // = XSN
     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;
     }
@@ -892,7 +916,7 @@ function check( model ) {       // = XSN
     // 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
@@ -900,44 +924,45 @@ function check( model ) {       // = XSN
     }
 
     // Handle each (primitive) expected element type separately
-    const type = getFinalTypeNameOf(elementDecl);
-    if (builtins.isStringTypeName(type)) {
+    // TODO: Don't rely on name; use actual 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 }`);
@@ -950,22 +975,22 @@ function check( model ) {       // = XSN
         // 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)' );
       }
     }
   }
@@ -978,8 +1003,7 @@ function check( model ) {       // = XSN
     return null;
   }
 
-  // TODO: remove the following
-
+  // TODO: remove
   // Return the artifact (and possibly, its element) found by following 'path'
   // starting at 'from'.  The return value is an object { artifact, endOfPath }
   // with 'artifact' being the last artifact encountered on 'path' (or
@@ -1001,9 +1025,10 @@ function check( model ) {       // = XSN
     // 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
   // 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.
@@ -1016,7 +1041,7 @@ function check( model ) {       // = XSN
 }
 
 /**
- * Ensure that the `locale` element of sap.common.TextsAspects
+ * Ensure that the `locale` element of `sap.common.TextsAspects`
  * is a string type.  This is required by CAP runtimes to work properly.
  *
  * @param {XSN.Model} model
@@ -1026,17 +1051,16 @@ function checkSapCommonTextsAspects( model ) {
   const locale = model.definitions[name]?.elements?.locale;
   if (locale) {
     // `locale` could also be `sap.common.Locale`, which must also be a string.
-    const type = locale._effectiveType;
-    if (type?.name?.absolute !== 'cds.String') {
+    if (locale._effectiveType !== model.definitions['cds.String']) {
       const hasCommonLocale = !!model.definitions['sap.common.Locale'];
       const { error } = model.$messageFunctions;
-      error('def-invalid-element-type', [ locale.type.location, locale ], {
+      error( 'def-invalid-element-type', [ locale.type.location, locale ], {
         '#': hasCommonLocale ? 'texts-aspect-locale' : 'std',
         art: name,
         elemref: 'locale',
         type: 'cds.String',
         othertype: 'sap.common.Locale',
-      });
+      } );
     }
   }
 }
@@ -1050,12 +1074,11 @@ function checkSapCommonTextsAspects( model ) {
 function checkSapCommonLocale( model ) {
   const localeArt = model.definitions['sap.common.Locale'];
   if (localeArt) {
-    const type = localeArt._effectiveType;
-    if (type?.name?.absolute !== 'cds.String') {
+    if (localeArt._effectiveType !== model.definitions['cds.String']) {
       const { message } = model.$messageFunctions;
-      message('type-expected-builtin', [ localeArt.name.location, localeArt ],
-              { name: 'sap.common.Locale' },
-              'Expected $(NAME) to be a string type');
+      message( 'type-expected-builtin', [ localeArt.name.location, localeArt ],
+               { name: 'sap.common.Locale' },
+               'Expected $(NAME) to be a string type' );
     }
   }
 }
@@ -1065,13 +1088,16 @@ function checkSapCommonLocale( model ) {
  * Visits each expression.
  *
  * TODO: Properly visit expressions; will be improved step by step;
- *       Currently only replaces old foreachPath().
+ *       Currently only replaces old foreachPath(), which had very poor performance.
  *
  * @param {any} xpr
  * @param {XSN.Artifact} user
  * @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 );
 }
@@ -1085,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 );
+      }
     }
   }
 
@@ -1098,11 +1126,31 @@ 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 );
       }
     }
   }
 }
 
+/**
+ * Whether the given element is a composition.
+ * TODO: `type T: Composition of E; entity V { e: T default 3 };`
+ * See also getUnderlyingBuiltinType()/compositionTextVariant() in utils.js.
+ *
+ * @return {boolean}
+ */
+function isComposition( model, elem ) {
+  elem = elem?._effectiveType;
+  if (!elem || !elem.target)
+    return false;
+  do {
+    if (elem.type?._artifact === model.definitions['cds.Composition'])
+      return true;
+    // Because inferred elements don't have a direct `type` property,
+    // we need to go along the origin chain.
+    elem = elem._origin;
+  } while (elem);
+  return false;
+}
 
 module.exports = check;