@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/compiler/{classes.js → xsn-model.js}

@@ -39,24 +39,8 @@ class XsnName {
   location;
 }
 
-class CsnLocation {
-  file;
-  line;
-  col;
-  endLine;
-  endCol;
-  constructor(file, line, col, endLine, endCol) {
-    this.file = file;
-    this.line = line;
-    this.col = col;
-    this.endLine = endLine;
-    this.endCol = endCol;
-  }
-}
-
 module.exports = {
   XsnSource,
   XsnArtifact,
   XsnName,
-  CsnLocation,
 };

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,29 @@ 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' && !def.elements.$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 head = xpr[0].id || xpr[0];
+          if (head[0] === '$')
+            xpr.unshift('$self');
+        }
       },
     };
     const checkDict = (dict, scope) => {
@@ -119,52 +134,50 @@ 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');
+    }
   }
 
   /*
@@ -179,12 +192,14 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
   There is one exception (Schema), see below
 
   carrier = service
-    the target is the EntityContainer, unless the annotation has an "AppliesTo" where only Schema is given, but not EntityContainer
-    then the <Annotation ...> is directly put into <Schema ...> without an enclosing <Annotations ...>
+    the target is the EntityContainer, unless the annotation has an "AppliesTo"
+    where only Schema is given, but not EntityContainer then the <Annotation ...>
+    is directly put into <Schema ...> without an enclosing <Annotations ...>
 
   carrier = entity (incl. view/projection)
-    the target is the corresponding EntityType, unless the annotation has an "AppliesTo" where only EntitySet is given, but not EntityType
-    then the target is the corresponding EntitySet
+    the target is the corresponding EntityType, unless the annotation has an
+    "AppliesTo" where only EntitySet is given, but not EntityType then the target
+    is the corresponding EntitySet
 
   carrier = structured type
     the target is the corresponding ComplexType
@@ -208,10 +223,11 @@ 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,15 +285,31 @@ 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 ]);
+        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' ]);
+      handleAnnotations(edmTargetName, cAction.returns,
+                        [ ...location, 'returns' ]);
       delete cAction.returns.$appliesToReturnType;
     }
 
@@ -286,12 +318,19 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       const params = [];
       if (entityNameIfBound) {
         // If this is an action and has an explicit binding parameter add it here
-        if (cAction.$bindingParam && cAction.kind === 'action')
-          params.push(cAction.$bindingParam.items ? `Collection(${entityNameIfBound})` : entityNameIfBound);
-
+        if (cAction.$bindingParam && cAction.kind === 'action') {
+          params.push(
+            cAction.$bindingParam.items
+              ? `Collection(${entityNameIfBound})`
+              : entityNameIfBound
+          );
+        }
         // If action/function has no explicit binding parameter add it here
-        else if (!cAction.$bindingParam)
-          params.push(cAction['@cds.odata.bindingparameter.collection'] ? `Collection(${entityNameIfBound})` : entityNameIfBound);
+        else if (!cAction.$bindingParam) {
+          params.push(cAction['@cds.odata.bindingparameter.collection']
+            ? `Collection(${entityNameIfBound})`
+            : entityNameIfBound);
+        }
       }
       // In case this is a function the explicit binding parameter is part of
       // the functions params dictionary. Only for functions all parameters must
@@ -324,7 +363,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
@@ -351,12 +390,49 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       if (knownAnnos.length === 0)
         return;
     }
-    if (isBetaEnabled(options, 'odataAnnotationExpressions')) {
-      knownAnnos.forEach((knownAnno) => {
-        if (knownAnno.search(/\.\$edmJson\./g) < 0)
-          xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
-      });
-    }
+
+    knownAnnos.forEach((knownAnno) => {
+      if (knownAnno.search(/\.\$edmJson\./g) < 0) {
+        transformExpression(carrier, knownAnno, {
+          ref: (elemref, prop, xpr, csnPath) => {
+            if (options.isV2() && elemref.$bparam) {
+              error('odata-anno-xpr-ref', location, {
+                elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2',
+              });
+              return;
+            }
+            const { links, scope } = reqDefsUtils.inspectRef(csnPath);
+            let i = scope === '$self' ? 1 : 0;
+            if (scope === '$magic') {
+              error('odata-anno-xpr-ref', location, {
+                elemref, anno: knownAnno, '#': 'magic',
+              });
+              return;
+            }
+            let stop = false;
+            for (; i < links.length && !stop; i++) {
+              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);
+      }
+    });
 
     const prefixTree = createPrefixTree();
 
@@ -1358,6 +1434,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,
@@ -19,11 +19,11 @@ function getEdm( options, messageFunctions ) {
      */
     constructor(version, attributes = Object.create(null), csn = undefined) {
       if (!attributes || typeof attributes !== 'object')
-        error(null, 'Please debug me: attributes must be a dictionary');
+        error(null, 'Debug me: attributes must be a dictionary');
       if (!Array.isArray(version))
-        error(null, `Please debug me: v is either undefined or not an array: ${version}`);
+        error(null, `Debug me: v is either undefined or not an array: ${version}`);
       if (version.filter(v => v).length !== 1)
-        error(null, 'Please debug me: exactly one version must be set');
+        error(null, 'Debug me: exactly one version must be set');
 
       // Common attributes of JSON and XML.
       // Note: Can't assign attributes directly, due to the input object being modified.
@@ -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);
     }
   }
 
