@sap/cds-compiler 6.1.0 → 6.3.0

package/lib/checks/queryNoDbArtifacts.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isPersistedOnDatabase, hasPersistenceSkipAnnotation } = require('../model/csnUtils');
+const { isPersistedOnDatabase, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { requireForeignKeyAccess } = require('./onConditions');
 const { pathId } = require('../model/csnRefs');
@@ -26,8 +26,13 @@ function checkQueryForNoDBArtifacts( query ) {
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
-        for (const part of queryPart)
-          checkQueryRef.call(this, part, prop === 'columns');
+        const that = this;
+        applyTransformationsOnNonDictionary((query.SELECT || query.SET), prop, {
+          ref: (parent, _name, val, csnPath, tokenStream, refIndex) => {
+            const danglingAssocAllowed = tokenStream[refIndex - 1] !== 'exists';
+            checkQueryRef.call(that, parent, danglingAssocAllowed);
+          },
+        }, { skipStandard: { on: true } });
       }
       else if (typeof queryPart === 'object') {
         checkQueryRef.call(this, queryPart, prop === 'columns');
@@ -119,9 +124,10 @@ function _checkExpandInline( obj, previousRefs = [], previousLinks = [] ) {
  * @param {CSN.Path} ref
  * @param {object[]} _links
  * @param {CSN.Path} $path
- * @param {boolean} inColumns
+ * @param {boolean} danglingAssocAllowed usually optimised to foreign key hence allowed even if target is skipped,
+ *                                       except in from or after exists
  */
-function _checkRef( ref, _links, $path, inColumns ) {
+function _checkRef( ref, _links, $path, danglingAssocAllowed ) {
   if (!ref || !_links )
     return;
 
@@ -129,7 +135,7 @@ function _checkRef( ref, _links, $path, inColumns ) {
   const isPublishedAssoc = this.csnUtils.isAssocOrComposition(_links[_links.length - 1].art);
 
   // Don't check the last element - to allow association publishing in columns
-  for (let i = 0; i < (inColumns ? _links.length - 1 : _links.length); i++) {
+  for (let i = 0; i < (danglingAssocAllowed ? _links.length - 1 : _links.length); i++) {
     const link = _links[i];
     if (!link)
       continue;
@@ -153,8 +159,8 @@ function _checkRef( ref, _links, $path, inColumns ) {
     if (nonPersistedTarget) {
       let isJoinRelevant = isPublishedAssoc || // publishing associations is always join relevant
         isLast || // e.g. FROM targets are always join relevant.
-        isUnmanagedOrNoKeys; // unmanaged associations are always join relevant -> no FKs
-
+        isUnmanagedOrNoKeys || // unmanaged associations are always join relevant -> no FKs
+        ref.slice(i).some(s => s.where || s.args); // function calls or filters are always join relevant
       if (!isJoinRelevant) {
         // for managed, published associations with more than one $path-step, only FK
         // access is allowed.
@@ -164,17 +170,12 @@ function _checkRef( ref, _links, $path, inColumns ) {
       }
 
       if (isJoinRelevant) {
-        const cdsPersistenceSkipped = hasPersistenceSkipAnnotation(targetArt);
-        this.error( null, $path, {
-          '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+        this.error('ref-invalid-assoc-navigation', $path, {
           anno: '@cds.persistence.skip',
           id: nonPersistedTarget.pathStep,
           elemref: { ref },
           name: nonPersistedTarget.name,
-        }, {
-          std: 'Unexpected $(ANNO) annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
-          abstract: 'Unexpected abstract association target $(NAME) of $(ID) in path $(ELEMREF)',
-        } );
+        });
         break; // only one error per path
       }
     }

package/lib/checks/types.js

@@ -152,7 +152,7 @@ function checkTypeOfHasProperType( artOrElement, name, model, error, path, deriv
 
 
 /**
- * Can happen in CSN, e.g. `{ a: { kind: "type" } }` but should not happen in CDL.
+ * Can happen in CSN, e.g. `{ a: { kind: "type" } }` or via `elem;` in CDL.
  *
  * @param {Function} error the error function
  * @param {CSN.Path} path the path to the element or the artifact

package/lib/checks/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../base/builtins');
-const { RelationalOperators } = require('../transform/transformUtils');
+const { RelationalOperators } = require('../transform/tupleExpansion');
 /**
  * Prepare the ref steps so that they are loggable
  *
@@ -17,7 +17,9 @@ function logReady( refStep ) {
  * structured that can be used for tuple expansion. This can either be a
  * real 'elements' thing or a managed association/composition with foreign keys.
  *
- * The RHS may be 'null' or any value
+ * @TODO: This function also allows `is null` on the right-hand-side.
+ *        We should move these checks to the actual tuple expansion, because
+ *        if we're missing cases here, it currently results in incorrect expansion.
  *
  * @param {Array} on the on condition which to check
  * @param {number} startIndex the index of the relational term in the on condition array
@@ -26,8 +28,7 @@ function logReady( refStep ) {
 function otherSideIsExpandableStructure( on, startIndex ) {
   if (on[startIndex - 1] && RelationalOperators.includes(on[startIndex - 1])) {
     const lhs = on[startIndex - 2];
-    // if ever lhs is allowed to be a value uncomment this
-    return /* lhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, lhs?._art));
+    return isOk(resolveArtifactType.call(this, lhs?._art));
   }
   else if (on[startIndex + 1] && RelationalOperators.includes(on[startIndex + 1])) {
     const op = on[startIndex + 1];
@@ -35,8 +36,7 @@ function otherSideIsExpandableStructure( on, startIndex ) {
     if (op === 'is')
       // check for unary operator 'is [not] null' as token stream
       return rhs === 'null' || (rhs === 'not' && on[startIndex + 3] === 'null');
-    // if ever rhs is allowed to be a value uncomment this
-    return /* rhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, rhs?._art));
+    return isOk(resolveArtifactType.call(this, rhs?._art));
   }
   return false;
 
@@ -51,6 +51,29 @@ function otherSideIsExpandableStructure( on, startIndex ) {
   }
 }
 
+/**
+ * Check that the opposite operand to a relational term is s value or "is null".
+ *
+ * @param {Array} expr the expression which to check
+ * @param {number} startIndex the index of the relational term in the expression array
+ * @returns {boolean} indicates whether the other side of a relational term is scalar
+ */
+function otherSideIsValue( expr, startIndex ) {
+  if (expr[startIndex - 1] && RelationalOperators.includes(expr[startIndex - 1]))
+    return expr[startIndex - 2]?.val !== undefined;
+
+  if (expr[startIndex + 1] && RelationalOperators.includes(expr[startIndex + 1])) {
+    const op = expr[startIndex + 1];
+    const rhs = expr[startIndex + 2];
+    if (op === 'is')
+      // check for unary operator 'is [not] null' as token stream
+      return rhs === 'null' || (rhs === 'not' && expr[startIndex + 3] === 'null');
+    return rhs?.val !== undefined;
+  }
+
+  return false;
+}
+
 /**
  * Get the real type of an artifact
  *
@@ -68,5 +91,6 @@ function resolveArtifactType( art ) {
 module.exports = {
   logReady,
   otherSideIsExpandableStructure,
+  otherSideIsValue,
   resolveArtifactType,
 };

package/lib/checks/validator.js

@@ -42,7 +42,6 @@ const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
-const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
 const existsMustEndInAssoc = require('./existsMustEndInAssoc');
 const forbidAssocInExists = require('./existsExpressionsOnlyForeignKeys');
 const checkPathsInStoredCalcElement = require('./checkPathsInStoredCalcElement');
@@ -87,7 +86,6 @@ const forRelationalDBCsnValidators = [
   checkCdsMap,
   existsMustEndInAssoc,
   forbidAssocInExists,
-  nonexpandableStructuredInExpression,
   navigationIntoMany,
   checkPathsInStoredCalcElement,
   featureFlags,
@@ -124,7 +122,7 @@ const forOdataArtifactValidators
   checkReadOnlyAndInsertOnly,
 ];
 
-const forOdataCsnValidators = [ checkCdsMap, nonexpandableStructuredInExpression ];
+const forOdataCsnValidators = [ checkCdsMap ];
 
 const forOdataQueryValidators = [];
 
@@ -202,8 +200,6 @@ function getDBCsnValidators( options ) {
     validations.push(checkForParams.csnValidator);
   if (options.sqlDialect === 'h2' || options.sqlDialect === 'postgres')
     validations.push(checkForHanaTypes);
-  if (options.transformation === 'effective' && options.effectiveServiceName)
-    validations.push(assertNoAssocUsageOutsideOfService);
 
   return validations;
 }
@@ -232,6 +228,9 @@ function forRelationalDB( csn, that ) {
                      },
                      (artifact, artifactName) => {
                        if (that.options.transformation === 'effective') {
+                         if (that.options.effectiveServiceName)
+                           assertNoAssocUsageOutsideOfService.bind(that)(artifact, artifactName);
+
                          forEachMemberRecursively(artifact, checkAnnotationExpression.bind(that), [ 'definitions', artifactName ], false, {
                            skipArtifact: a => a.returns || (a.params && !a.query),
                          });

package/lib/compiler/assert-consistency.js

@@ -647,6 +647,8 @@ function assertConsistency( model, stage ) {
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
         '$limit', 'limit', '_status', '_origin',
+        // via casts
+        'enum',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -1059,7 +1061,7 @@ function assertConsistency( model, stage ) {
     // TODO
     // else if (spec.instanceOf && spec.instanceOf !== 'ignore' &&
     //    Object.getPrototypeOf( node ) !== spec.instanceOf.prototype)
-    // eslint-disable-next-line @stylistic/js/max-len
+    // eslint-disable-next-line @stylistic/max-len
     //  throw new InternalConsistencyError( `Expected object of class ${ spec.instanceOf.name } but found ${ found }${ at( [ null, parent ], prop, name ) }` );
   }
 

package/lib/compiler/base.js

@@ -21,7 +21,7 @@ const kindProperties = {
   entity: {
     elements: true, actions: true, params: () => false, include: true,
   },
-  select: { normalized: 'select', elements: true },
+  select: { normalized: 'select', elements: propExists, enum: propExists },
   $join: { normalized: 'select' },
   $tableAlias: { normalized: 'alias' }, // table alias in select
   $self: { normalized: 'alias' }, // table alias in select

package/lib/compiler/builtins.js

@@ -222,7 +222,7 @@ const dateRegEx = /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/;
 //                      YYYY -     MM  -   dd
 const timeRegEx = /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
 //                  T     HH   :    mm      :    ss         TZD
-// eslint-disable-next-line @stylistic/js/max-len, sonarjs/regex-complexity
+// eslint-disable-next-line @stylistic/max-len, sonarjs/regex-complexity
 const timestampRegEx = /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
 //                          YYYY  -  MM   -  dd    T    HH   :   mm     :  ss     . fraction     TZD
 // eslint-disable-next-line sonarjs/regex-complexity

package/lib/compiler/checks.js

@@ -5,7 +5,6 @@
 //  * 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
 
 'use strict';
@@ -18,7 +17,7 @@ const {
   isDeprecatedEnabled,
 } = require('../base/model');
 const { typeParameters } = require('./builtins');
-const { propagationRules } = require('../base/builtins');
+const { propagationRules, acceptsExprValues } = require('../base/builtins');
 const { annotationVal } = require('./utils');
 
 const $location = Symbol.for( 'cds.$location' );
@@ -84,7 +83,7 @@ function check( model ) {
     checkName( art );
     checkTypeArguments( art );
 
-    if (art.value && !art.$calcDepElement && art.type)
+    if (art.value && !art.$calcDepElement && (art.type || art.elements || art.items))
       checkTypeCast( art.value, art );
 
     for (const anno of iterateAnnotations( art ))
@@ -117,13 +116,21 @@ function check( model ) {
       return;
 
     const isVirtual = parentProps.virtual?.val || elem.virtual?.val;
+    const typeName = elem._effectiveType?.name?.id;
     if (isVirtual) {
       error( 'def-unexpected-key', [ (parentProps.key || elem.key).location, elem ],
-             { '#': 'virtual', prop: 'key' } );
+             { '#': 'virtual', keyword: 'key' } );
     }
-    else if (elem._effectiveType?.name?.id === 'cds.Map') {
+    else if (typeName === 'cds.Map') {
       error( 'def-unexpected-key', [ elem.type?.location || elem.location, elem ],
-             { '#': 'invalidType', prop: 'key', type: 'cds.Map' } );
+             { '#': 'invalidType', keyword: 'key', type: typeName } );
+    }
+    else if (typeName === 'cds.LargeString' ||
+        typeName === 'cds.Vector' ||
+        typeName === 'cds.hana.CLOB' ||
+        typeName === 'cds.LargeBinary') {
+      warning( 'def-unsupported-key', [ elem.type?.location || elem.location, elem ],
+               { '#': 'type', keyword: 'key', type: typeName } );
     }
   }
 
@@ -245,25 +252,43 @@ function check( model ) {
   }
 
   function checkTypeCast( xpr, user ) {
-    const isCast = (xpr.op?.val === 'cast');
-    const elem = isCast
+    const isSqlCast = (xpr.op?.val === 'cast');
+    const elem = isSqlCast
       ? xpr.args?.[0]?._artifact
       : xpr._artifact;
-    const type = isCast ? xpr.type : user.type;
-    if (!isCast && type.$inferred)
+
+    const typeArt = isSqlCast ? xpr : user;
+    if (!elem || !isSqlCast && typeArt.type?.$inferred)
       return; // e.g. $inferred:'generated'
-    if (elem && type) { // has explicit type
-      if (type._artifact?._effectiveType?.name.id === 'cds.Map')
+
+    const { type } = typeArt;
+    if (type) { // has explicit type
+      if (type._artifact?._effectiveType?.name.id === 'cds.Map') {
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'std', type: 'cds.Map' } );
-      else if (type._artifact?.elements)
+      }
+      else if (type._artifact?.elements) {
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'to-structure' } );
-      else if (elem.elements) // TODO: calc elements
+      }
+      else if (elem.elements) { // TODO: calc elements
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'from-structure' } );
-      else if (elem.target && !type._artifact?.target)
+      }
+      else if (elem.target && !type._artifact?.target) {
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'from-assoc' } );
-      else if (!elem.target && type._artifact?.target && !user.type?.$inferred)
-        // $inferred already reported in resolve.js
-        error( 'type-invalid-cast', [ type.location, user ], { '#': 'assoc' } );
+      }
+      else if (!elem.target &&     // referenced element is not association
+          !user.type?.$inferred && // $inferred types already reported in resolve.js.
+          (
+            // assoc used in SQL cast
+            type._artifact?.target && isSqlCast ||
+            // there is a target and the type is a direct `cds.Association`;
+            // other types handled by resolver already.
+            typeArt.target && type._artifact?.category === 'relation'
+          )
+      ) {
+        // - redirection-check in resolve.js already checks this for CDL-casts
+        // - `"cast": { "target": "…", "type": "cds.Association", … }` via CSN input.
+        error('type-invalid-cast', [ type.location, user ], { '#': 'assoc' });
+      }
     }
   }
 
@@ -687,12 +712,15 @@ function check( model ) {
    *
    * @param {any} xpr The expression to check
    * @param {XSN.Artifact} user User for semantic location
+   * @param {any} _parentExpr
    * @param {string} [context] where the expression is used, e.g. 'anno'
    */
-  function checkGenericExpression( xpr, user, context ) {
+  function checkGenericExpression( xpr, user, _parentExpr, context ) {
     if (context !== 'anno')
       checkExpressionNotVirtual( xpr, user );
-    checkExpressionAssociationUsage( xpr, user, false );
+    checkExpressionAssociationUsage( xpr, user, {
+      context, rejectManaged: context === 'anno', rejectUnmanaged: true,
+    } );
     if (xpr.op?.val === 'cast') {
       requireExplicitTypeInSqlCast( xpr, user );
       checkTypeCast( xpr, user );
@@ -713,7 +741,7 @@ function check( model ) {
 
     visitExpression( elem.on, elem, (xpr, user) => {
       checkExpressionNotVirtual( xpr, user );
-      checkExpressionAssociationUsage( xpr, user, true );
+      checkExpressionAssociationUsage( xpr, user, null );
 
       if (xpr._artifact?._effectiveType?.name.id === 'cds.Map') {
         error( 'ref-unexpected-map', [ xpr.location, user ], { '#': 'onCond', type: 'cds.Map' } );
@@ -727,7 +755,9 @@ function check( model ) {
   }
 
   function checkSelectItemValue( elem ) {
-    checkExpressionAssociationUsage( elem.value, elem, false );
+    checkExpressionAssociationUsage( elem.value, elem, {
+      context: 'query', rejectManaged: false, rejectUnmanaged: true,
+    } );
     checkVirtualSelectItemChangeForV6( elem );
     // To avoid duplicate messages, only run this check if the type wasn't inferred from
     // the cast, as otherwise we will check it twice (once here, once via element).
@@ -736,8 +766,8 @@ function check( model ) {
       checkTypeCast( elem.value, elem );
       checkTypeArguments( elem.value, elem );
     }
-    visitSubExpression( elem.value, elem, (xpr) => {
-      checkGenericExpression( xpr, elem );
+    visitSubExpression( elem.value, elem, (xpr, user, parentExpr) => {
+      checkGenericExpression( xpr, elem, parentExpr, 'query' );
     } );
   }
 
@@ -794,7 +824,8 @@ function check( model ) {
         // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
         // And users can't change structured to non-structured elements.
         if (!elem.$inferred && xpr._artifact._effectiveType?.elements) {
-          error( 'ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
+          error( 'ref-unexpected-structured', [ sourceLoc, elem ],
+                 { '#': 'struct-expr', elemref: xpr } );
         }
         else if (xpr._artifact.target !== undefined && (!lastStep.where || isStored)) {
           // Allow using an association _with filter_, but only for on-read calculated elements.
@@ -867,10 +898,11 @@ function check( model ) {
    *
    * @param {any} xpr The expression to check
    * @param {XSN.Artifact} user
-   * @param {boolean} allowAssocTail
+   * @param {{context: string, rejectUnmanaged, rejectManaged}|null} [rejectAssocTail]
+   *        Context where association tails are not allowed.
    * @returns {void}
    */
-  function checkExpressionAssociationUsage( xpr, user, allowAssocTail ) {
+  function checkExpressionAssociationUsage( xpr, user, rejectAssocTail = null ) {
     if (!xpr.args)
       return;
 
@@ -885,12 +917,18 @@ function check( model ) {
       const op = getBinaryOp( xpr );
       for (const arg of args) {
         if (arg && !(op?.val !== '=' && isDollarSelfOrProjectionOperand( arg )))
-          checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail );
+          checkExpressionIsNotAssocOrSelf( arg, user, rejectAssocTail );
       }
     }
   }
 
-  function checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail ) {
+  /**
+   * @param arg
+   * @param {XSN.Artifact} user
+   * @param {{context: string, rejectUnmanaged, rejectManaged}|null} [rejectAssocTail]
+   *        Context where association tails are not allowed.
+   */
+  function checkExpressionIsNotAssocOrSelf( arg, user, rejectAssocTail ) {
     // 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'
@@ -899,9 +937,17 @@ function check( model ) {
         error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
       }
     }
-    else if (!allowAssocTail && isAssociationOperand( arg )) {
-      const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
-      error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
+    else if (rejectAssocTail && isAssociationOperand( arg )) {
+      if (rejectAssocTail.rejectManaged && rejectAssocTail.rejectUnmanaged ||
+          rejectAssocTail.rejectManaged && arg._artifact.keys ||
+          rejectAssocTail.rejectUnmanaged && arg._artifact.on) {
+        // only a few contexts have special message
+        const context = rejectAssocTail.context === 'query' && 'query-' ||
+          rejectAssocTail.context === 'anno' && 'anno-' ||
+          '';
+        const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
+        error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': `${ context }${ variant }` } );
+      }
     }
   }
 
@@ -935,16 +981,16 @@ function check( model ) {
     // One argument must be "$self" and the other an assoc
     if (xpr.op.val === '=' && xpr.args.length === 2) {
       // Tree-ish expression from the compiler (not augmented)
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line @stylistic/max-len
       return (isAssociationOperand( xpr.args[0] ) && isDollarSelfOrProjectionOperand( xpr.args[1] ) ||
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line @stylistic/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)
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line @stylistic/max-len
       return (isAssociationOperand( xpr.args[0] ) && isDollarSelfOrProjectionOperand( xpr.args[2] ) ||
-              // eslint-disable-next-line @stylistic/js/max-len
+              // eslint-disable-next-line @stylistic/max-len
               isAssociationOperand( xpr.args[2] ) && isDollarSelfOrProjectionOperand( xpr.args[0] ));
     }
 
@@ -963,7 +1009,7 @@ function check( model ) {
     const name = anno.name?.id;
     if (!name)
       return true;
-    if (!propagationRules[`@${ name }`])
+    if (!propagationRules[`@${ name }`] || acceptsExprValues[`@${ name }`])
       return true;
     error( 'anno-unexpected-expr', [ anno.location, art ], { anno: name },
            'Unexpected expression as value for $(ANNO)' );
@@ -1088,7 +1134,7 @@ function check( model ) {
    */
   function checkAnnotationExpressions( anno, art ) {
     if (anno.$tokenTexts) {
-      checkGenericExpression( anno, art, 'anno' );
+      checkGenericExpression( anno, art, null, 'anno' );
     }
     else if (anno.literal === 'array') {
       anno.val.forEach( val => checkAnnotationExpressions( val, art ) );
@@ -1165,7 +1211,7 @@ function check( model ) {
           value.literal !== 'timestamp' && value.literal !== 'string') {
         // Hm, actually date and time cannot be mixed
         warning( null, loc, { type, anno },
-          // eslint-disable-next-line @stylistic/js/max-len
+          // eslint-disable-next-line @stylistic/max-len
                  'A date/time value or a string is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }

package/lib/compiler/define.js

@@ -1010,6 +1010,7 @@ function define( model ) {
       }
       // Either expression (value), expand, new virtual or new association
       else if (col.value || col.name) {
+        col.kind = 'element';
         if (!col._block)
           setLink( col, '_block', parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
@@ -1031,8 +1032,7 @@ function define( model ) {
         initSelectItems( col, null, user ); // TODO: use col as user (i.e. remove param)
       }
 
-      initItemsLinks( col, parent._block );
-      initExprAnnoBlock( col, parent._block );
+      initCdlTypeCast( col, parent );
     }
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
@@ -1044,6 +1044,26 @@ function define( model ) {
     }
   }
 
+  function initCdlTypeCast( col, parent ) {
+    if (col.val)
+      return; // e.g. '*' column
+
+    setMemberParent( col, col.name, parent );
+    initMembers( col, col, col._block );
+
+    // We don't allow CDL-style casts to anonymous structures.  We reject it already here
+    // and not in checks.js to ensure that it's rejected in parseCdl.
+    if (col.elements) {
+      error('type-invalid-cast', [ col.elements[$location] ?? col.location, col ],
+            { '#': 'to-inline-structure' });
+    }
+    else if (col.expand && (col.type || col.elements || col.items)) {
+      const loc = (col.type?.location || col.elements?.[$location] ||
+        col.items?.location || col.location);
+      error('type-invalid-cast', [ loc, col ], { '#': 'expand' });
+    }
+  }
+
   /**
    * If we have a valid top-level exists, exists in filters of sub-expressions can be translated,
    * since we will have a top-level subquery after exists-processing in the forRelationalDB.
@@ -1150,7 +1170,7 @@ function define( model ) {
           // We do not want to complain separately about all element properties:
           error( 'ext-unexpected-element', [ e.location, construct ],
                  { name: e.name.id, code: 'extend … with enum' },
-                 // eslint-disable-next-line @stylistic/js/max-len
+                 // eslint-disable-next-line @stylistic/max-len
                  'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
           // Don't emit 'ext-expecting-enum' if this error is emitted.
           return;
@@ -1238,7 +1258,6 @@ function define( model ) {
       if (elem.$duplicates === true && add)
         elem.$duplicates = null;
       setMemberParent( elem, name, parent, add && prop );
-      // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );
       initMembers( elem, elem, bl, initExtensions );
       if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
@@ -1320,7 +1339,7 @@ function define( model ) {
     // - artifacts (CDL-only anyway) only inside [extend] context|service
     if (!dict)
       return false;
-    const feature = kindProperties[parent.kind][prop];
+    const feature = kindProperties[parent.kind ?? 'element'][prop];
     if (feature &&
         (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
       return true;

package/lib/compiler/extend.js

@@ -561,7 +561,7 @@ function extend( model ) {
            {
              std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
              array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
-             // eslint-disable-next-line @stylistic/js/max-len
+             // eslint-disable-next-line @stylistic/max-len
              struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
              boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
              null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',

package/lib/compiler/finalize-parse-cdl.js

@@ -117,7 +117,15 @@ function finalizeParseCdl( model ) {
     // containing it.  Otherwise some type's aren't properly resolved.
     // TODO: If resolveTypeUnchecked is reworked, we may be able to simplify this coding.
     (artifact.$queries || []).forEach( art => resolveTypesForParseCdl( art, artifact ) );
-    (artifact.columns || []).forEach( art => resolveTypesForParseCdl( art, artifact ) );
+    (artifact.columns || []).forEach( (col) => {
+      // TODO: Can we use "ensureColumnName" of populate.js? It depends on column indices
+      //  _after_ wildcards were expanded, though.
+      if (!col.name && col.value?.path) {
+        const last = col.value.path.at(-1);
+        col.name = { id: last?.id || '', location: last?.location, $inferred: 'as' };
+      }
+      resolveTypesForParseCdl( col, artifact );
+    } );
     forEachGeneric( artifact, 'mixin', art => resolveTypesForParseCdl( art, artifact ) );
 
     // For better error messages for `type of`s in `returns`, we pass the object as the new main.

package/lib/compiler/generate.js

@@ -104,7 +104,7 @@ function generate( model ) {
       const lang = textsAspect.elements.language;
       error( 'def-unexpected-element', [ lang.name.location, lang ],
              { option: 'addTextsLanguageAssoc', art: textsAspect, name: 'language' },
-        // eslint-disable-next-line @stylistic/js/max-len
+        // eslint-disable-next-line @stylistic/max-len
              '$(ART) is not used because option $(OPTION) conflicts with existing element $(NAME); remove either option or element' );
       hasError = true;
     }
@@ -209,7 +209,7 @@ function generate( model ) {
         conflictingElements.push( elem );
 
       const isKey = elem.key && elem.key.val;
-      const isLocalized = hasTruthyProp( elem, 'localized' );
+      const isLocalized = elem.$syntax !== 'calc' && hasTruthyProp( elem, 'localized' );
 
       if (isKey) {
         keys += 1;
@@ -245,7 +245,7 @@ function generate( model ) {
           (fioriEnabled && art.elements.ID_texts)) {
         // TODO if we have too much time: check all elements of texts entity for safety
         warning( null, [ art.name.location, art ], { art: textsEntity },
-                 // eslint-disable-next-line @stylistic/js/max-len
+                 // eslint-disable-next-line @stylistic/max-len
                  'Texts entity $(ART) can\'t be created as there is another definition with that name' );
         info( null, [ textsEntity.name.location, textsEntity ], { art },
               'Texts entity for $(ART) can\'t be created with this definition' );
@@ -640,7 +640,7 @@ function generate( model ) {
     }
     if (model.definitions[entityName]) {
       error( null, [ location, elem ], { art: entityName },
-             // eslint-disable-next-line @stylistic/js/max-len
+             // eslint-disable-next-line @stylistic/max-len
              'Target entity $(ART) can\'t be created as there is another definition with this name' );
       return false;
     }