@sap/cds-compiler 4.7.4 → 4.8.0

package/lib/edm/annotations/edmJson.js

@@ -7,7 +7,7 @@ const {
   EdmTypeFacetNames,
   EdmPrimitiveTypeMap,
 } = require('../EdmPrimitiveTypeDefinitions.js');
-const { isBuiltinType, isAnnotationExpression } = require('../../model/csnUtils');
+const { isBuiltinType, isAnnotationExpression } = require('../../base/builtins');
 const { transformExpression } = require('../../transform/db/applyTransformations.js');
 
 /**
@@ -270,7 +270,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ exact: 2 }, xpr, prop);
     transformExpression(xpr, undefined, transform);
     delete parent[prop];
-    parentparent[parentprop].$Apply = [ { $Function: 'odata.concat' }, ...xpr ];
+    parentparent[parentprop].$Apply = xpr;
+    parentparent[parentprop].$Function = 'odata.concat';
   };
   //----------------------------------
   // ARITHMETICAL AND UNARY
@@ -305,8 +306,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   transform.ref = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     if (xpr.some(ps => ps.args || ps.where)) {
-      error('odata-anno-xpr-args', location, {
-        anno, elemref: parent, '#': 'wrongref',
+      error('odata-anno-xpr-ref', location, {
+        anno, elemref: parent, '#': 'args',
       });
     }
     const [ head, ...tail ] = xpr;
@@ -742,7 +743,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         }
         else {
           evalArgs(argDef, parent.args, xpr);
-          parentparent[parentprop].$Apply = [ { $Function: funcName }, ...(parent.args || []) ];
+          parentparent[parentprop].$Apply = [ ...(parent.args || []) ];
+          parentparent[parentprop].$Function = funcName;
           delete parentparent[parentprop].func;
           delete parentparent[parentprop].args;
           transformExpression(parentparent, parentprop, transform);

package/lib/edm/annotations/genericTranslation.js

@@ -1,11 +1,11 @@
 'use strict';
 
-const { isEdmPropertyRendered, isBuiltinType, transformExpression } = require('../../model/csnUtils');
+const { isEdmPropertyRendered, transformExpression } = require('../../model/csnUtils');
+const { isBuiltinType } = require('../../base/builtins');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const { forEachDefinition } = require('../../model/csnUtils');
-// const { csnRefs } = require('../../model/csnRefs');
 const { isBetaEnabled, setProp } = require('../../base/model.js');
 const { xpr2edmJson, getEdmJsonHandler } = require('./edmJson.js');
 const { vocabularyDefinitions } = require('./vocabularyDefinitions.js');
@@ -18,7 +18,7 @@ const { EdmPathTypeMap } = require('../EdmPrimitiveTypeDefinitions.js');
  *   v - array with two boolean entries, first is for v2, second is for v4
  *   dictReplacement: for test purposes, replaces the standard oDataDictionary
  */
-function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
+function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                             Edm, options, messageFunctions, mergedVocDefs = vocabularyDefinitions ) {
   const gAnnosArray = []; // global variable where we store all the generated annotations
   const usedExperimentalTerms = {}; // take note of all experimental annos that have been used
@@ -27,7 +27,6 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
   const { v } = options;
   const { message, error } = messageFunctions;
   const { handleEdmJson } = getEdmJsonHandler(Edm, options, messageFunctions, handleTerm);
-  // const { inspectRef } = csnRefs(reqDefs);
 
   const [ userDefinedTermDict, allKnownVocabularies ] = createUserDefinedTermDictionary();
 
@@ -57,8 +56,10 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
             { name: serviceName, '#': 'service' } );
   }
 
-  assignParameterAnnotations();
-
+  forEachDefinition(reqDefs, (def, defName) => {
+    if (defName.startsWith(`${serviceName}.`))
+      assignParameterAnnotations(def);
+  });
   // Crawl over the csn and trigger the annotation translation for all kinds
   //   of annotated things.
   // Note: only works for single service
@@ -96,15 +97,23 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     return v && v[0];
   }
 
