@sap/cds-compiler 5.9.4 → 5.9.6

package/CHANGELOG.md

@@ -7,6 +7,13 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 5.9.6 - 2025-06-18
+
+- to.sql: Fix error when calculated element refers to a localized element.
+- to.edm(x):
+  + Fix errors for service entities containing multiple path steps (e.g. `Service.Prefix.MyEntity`).
+  + Support enum references in annotation expressions that were resolved by the compiler.
+
 ## Version 5.9.4 - 2025-05-22
 
 - to.edm(x): Parameters are marked optional unless explicitly marked as `not null`.

package/lib/base/messages.js

@@ -1489,12 +1489,17 @@ function homeName( art, absoluteOnly ) {
     return art;
   if (art._user)               // when providing a path item with filter as “user”
     return homeName( art._user, absoluteOnly );
-  if (art._outer) {              // in items property, or annotation with path
+  if (art._outer) {             // in items property, or annotation with path
+    if (art._outer?.kind === '$annotation')
+      art = art._outer;
     const outer = homeName( art._outer, absoluteOnly );
     if (art.kind === '$annotation') // eslint-disable-next-line sonarjs/no-nested-template-literals
       return `${ outer }/${ quoted( `@${ art.name.id }` ) }`;
     return outer;
   }
+  else if (art.kind === '$annotation') { // in items property, or annotation with path
+    return quoted( `@${ art.name.id }` );
+  }
   else if (art.kind === 'source' || !art.name) { // error reported in parser or on source level
     return null;
   }

package/lib/compiler/assert-consistency.js

@@ -496,6 +496,7 @@ function assertConsistency( model, stage ) {
         // expressions as annotation values
         '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type', '$typeArgs',
         'scale', 'srid', 'length', 'precision', 'scope', '$parens',
+        '_block', '_outer',     // for annotation assignments
       ],
       // TODO: restrict path to #simplePath
     },

package/lib/compiler/checks.js

@@ -991,7 +991,7 @@ function check( model ) {
 
   function checkAnnotationAssignment1( art, anno ) {
     const name = anno.name?.id;
-    if (art.$contains?.$annotation && anno.kind === '$annotation') {
+    if (art.$contains?.$annotation && anno.kind === '$annotation' && anno._outer) {
       if (checkAnnotationAcceptsExpressions( anno, art ))
         checkAnnotationExpressions( anno, art );
     }
@@ -1144,7 +1144,7 @@ function check( model ) {
       return;
     }
 
-    // Struct expected (can only happen within arrays)?
+    // Struct expected (can only happen within arrays, or CSN input)?
     if (elementDecl._effectiveType.elements) {
       if (value.literal !== 'struct') {
         warning( null, loc, { anno }, 'A struct value is required here for annotation $(ANNO)' );

package/lib/compiler/define.js

@@ -298,6 +298,7 @@ function define( model ) {
       return;
     }
     setLink( art, '_block', block );
+    initExprAnnoBlock( art, block );
     // dictAdd might set $duplicates
     dictAdd( model.definitions, absolute, art );
   }
@@ -393,6 +394,7 @@ function define( model ) {
 
   function addExtension( ext, block ) {
     setLink( ext, '_block', block );
+    initExprAnnoBlock( ext, block );
     const absolute = ext.name && resolveUncheckedPath( ext.name, '_extensions', ext );
     if (!absolute)                    // broken path
       return;
@@ -429,6 +431,7 @@ function define( model ) {
       if (prop === 'params' && name === '') // RETURNS
         sub.name = { id: '', location: sub.location };
       setLink( sub, '_block', parent._block );
+      initExprAnnoBlock( sub, parent._block );
       setLink( sub, '_parent', parent );
       setLink( sub, '_main', parent._main || parent );
       initExtension( sub );
@@ -446,6 +449,26 @@ function define( model ) {
     }
   }
 
+  function initExprAnnoBlock( art, block ) {
+    // remark: `art` could also be the extension
+    for (const prop in art) {
+      if (prop.charAt(0) !== '@')
+        continue;
+      const anno = art[prop];
+      // _block links needed for `cast( … as Type )`, `[ ..., cast( … as Type ) ]`
+      if (anno.literal === 'array') {
+        anno.kind = '$annotation';
+        for (const item of anno.val)
+          setLink( item, '_block', block );
+      }
+      else if (anno.$tokenTexts) {
+        // remark: it wouldn't hurt to set it always...
+        anno.kind = '$annotation';
+        setLink( anno, '_block', block );
+      }
+    }
+  }
+
   function addVocabulary( vocab, block, prefix ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
@@ -1009,6 +1032,7 @@ function define( model ) {
       }
 
       initItemsLinks( col, parent._block );
+      initExprAnnoBlock( col, parent._block );
     }
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
@@ -1069,6 +1093,7 @@ function define( model ) {
     const main = parent._main || parent;
     const isQueryExtension = construct.kind === 'extend' && main.query;
     let obj = initItemsLinks( construct, block );
+    initExprAnnoBlock( construct, block );
     if (obj.target && targetIsTargetAspect( obj )) {
       obj.targetAspect = obj.target;
       delete obj.target;

package/lib/compiler/extend.js

@@ -489,6 +489,7 @@ function extend( model ) {
       const location = firstEllipsis.location || anno.name.location;
       message( 'anno-unexpected-ellipsis', [ location, art ], { code: '...' } );
       previousAnno = {
+        kind: '$annotation',
         val: [],
         literal: 'array',
         name: { id: annoName.slice( 1 ) },
@@ -499,6 +500,7 @@ function extend( model ) {
       // TODO: If we introduce sub-messages, point to the non-array base value.
       error( 'anno-mismatched-ellipsis', [ anno.name.location, art ], { code: '...' } );
       previousAnno = {
+        kind: '$annotation',
         val: [],
         literal: 'array',
         name: previousAnno.name,
@@ -532,6 +534,7 @@ function extend( model ) {
     }
     // console.log('TP:',previousValue.map(se),anno.val.map(se),'->',result.map(se))
     return {
+      kind: '$annotation',
       val: result,
       literal: 'array',
       name: previousAnno.name,

package/lib/compiler/resolve.js

@@ -1456,19 +1456,35 @@ function resolve( model ) {
     }
   }
 
-  function resolveAnnoExpr( expr, art, anno = expr ) {
+  function resolveAnnoExpr( expr, art, anno = expr, topItem = false ) {
     if (expr.$tokenTexts) {
-      if (!anno.kind)
+      if (anno === expr) {
         initAnnotationForExpression( anno, art );
+      }
+      else if (topItem) {     // item of top-level array annotation
+        setLink( expr, '_outer', anno );
+        anno = expr;
+      }
+
       const type = anno === expr && anno.name;
       // TODO: it might be best to set an _artifact link also for property values
       // like in `@Anno: [ { foo: #EnumSymbol }]
       resolveExpr( expr, 'annotation', anno, type );
     }
     else if (expr.literal === 'array') {
-      expr.val.forEach( val => resolveAnnoExpr( val, art, anno ) );
+      const withExpr = anno === expr &&
+        // the following is needed for checkAnnotationAcceptsExpressions(),
+        // otherwise @cds.persistence.skip: [hdi, hdbcds, sql.postgres] fails
+        expr.val.some( item => item.$tokenTexts || item.literal === 'struct');
+      if (withExpr)
+        initAnnotationForExpression( anno, art );
+      expr.val.forEach( val => resolveAnnoExpr( val, art, anno, withExpr ) );
     }
     else if (expr.literal === 'struct') {
+      if (topItem) {     // item of top-level array annotation
+        setLink( expr, '_outer', anno );
+        anno = expr;
+      }
       Object.values( expr.struct ).forEach( val => resolveAnnoExpr( val, art, anno ) );
     }
   }
@@ -1480,10 +1496,9 @@ function resolve( model ) {
    * @param {XSN.Artifact} art
    */
   function initAnnotationForExpression( anno, art ) {
-    anno.kind = '$annotation';
     setLink( anno, '_outer', art );
     art.$contains ??= {};
-    art.$contains.$annotation = { // set in resolveExprNode
+    art.$contains.$annotation ??= { // set in resolveExprPath
       $path: false,
       $self: false,
     };
@@ -1491,6 +1506,9 @@ function resolve( model ) {
     // Might be useful for future recursive types.
   }
 
+  // Note: for annotation assignments, `art` should be the annotation, not the
+  // assignee (element, ...); otherwise, artifact links could be resolved in the
+  // wrong block
   function resolveExpr( expr, exprCtx, art, type = null ) {
     traverseTypedExpr( expr, exprCtx, art, type, resolveExprNode );
   }
@@ -1543,8 +1561,12 @@ function resolve( model ) {
     const ref = resolvePath( expr, expected, user );
 
     if (expected === 'annotation') {
-      user._outer.$contains.$annotation.$path = true;
-      user._outer.$contains.$annotation.$self ||= expr.path[0]?._navigation?.kind === '$self';
+      const ruser = (user._outer.kind === '$annotation')
+        ? user._outer._outer
+        : user._outer;
+      // if (!ruser.$contains) console.log('UO:',!!ruser,!!user._block,user._outer)
+      ruser.$contains.$annotation.$path = true;
+      ruser.$contains.$annotation.$self ||= expr.path[0]?._navigation?.kind === '$self';
     }
 
     // check whether arguments and filters are allowed on last path item;

package/lib/compiler/shared.js

@@ -775,8 +775,13 @@ function fns( model ) {
     if (head._artifact !== undefined)
       return head._artifact;
     let ruser = user._user || user; // TODO: nicer name if we keep this
-    if (ruser.kind === '$annotation')
-      ruser = ruser._outer;
+    // TODO: re-think _user link
+    if (ruser._outer && !semantics.isMainRef) {
+      if (ruser.kind === '$annotation')
+        ruser = ruser._outer;     // for elem refs, use elem as real "user"
+      else if (ruser._outer.kind === '$annotation')
+        ruser = ruser._outer._outer;
+    }
 
     // Handle expand/inline, `type of`, :param, global (internally for CDL):
     if (user._columnParent && !semantics.isMainRef) { // in expand/inline
@@ -1002,7 +1007,8 @@ function fns( model ) {
         // TODO: remove again, should be easy enough in to-csn without.
         if (path.length === 1 && art.kind === '$tableAlias')
           (user._user || user).$noOrigin = true;
-        if (head.id === '$projection' && user.kind === '$annotation') {
+        if (head.id === '$projection' &&
+            (user.kind === '$annotation' || user._outer?.kind === '$annotation')) {
           error( 'ref-unsupported-projection', [ head.location, user ],
                  { code: '$projection', newcode: '$self' },
                  '$(CODE) is not supported in annotations; replace by $(NEWCODE)' );

package/lib/edm/annotations/edmJson.js

@@ -83,7 +83,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     });
     delete parent[op];
   };
-  const noOp = () => (true);
+  const noOp = () => {};
   //----------------------------------
   // Create the transformer dictionary
   const transform = {
@@ -96,7 +96,6 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     isNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is null'),
     isNotNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is not null'),
     exists: notADynExpr,
-    '#': notADynExpr,
     SELECT: notADynExpr,
     SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
     like: notADynExpr,
@@ -312,6 +311,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     else
       parentparent[parentprop] = xpr;
   };
+  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentprop, txt) => {
+    if (parent['#'] && parent.val) // enum reference that was resolved by the compiler
+      delete parent['#'];
+    else
+      notADynExpr(parent, prop, xpr, csnPath, parentParent, parentprop, txt);
+  };
   transform.ref = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     if (xpr.some(ps => ps.args || ps.where)) {
       error('odata-anno-xpr-ref', location, {

package/lib/edm/edmPreprocessor.js

@@ -5,7 +5,8 @@ const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model')
 const {
   forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isEdmPropertyRendered, getUtils,
-  applyTransformations, transformAnnotationExpression, findAnnotationExpression,
+  applyTransformations, applyTransformationsOnNonDictionary,
+  transformAnnotationExpression, findAnnotationExpression,
   cardinality2str,
 } = require('../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../base/builtins');
@@ -322,11 +323,32 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         if (node.$path && dotEntityNameMap[node.$path[1]])
           node.$path[1] = dotEntityNameMap[node.$path[1]];
 
+        if (node.projection || node.query) {
+          applyTransformationsOnNonDictionary(node.projection || node.query, undefined, {
+            ref: (parent, prop, ref) => {
+              if (dotEntityNameMap[ref[0]])
+                parent.ref[0] = dotEntityNameMap[ref[0]];
+            },
+          }, { directDict: true });
+        }
+
         rewriteReferencesInActions(node);
       };
 
-      forEachMemberRecursively(def, applyOnNode);
+      const applyOnAnnoXprs = (node) => {
+        Object.keys(node).filter(pn => pn[0] === '@').forEach((anno) => {
+          transformAnnotationExpression(node, anno, {
+            ref: (elemRef, _prop, ref) => {
+              if (dotEntityNameMap[ref[0]] || dotTypeNameMap[ref[0]])
+                elemRef.ref[0] = dotEntityNameMap[ref[0]] || dotTypeNameMap[ref[0]];
+            },
+          });
+        });
+      };
+
+      forEachMemberRecursively(def, [ applyOnNode, applyOnAnnoXprs ]);
       applyOnNode(def);
+      applyOnAnnoXprs(def);
       // handle unbound action/function and params in views
       rewriteReferencesInActions(def);
     };

package/lib/transform/db/rewriteCalculatedElements.js

@@ -697,8 +697,10 @@ function removeDummyValueInEntity( artifact, path, options ) {
 function dummifyInEntity( artifact, path ) {
   applyTransformationsOnDictionary(artifact.elements, {
     value: (parent, _prop, value) => {
-      if (!value.stored)
+      if (!value.stored) {
         parent.value = { val: 'DUMMY' };
+        delete parent.localized;
+      }
     },
   }, {}, path);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.9.4",
+  "version": "5.9.6",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -18,7 +18,8 @@
     "gen": "node ./scripts/build.js && node scripts/genGrammarChecksum.js && node ./redepage/bin/redepage --compile lib/gen/CdlParser.js --copy-base-parser lib/parsers/CdlGrammar.g4",
     "xmakeAfterInstall": "npm run gen",
     "xmakePrepareRelease": "echo \"$(node scripts/stripReadme.js README.md)\" > README.md && node scripts/assertSnapshotVersioning.js && node scripts/assertChangelog.js && node scripts/cleanup.js --remove-dev",
-    "test": "npm run test:piper",
+    "test": "node scripts/xmakeTestDispatcher.js",
+    "test:xmake": "npm run test3 -- --topic=Drafts --test=CalculatedElements",
     "test:ci": "node scripts/verifyGrammarChecksum.js && mocha --timeout 10000 --reporter-option maxDiffSize=0 scripts/testLazyLoading.js && mocha --parallel --reporter-option maxDiffSize=0 test/ test3/",
     "test:piper": "node scripts/verifyGrammarChecksum.js && npm run coverage:piper",
     "test3": "node scripts/verifyGrammarChecksum.js && mocha --reporter-option maxDiffSize=0 test3/",