@@ -1108,7 +1108,7 @@ function getEdm( options, messageFunctions ) {
             json.$OnDelete = c._edmAttributes.Action;
             break;
           default:
-            error(null, `Please debug me: Unhandled NavProp child: ${c.kind}`);
+            error(null, `Debug me: Unhandled NavProp child: ${c.kind}`);
         }
       });
       // TODO Annotations

package/lib/edm/edmInboundChecks.js

@@ -2,8 +2,10 @@
 
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
-  forEachDefinition, forEachMemberRecursively, isBuiltinType, getUtils,
+  forEachDefinition, forEachMemberRecursively, getUtils,
+  transformExpression, findAnnotationExpression,
 } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { assignAnnotation } = require('./edmUtils.js');
 
 // eslint-disable-next-line no-unused-vars
@@ -49,6 +51,17 @@ 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);
+        markBindingParamPaths(action, aLoc);
+        forEachMemberRecursively(action, checkIfItemsOfItems, aLoc);
+        checkIfItemsOfItems(action.returns, undefined, undefined, aLoc.concat('returns'));
+        markBindingParamPaths(action, aLoc);
+      });
+    }
 
     // decorate UUID keys with @Core.ComputedDefaultValue and complain
     // on named type UUID elements that have no such annotation
@@ -88,14 +101,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;
         }
@@ -105,6 +127,36 @@ function inboundQualificationChecks( csn, options, messageFunctions,
           message('chained-array-of', path);
       }
     }
+
+    // we need to know if the first path step is the bindind param
+    // for the rejection of V2 paths where the BP is ignored
+    function markBindingParamPaths( action, loc ) {
+      const special$self = !csn?.definitions?.$self && '$self';
+      if (action.params) {
+        const params = Object.entries(action.params);
+        const firstParam = params[0][1];
+        const type = firstParam?.items?.type || firstParam?.type;
+        if (type === special$self) {
+          const bindingParamName = params[0][0];
+          const markBindingParam = {
+            ref: (parent, prop, xpr) => {
+              if ((xpr[0].id || xpr[0]) === bindingParamName)
+                parent.$bparam = true;
+            },
+          };
+          let exprAnnos = Object.keys(action).filter(pn => findAnnotationExpression(action, pn));
+          exprAnnos.forEach((pn) => {
+            transformExpression(action, pn, markBindingParam, loc);
+          });
+          forEachMemberRecursively(action, (member, _memberName, _prop, path, _parent) => {
+            exprAnnos = Object.keys(member).filter(pn => findAnnotationExpression(member, pn));
+            exprAnnos.forEach((pn) => {
+              transformExpression(member, pn, markBindingParam, path);
+            });
+          }, loc);
+        }
+      }
+    }
   }
 
   function checkNestedContextsAndServices() {