-  function assignParameterAnnotations() {
+  function assignParameterAnnotations( def ) {
     // Copy annotations from origin to parameter entity if it's
     // qualified with #$parameters or if its applicable to an EntitySet or Singleton
     const scopeCheck = {
       ref: (elemref, prop, xpr, path) => {
-        if (scopeCheck.scope === 'param' && (!elemref.param || (xpr[0].id || xpr[0]) === '$self'))
-          error('odata-anno-xpr-ref', path, { elemref, anno: scopeCheck.anno, '#': 'notaparam' });
-        if (scopeCheck.scope === 'type' && elemref.param)
-          error('odata-anno-xpr-ref', path, { elemref, anno: scopeCheck.anno, '#': 'notaneelement' });
+        if (scopeCheck.scope === 'param' && (!elemref.param || (xpr[0].id || xpr[0]) === '$self')) {
+          error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaparam' });
+          // don't try to resolve those paths later on
+          delete elemref[prop];
+        }
+        if (scopeCheck.scope === 'type' && elemref.param) {
+          error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaneelement' });
+          delete elemref[prop];
+        }
+        if (scopeCheck.scope === 'param' && elemref.param)
+          // make sure that path is resolvable as element path later on
+          delete elemref.param;
       },
     };
     const checkDict = (dict, scope) => {
@@ -119,52 +128,49 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
         });
       }
     };
