@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/compiler/checks.js

@@ -1,33 +1,36 @@
-// 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,
+  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');
 
-function check( model ) {       // = XSN
+/**
+ * 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 );
@@ -47,22 +50,24 @@ function check( model ) {       // = XSN
   }
 
   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,56 +80,128 @@ 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' });
+            { '#': '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
+    // 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');
     }
   }
 
+
+  /**
+   * 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') {
@@ -133,14 +210,14 @@ function check( model ) {       // = XSN
              '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' },
+      // 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');
       }
     }
@@ -173,8 +250,6 @@ function check( model ) {       // = XSN
     }
   }
 
-  // Individual checks -------------------------------------------------------
-
   /**
    * The enumNode is a single enum element and not the whole type.
    *
@@ -190,7 +265,7 @@ 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
+      warning('ref-unexpected-enum', [ loc, enumNode ], {},
               'References to other values are not allowed as enum values');
     }
   }
@@ -201,8 +276,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,25 +286,18 @@ 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',
@@ -244,32 +311,32 @@ function check( model ) {       // = XSN
   }
 
   /**
-   * 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)',
+        });
       }
     }
 
@@ -288,27 +355,29 @@ function check( model ) {       // = XSN
 
     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,
+        }, {
+          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,6 +387,7 @@ function check( model ) {       // = XSN
    *       subElement : L2;
    *     }
    *   }
+   *   ```
    *
    * @param {XSN.Artifact} element
    */
@@ -325,8 +395,8 @@ function check( model ) {       // = XSN
     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' },
@@ -335,61 +405,26 @@ function check( model ) {       // = XSN
                 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);
-    }
   }
 
   /**
-   * 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)',
-          });
+      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: '*' } );
         }
       }
     }
@@ -398,34 +433,24 @@ function check( model ) {       // = XSN
     // 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))
+          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', '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',
-        });
-      }
+    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 } );
     });
   }
 
@@ -452,10 +477,14 @@ function check( model ) {       // = XSN
   }
 
   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' });
@@ -463,6 +492,30 @@ function check( model ) {       // = XSN
           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);
   }
@@ -473,8 +526,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,7 +539,7 @@ 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) {
@@ -553,7 +607,7 @@ function check( model ) {       // = XSN
         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
+          return false; // only report once
         }
         else if (!checkElementOverride(elem, orig)) {
           return false;
@@ -564,8 +618,6 @@ function check( model ) {       // = XSN
   }
 
 
-  // Former checkExpressions.js ----------------------------------------------
-
   /**
    * Check a generic expression (or condition) for semantic validity.
    *
@@ -576,6 +628,10 @@ function check( model ) {       // = XSN
   function checkGenericExpression( xpr, user ) {
     checkExpressionNotVirtual(xpr, user);
     checkExpressionAssociationUsage(xpr, user, false);
+    if (xpr.op?.val === 'cast') {
+      requireExplicitTypeInSqlCast( xpr, user );
+      checkTypeArguments( xpr, user );
+    }
   }
 
   function checkExpressionNotVirtual( xpr, user ) {
@@ -589,6 +645,8 @@ function check( model ) {       // = XSN
       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' } );
       });
@@ -600,11 +658,16 @@ function check( model ) {       // = XSN
   }
 
   function checkSelectItemValue( elem ) {
-    checkExpressionAssociationUsage(elem.value, 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) => {
-      checkExpressionNotVirtual(xpr, elem);
-      checkExpressionAssociationUsage(xpr, elem, false);
+      checkGenericExpression( xpr, elem );
     });
   }
 
@@ -615,12 +678,16 @@ function check( model ) {       // = XSN
         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))
+        if (!elem.$inferred && xpr._artifact._effectiveType?.elements) {
           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)
+        }
+        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
@@ -676,13 +743,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
    *
@@ -721,11 +781,14 @@ 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' } );
+      if (arg.$expected === 'exists') {
+        const variant = isComposition(model, arg._artifact) ? 'expr-comp' : 'expr';
+        error('ref-unexpected-assoc', [ arg.location, user ], { '#': variant });
+      }
     }
     else if (!allowAssocTail && isAssociationOperand(arg)) {
-      error('ref-unexpected-assoc', [ arg.location, user ], { '#': 'expr' } );
+      const variant = isComposition(model, arg._artifact) ? 'expr-comp' : 'expr';
+      error('ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
     }
 
     if (isDollarSelfOrProjectionOperand(arg)) {
@@ -734,15 +797,12 @@ function check( model ) {       // = XSN
     }
   }
 
-  // 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,7 +824,6 @@ 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)
@@ -787,13 +846,13 @@ 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;
@@ -827,7 +886,6 @@ function check( model ) {       // = XSN
     if (!annoDecl || annoDecl.artifacts && !elementDecl)
       return;
 
-
     // Must be an annotation if found
     if (annoDecl.kind !== 'annotation') // i.e namespace
       return;
@@ -847,7 +905,7 @@ function check( model ) {       // = XSN
 
     // Must have literal or path unless it is a boolean
     if (!anno.literal && !anno.path && getFinalTypeNameOf(elementDecl) !== 'cds.Boolean') {
-      if (elementDecl.type && elementDecl.type._artifact.name.absolute) {
+      if (elementDecl.type?._artifact.name.absolute) {
         warning('anno-expecting-value', [ anno.location || anno.name.location, art ],
                 { '#': 'type', type: elementDecl.type._artifact });
       }
@@ -868,7 +926,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;
 
@@ -900,6 +958,7 @@ function check( model ) {       // = XSN
     }
 
     // Handle each (primitive) expected element type separately
+    // TODO: Don't rely on name; use actual type
     const type = getFinalTypeNameOf(elementDecl);
     if (builtins.isStringTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'enum' &&
@@ -978,8 +1037,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
@@ -1004,6 +1062,7 @@ function check( model ) {       // = XSN
     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 +1075,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,11 +1085,10 @@ 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',
@@ -1050,12 +1108,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,7 +1122,7 @@ 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
@@ -1104,5 +1161,25 @@ function visitSubExpression( xpr, 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;