-    const checkDef = (def, scope) => {
+    const checkObj = (obj, scope) => {
       scopeCheck.scope = scope;
-      const knownAnnos = filterKnownAnnotations(def);
+      const knownAnnos = filterKnownAnnotations(obj);
       knownAnnos.forEach((pn) => {
         scopeCheck.anno = pn;
-        transformExpression(def, pn, scopeCheck, def.$path);
+        transformExpression(obj, pn, scopeCheck, obj.$path);
       });
     };
-    forEachDefinition(reqDefs, (object) => {
-      if (object.$isParamEntity && object._origin) {
-        // check for correct paths
-        if (object._origin.$paramAnnoProxies) {
-          object.$eltAnnoProxies = object._origin.$paramAnnoProxies;
-          object._origin.$paramAnnoProxies = null;
-          checkDict(object.$eltAnnoProxies, 'param');
-        }
-        checkDict(object._origin.$eltAnnoProxies, 'type');
-        checkDict(object.elements, 'param');
-        checkDict(object._origin.elements, 'type');
-
-        scopeCheck.scope = 'param';
-        Object.keys(object._origin).forEach((attr) => {
-          if (attr[0] === '@') {
-            scopeCheck.anno = attr;
-            const [ prefix, innerAnnotation ] = attr.split('.@');
-            const ns = whatsMyTermNamespace(prefix);
-            if (ns) {
-              const steps = prefix.replace(`@${ns}.`, '').split('.');
-              const paramAnnoParts = steps[0].split('#$parameters');
-              const dictTerm = getDictTerm(`${ns}.${paramAnnoParts[0]}`, options);
-              if (paramAnnoParts.length > 1 || [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
-                steps[0] = `@${ns}.${paramAnnoParts.join('')}`;
-                let newAnno = steps.join('.');
-                if (innerAnnotation)
-                  newAnno += `.@${innerAnnotation}`;
-                edmUtils.assignAnnotation(object, newAnno, object._origin[attr]);
-                transformExpression(object._origin, attr, scopeCheck, object._origin.$path);
-                if (paramAnnoParts.length > 1)
-                  delete object._origin[attr];
-              }
+    if (def.$isParamEntity && def._origin) {
+      // check for correct paths
+      if (def._origin.$paramsAnnoProxies) {
+        def.$elementsAnnoProxies = def._origin.$paramsAnnoProxies;
+        checkDict(def.$elementsAnnoProxies, 'param');
+      }
+      checkDict(def._origin.$elementsAnnoProxies, 'type');
+      checkDict(def.elements, 'param');
+      checkDict(def._origin.elements, 'type');
+
+      scopeCheck.scope = 'param';
+      Object.keys(def._origin).forEach((attr) => {
+        if (attr[0] === '@') {
+          scopeCheck.anno = attr;
+          const [ prefix, innerAnnotation ] = attr.split('.@');
+          const ns = whatsMyTermNamespace(prefix);
+          if (ns) {
+            const steps = prefix.replace(`@${ns}.`, '').split('.');
+            const paramAnnoParts = steps[0].split('#$parameters');
+            const dictTerm = getDictTerm(`${ns}.${paramAnnoParts[0]}`, options);
+            if (paramAnnoParts.length > 1 || [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
+              steps[0] = `@${ns}.${paramAnnoParts.join('')}`;
+              let newAnno = steps.join('.');
+              if (innerAnnotation)
+                newAnno += `.@${innerAnnotation}`;
+              edmUtils.assignAnnotation(def, newAnno, def._origin[attr]);
+              transformExpression(def._origin, attr, scopeCheck, def._origin.$path);
+              if (paramAnnoParts.length > 1)
+                delete def._origin[attr];
             }
           }
-        });
-        checkDef(object._origin, 'type');
-      }
-    });
+        }
+      });
+      checkObj(def._origin, 'type');
+    }
   }
 
   /*
@@ -208,10 +214,10 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     // definition bound annotations
     handleAnnotations(defName, def, location);
     // definition bound element annotations
-    if (def.$eltAnnoProxies) {
-      Object.entries(def.$eltAnnoProxies).forEach(([ elemPath, element ]) => {
+    if (def.$elementsAnnoProxies) {
+      Object.entries(def.$elementsAnnoProxies).forEach(([ elemPath, element ]) => {
         const edmTargetName = `${defName}/${elemPath}`;
-        handleAnnotations(edmTargetName, element, element.$path);
+        handleAnnotations(edmTargetName, element, element.$path, [ ...location, '$elementsAnnoProxies', elemPath ]);
       });
     }
     // element bound annotations
@@ -269,12 +275,24 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     handleAnnotations(actionName, cAction, location);
 
     if (cAction.params) {
+      if (cAction.$paramsAnnoProxies) {
+        Object.entries(cAction.$paramsAnnoProxies).forEach(([ paramPath, param ]) => {
+          const edmTargetName = `${actionName}/${paramPath}`;
+          handleAnnotations(edmTargetName, param, param.$path, [ ...location, '$paramsAnnoProxies', paramPath ]);
+        });
+      }
       Object.entries(cAction.params).forEach(([ n, p ]) => {
         const edmTargetName = `${actionName}/${n}`;
         handleAnnotations(edmTargetName, p, [ ...location, 'params', n ]);
       });
     }
     if (cAction.returns) {
+      if (cAction.$returnsAnnoProxies) {
+        Object.entries(cAction.$returnsAnnoProxies).forEach(([ returnsPath, returns ]) => {
+          const edmTargetName = `${actionName}/${returnsPath}`;
+          handleAnnotations(edmTargetName, returns, returns.$path, [ ...location, '$returnsAnnoProxies', returnsPath ]);
+        });
+      }
       const edmTargetName = `${actionName}/$ReturnType`;
       setProp(cAction.returns, '$appliesToReturnType', true);
       handleAnnotations(edmTargetName, cAction.returns, [ ...location, 'returns' ]);
@@ -324,7 +342,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
   //   edmTargetName : string, name of the target in edm
   //   carrier: object, the annotated cds thing, contains all the annotations
   //                    as properties with names starting with @
-  function handleAnnotations( edmTargetName, carrier, location ) {
+  function handleAnnotations( edmTargetName, carrier, location, csnPathResolutionLocation = location ) {
     // collect the names of the carrier's annotation properties
     // keep only those annotations that - start with a known vocabulary name
     //                                  - have a value other than null
@@ -353,8 +371,46 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     }
     if (isBetaEnabled(options, 'odataAnnotationExpressions')) {
       knownAnnos.forEach((knownAnno) => {
-        if (knownAnno.search(/\.\$edmJson\./g) < 0)
+        if (knownAnno.search(/\.\$edmJson\./g) < 0) {
+          if (isBetaEnabled(options, 'odataPathsInAnnotationExpressions')) {
+            transformExpression(carrier, knownAnno, {
+              ref: (elemref, prop, xpr, csnPath) => {
+                const { links, scope } = reqDefsUtils.inspectRef(csnPath);
+                let i = scope === '$self' ? 1 : 0;
+                const getProp = propName => (links[i].art ? (links[i].art[propName] || reqDefsUtils.effectiveType(links[i].art)[propName]) : undefined);
+                if (scope === '$magic')
+                  return;
+                let stop = false;
+                for (; i < links.length && !stop; i++) {
+                  const cardinality = getProp('cardinality');
+                  if ((cardinality && cardinality.max !== 1) || getProp('items')) {
+                    error('odata-anno-xpr-ref', location, {
+                      count: i + 1, elemref, anno: knownAnno, '#': 'tomany',
+                    });
+                    stop = true;
+                  }
+                  if (!isEdmPropertyRendered(links[i].art, csnPath)) {
+                    error('odata-anno-xpr-ref', location, {
+                      count: i + 1, elemref, anno: knownAnno, '#': 'notrendered',
+                    });
+                    stop = true;
+                  }
+                  if (links[i].art?._target?.$proxy && i < links.length - 1) {
+                    const proxy = links[i].art?._target;
+                    const eltName = links[i + 1].art?.name;
+                    if (!proxy.elements[eltName]) {
+                      error('odata-anno-xpr-ref', location, {
+                        count: i + 2, elemref, anno: knownAnno, '#': 'notrendered',
+                      });
+                      stop = true;
+                    }
+                  }
+                }
+              },
+            }, csnPathResolutionLocation);
+          }
           xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
+        }
       });
     }
 
@@ -1358,6 +1414,8 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
             dict.xrefs[myServiceRoot] = { $myServiceRoot: myServiceRoot, used: false };
           const edmType = new Edm.TypeBase(options.v, {}, annoDef);
           dictDef = edmType._edmAttributes;
+          if (dictDef.Type?.startsWith('Edm.Int'))
+            dictDef.Type = 'Edm.Int';
           dictDef.$myServiceRoot = myServiceRoot;
           let val = annoDef['@odata.term.AppliesTo'];
           if (val != null)

package/lib/edm/csn2edm.js

@@ -11,8 +11,9 @@ const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
-  isEdmPropertyRendered, isBuiltinType, getUtils,
+  isEdmPropertyRendered, getUtils, findAnnotationExpression,
 } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { checkCSNVersion } = require('../json/csnVersion');
 const {
   EdmTypeFacetMap,
@@ -86,7 +87,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
     return rc;
   }
 
-  const reqDefsUtils = getUtils(reqDefs);
+  // refresh csn cache after preprocessor model augmentation with parameters, types, proxies etc
+  const csnUtils = getUtils(csn);
 
   if (serviceNames === undefined)
     serviceNames = options.serviceNames;
@@ -744,17 +746,31 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         // bpName is eventually used later for EntitySetPath
         // No explicit binding parameter, check (user defined) annotation value)
         if (!actionCsn.$bindingParam) {
-          const bpNameAnno = actionCsn['@cds.odata.bindingparameter.name'];
+          const bpnAnnoName = '@cds.odata.bindingparameter.name';
+          const bpnAnnoLoc = [ ...location, bpnAnnoName ];
+          const bpNameAnno = actionCsn[bpnAnnoName];
           if (bpNameAnno != null) {
             if (typeof bpNameAnno === 'string')
               bpName = bpNameAnno;
-            if (typeof bpNameAnno === 'object' && bpNameAnno['='])
-              bpName = bpNameAnno['='];
+            if (typeof bpNameAnno === 'object' && bpNameAnno['=']) {
+              if (findAnnotationExpression(actionCsn, bpnAnnoName)) {
+                if (!bpNameAnno.ref)
+                  message('odata-anno-xpr', bpnAnnoLoc, { anno: bpnAnnoName, '#': 'unexpected' });
+                else if (bpNameAnno.ref.length !== 1)
+                  error('odata-anno-xpr-ref', bpnAnnoLoc, { anno: bpnAnnoName, elemref: bpNameAnno, '#': 'invalid' });
+                else
+                  bpName = bpNameAnno.ref[0];
+              }
+              else {
+                bpName = bpNameAnno['='];
+              }
+            }
           }
+
           if (!edmUtils.isODataSimpleIdentifier(bpName))
-            message('odata-spec-violation-id', [ ...location, '@cds.odata.bindingparameter.name' ], { id: bpName });
+            message('odata-spec-violation-id', bpnAnnoLoc, { id: bpName });
           if (actionCsn.params && actionCsn.params[bpName])
-            error('duplicate-definition', [ ...location, '@cds.odata.bindingparameter.name' ], { '#': 'param', name: bpName });
+            error('duplicate-definition', bpnAnnoLoc, { '#': 'param', name: bpName });
         }
         if (entityCsn) {
           actionNode.setEdmAttribute('IsBound', true);
@@ -1072,8 +1088,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
     function addAnnotations2XServiceRefs( ) {
-      options.getFinalTypeInfo = reqDefsUtils.getFinalTypeInfo;
-      const { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
+      options.getFinalTypeInfo = csnUtils.getFinalTypeInfo;
+      const { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csnUtils, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema
       annos.forEach((anno) => {

package/lib/edm/edm.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const edmUtils = require('./edmUtils.js');
-const { isBuiltinType } = require('../model/csnUtils.js');
+const edmUtils = require('./edmUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { forEach } = require('../utils/objectUtils');
 const {
   EdmTypeFacetMap,
@@ -782,7 +782,7 @@ function getEdm( options, messageFunctions ) {
       super(version, attributes, csn);
       const appliesTo = csn['@odata.term.AppliesTo'];
       if (appliesTo)
-        this.setEdmAttribute('AppliesTo', Array.isArray(appliesTo) ? appliesTo.map(v => v['='] || v).join(' ') : appliesTo['='] || appliesTo);
+        this.setEdmAttribute('AppliesTo', Array.isArray(appliesTo) ? appliesTo.join(' ') : appliesTo);
     }
   }
 

package/lib/edm/edmInboundChecks.js

@@ -2,8 +2,9 @@
 
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
-  forEachDefinition, forEachMemberRecursively, isBuiltinType, getUtils,
+  forEachDefinition, forEachMemberRecursively, getUtils,
 } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { assignAnnotation } = require('./edmUtils.js');
 
 // eslint-disable-next-line no-unused-vars
@@ -49,6 +50,15 @@ function inboundQualificationChecks( csn, options, messageFunctions,
     // check items.items
     checkIfItemsOfItems(def, undefined, undefined, location);
     forEachMemberRecursively(def, checkIfItemsOfItems, location);
+    checkIfItemsOfItems(def.returns, undefined, undefined, location.concat('returns'));
+    if (def.actions) {
+      Object.entries(def.actions).forEach(([ n, action ]) => {
+        const aLoc = location.concat('actions', n);
+        checkIfItemsOfItems(action, undefined, undefined, aLoc);
+        forEachMemberRecursively(action, checkIfItemsOfItems, aLoc);
+        checkIfItemsOfItems(action.returns, undefined, undefined, aLoc.concat('returns'));
+      });
+    }
 
     // decorate UUID keys with @Core.ComputedDefaultValue and complain
     // on named type UUID elements that have no such annotation
@@ -88,14 +98,23 @@ function inboundQualificationChecks( csn, options, messageFunctions,
     }
 
     function checkIfItemsOfItems( member, _memberName, _prop, path ) {
+      if (!member)
+        return;
       const memberType = csnUtils.effectiveType(member);
-      if (memberType.items) {
-        if (memberType.items.target) {
-          const isComp = memberType.items.type === 'cds.Composition';
+      let { items } = memberType;
+      if (items) {
+        if (items.target) {
+          const isComp = items.type === 'cds.Composition';
           message('type-invalid-items', path, { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
           return;
         }
-        if (memberType.items.items) {
+        let i = 1;
+        while (items) {
+          items = items.items;
+          if (items)
+            i++;
+        }
+        if (i > 1) {
           message('chained-array-of', path);
           return;
         }

package/lib/edm/edmPreprocessor.js

@@ -5,9 +5,10 @@ const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model')
 const {
   forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isEdmPropertyRendered, getUtils,
-  isBuiltinType, applyTransformations, transformExpression, findAnnotationExpression,
-  cardinality2str, isMagicVariable,
+  applyTransformations, transformExpression, findAnnotationExpression,
+  cardinality2str,
 } = require('../model/csnUtils');
+const { isBuiltinType, isMagicVariable } = require('../base/builtins');
 const edmUtils = require('./edmUtils.js');
 const edmAnnoPreproc = require('./edmAnnoPreprocessor.js');
 const { inboundQualificationChecks } = require('./edmInboundChecks.js');
@@ -540,7 +541,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       // preserve the original target for constraint calculation
       setProp(entityCsn.$sources[n], '_originalTarget', entityCsn.$sources[n]._target);
       entityCsn.$sources[n]._target = parameterCsn;
-      entityCsn.$sources[n].target = parameterCsn.name;
     });
   }
 
@@ -1905,6 +1905,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         markCollection(member.returns);
         mapCdsToEdmProp(member.returns);
         annotateAllowedValues(member.returns, [ ...location, 'returns' ]);
+        rewriteAnnotationExpressions(member.returns);
       }
     }, defLocation);
     // mark members that need to be rendered as collections
@@ -2038,11 +2039,12 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
           if (edmUtils.isNavigable(assoc) && isMyServiceRequested(containee.name) || containee.$proxy) {
             const localAssocPath = path.join('.');
-            let navPropEntry = localRestrictions.find(p => p.NavigationProperty && p.NavigationProperty['='] === prefix.concat(localAssocPath).join('.'));
+            const laprefix = prefix.concat(localAssocPath).join('.');
+            let navPropEntry = localRestrictions.find(p => p.NavigationProperty && p.NavigationProperty['='] === laprefix);
             const hasEntry = !!navPropEntry;
 
             if (!hasEntry)
-              navPropEntry = { NavigationProperty: { '=': prefix.concat(localAssocPath).join('.') } };
+              navPropEntry = { NavigationProperty: { '=': laprefix } };
 
 
             const props = Object.entries(containee);
@@ -2172,8 +2174,8 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     // rewrite annotation expression paths such that they are defined against the definition
     const absPath = $path2path(carrier.$path);
     let isSubTreeSpan = true;
-    const rootPrefix = absPath.slice(1, absPath.length - 1);
 
+    let rootPrefix = absPath.slice(1, absPath.length - 1);
     const isExprAnno = (obj, pn) => isBetaEnabled(options, 'odataPathsInAnnotationExpressions') && findAnnotationExpression(obj, pn);
 
     const subTreeSpan = {
@@ -2181,8 +2183,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         const head = xpr[0].id || xpr[0];
         if (head === '$self' || parent.param) {
           let j = parent.param ? 0 : 1;
+          const k = parent.param ? 1 : 0;
+          isSubTreeSpan = isSubTreeSpan && (absPath.length - k <= xpr.length);
           for (let i = 1; i < absPath.length - 1 && isSubTreeSpan; i++, j++)
-            isSubTreeSpan = (xpr[j].id || xpr[j]) === absPath[i];
+            isSubTreeSpan = isSubTreeSpan && (xpr[j].id || xpr[j]) === absPath[i];
         }
       },
     };
@@ -2197,10 +2201,13 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           for (let i = 1; i < absPath.length - 1 && absPathPrefixEqual; i++, j++)
             absPathPrefixEqual = (xpr[j].id || xpr[j]) === absPath[i];
 
-          if (absPathPrefixEqual)
+          if (absPathPrefixEqual) {
             // remove prefix between $self and leaf element name
             // or starting with the parameter name
             xpr.splice(parent.param ? 0 : 1, absPath.length - 2);
+            if (parent.param)
+              parent.param = null;
+          }
         }
       },
     };
@@ -2224,6 +2231,29 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           acc[isExprAnno(carrier, pn) ? 0 : 1].push(pn);
         return acc;
       }, [ [], [] ]);
+
+      let scope = carrier.$path[2];
+      let def = csn.definitions[carrier.$path[1]];
+      // unbound
+      if (scope === 'returns') {
+        absPath[1] = '$ReturnType';
+        rootPrefix = absPath.slice(3, absPath.length - 1);
+      }
+      let eltPath = absPath.slice(1).join('/');
+      // bound action
+      if (scope === 'actions' && def[scope][carrier.$path[3]]) {
+        def = def[scope][carrier.$path[3]];
+        scope = carrier.$path[4];
+        if (scope === 'params')
+          rootPrefix = absPath.slice(2, absPath.length - 1);
+        if (scope === 'returns') {
+          absPath[2] = '$ReturnType';
+          rootPrefix = absPath.slice(3, absPath.length - 1);
+          eltPath = absPath.slice(2).join('/');
+        }
+      }
+      const proxyDict = `$${scope}AnnoProxies`;
+
       xprANames.forEach((xprAName) => {
         isSubTreeSpan = true;
         transformExpression(carrier, xprAName, subTreeSpan);
@@ -2231,18 +2261,14 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           transformExpression(carrier, xprAName, relativize);
         }
         else {
-          const scope = carrier.$path[2];
           absolutize.scope = scope;
           transformExpression(carrier, xprAName, absolutize);
-          const def = csn.definitions[absPath[0]];
-          const eltPath = absPath.slice(1).join('/');
-          const proxyDict = scope === 'elements' ? '$eltAnnoProxies' : '$paramAnnoProxies';
 
           if (!def[proxyDict])
             setProp(def, proxyDict, Object.create(null));
-          let eltProxy = def[proxyDict][eltPath];
-          if (!eltProxy) {
-            eltProxy = Object.create(null);
+          let proxyCarrier = def[proxyDict][eltPath];
+          if (!proxyCarrier) {
+            proxyCarrier = Object.create(null);
             // these attributes are needed to test for
             // Property, Parameter, NavigationProperty, Collection
             // Applicability
@@ -2255,18 +2281,18 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
               '@cds.api.ignore',
               '@odata.navigable' ].forEach((prop) => {
               if (carrier[prop] != null)
-                setProp(eltProxy, prop, carrier[prop]);
+                setProp(proxyCarrier, prop, carrier[prop]);
             });
 
             Object.keys(carrier).filter(pn => pn[0] !== '@').forEach((pn) => {
-              eltProxy[pn] = carrier[pn];
+              proxyCarrier[pn] = carrier[pn];
             });
-            def[proxyDict][eltPath] = eltProxy;
+            def[proxyDict][eltPath] = proxyCarrier;
           }
-          eltProxy[xprAName] = carrier[xprAName];
+          proxyCarrier[xprAName] = carrier[xprAName];
           carrier[xprAName] = null;
           nxprANames.filter(an => an.startsWith(`${xprAName}.`)).forEach((nxprAName) => {
-            eltProxy[nxprAName] = carrier[nxprAName];
+            proxyCarrier[nxprAName] = carrier[nxprAName];
             carrier[nxprAName] = null;
           });
         }

package/lib/edm/edmUtils.js

@@ -1,9 +1,10 @@
 'use strict';
 
-const { setProp, isBetaEnabled } = require('../base/model');
+const { setProp } = require('../base/model');
 const {
-  isBuiltinType, isEdmPropertyRendered, applyTransformations,
+  isEdmPropertyRendered, applyTransformations,
 } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { escapeString, hasControlCharacters, hasUnpairedUnicodeSurrogate } = require('../render/utils/stringEscapes');
 const { CompilerAssertion } = require('../base/error');
 const { cloneAnnotationValue } = require('../model/cloneCsn');
@@ -31,20 +32,6 @@ function validateOptions( _options ) {
     options.isV4 = () => v4;
 
     options.pathDelimiter = options.isStructFormat ? '/' : '_';
-
-    if (isBetaEnabled(options, 'v5preview')) {
-      if (!options.severities)
-        options.severities = {};
-      options.severities['odata-spec-violation-array'] ??= 'Error';
-      options.severities['odata-spec-violation-assoc'] ??= 'Error';
-      options.severities['odata-spec-violation-namespace'] ??= 'Error';
-      options.severities['odata-spec-violation-param'] ??= 'Error';
-      options.severities['odata-spec-violation-returns'] ??= 'Error';
-      options.severities['odata-spec-violation-type-unknown'] ??= 'Error';
-      options.severities['odata-spec-violation-no-key'] ??= 'Error';
-      options.severities['odata-spec-violation-key-type'] ??= 'Error';
-      options.severities['odata-spec-violation-property-name'] ??= 'Error';
-    }
     return options;
   }
   return _options;

package/lib/gen/Dictionary.json

@@ -3030,6 +3030,15 @@
         "ValueListProperty": "Edm.String"
       }
     },
+    "Common.ValueListParameterConstants": {
+      "$kind": "ComplexType",
+      "BaseType": "Common.ValueListParameter",
+      "Properties": {
+        "Constants": "Collection(Edm.PrimitiveType)",
+        "ValueListProperty": "Edm.String"
+      },
+      "$experimental": true
+    },
     "Common.ValueListParameterInOut": {
       "$kind": "ComplexType",
       "BaseType": "Common.ValueListParameter",