@sap/cds-compiler 5.1.0 → 5.2.0

package/lib/compiler/tweak-assocs.js

@@ -73,7 +73,6 @@ function tweakAssocs( model ) {
   // Only top-level queries and sub queries in FROM
 
   function rewriteArtifact( art ) {
-    // return;
     if (!art.query) {
       rewriteAssociation( art );
     }
@@ -333,27 +332,62 @@ function tweakAssocs( model ) {
 
     // TODO: split this function: create foreign keys without `targetElement`
     // already in Phase 2: redirectImplicitly()
-    // console.log(message( null, elem.location, elem, {art:assoc,target:assoc.target},
-    //  'Info','FK').toString())
     elem.foreignKeys = Object.create(null); // set already here (also for zero foreign keys)
     forEachInOrder( assoc, 'foreignKeys', ( orig, name ) => {
       const location = weakRefLocation( elem.target );
       const fk = linkToOrigin( orig, name, elem, 'foreignKeys', location );
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
       setLink( fk, '_effectiveType', fk );
-      const te = copyExpr( orig.targetElement, location );
-      if (elem._redirected) {
-        const i = te.path[0];   // TODO: or also follow path like for ON?
-        const state = rewriteItem( elem, i, i.id, elem, true );
-        if (state && state !== true && te.path.length === 1)
-          setArtifactLink( te, state );
-      }
-      fk.targetElement = te;
+      fk.targetElement = copyExpr( orig.targetElement, location );
+      if (elem._redirected)
+        rewriteKey( elem, fk.targetElement );
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
   }
 
+  function rewriteKey( elem, targetElement ) {
+    let projectedKey = null;
+    // rewrite along redirection chain
+    for (const alias of elem._redirected) {
+      if (alias.kind !== '$tableAlias')
+        continue;
+
+      projectedKey = firstProjectionForPath( targetElement.path, 0, alias, null );
+      if (projectedKey.elem) {
+        const item = targetElement.path[projectedKey.index];
+        item.id = projectedKey.elem.name.id;
+        if (projectedKey.index > 0)
+          targetElement.path.splice(0, projectedKey.index);
+      }
+      else {
+        setArtifactLink( targetElement.path[0], null );
+        setArtifactLink( targetElement, null );
+
+        const culprit = !elem.target.$inferred && elem.target ||
+          elem.value?.path?.[elem.value.path.length - 1] ||
+          elem;
+        // TODO: probably better to collect the non-projected foreign keys
+        // and have one message for all
+        error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
+          '#': 'std',
+          id: targetElement.path.map(p => p.id).join('.'),
+          target: alias._main,
+          name: elem.name.id,
+        });
+        return null;
+      }
+    }
+
+    if (projectedKey?.elem) {
+      const item = targetElement.path[0];
+      setArtifactLink( item, projectedKey.elem );
+      setArtifactLink( targetElement, projectedKey.elem );
+      return projectedKey.elem;
+    }
+    return null;
+  }
+
   // TODO: there is no need to rewrite the on condition of non-leading queries,
   // i.e. we could just have on = {…}
   // TODO: re-check $self rewrite (with managed composition of aspects),
@@ -380,27 +414,35 @@ function tweakAssocs( model ) {
     elem.on.$inferred = 'copy';
 
     const { navigation } = nav;
-    if (!navigation) // TODO: what about $projection.assoc as myAssoc ?
+    if (!navigation) { // TODO: what about $projection.assoc as myAssoc ?
+      if (elem._columnParent)
+        error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
       return;                 // should not happen: $projection, $magic, or ref to const
-
-    // Currently, having an unmanaged association inside a struct is not
-    // supported by this function:
-    if (navigation !== assoc && navigation._origin !== assoc) { // TODO: re-check
-      // For "assoc1.assoc2" and "struct.elem1.assoc2"
-      if (elem._redirected !== null) // null = already reported
-        error( 'rewrite-not-supported', [ elem.target.location, elem ] );
     }
-    else if (!nav.tableAlias || nav.tableAlias.path) {
+    const isAssocInStruct = (navigation !== assoc && navigation._origin !== assoc);
+    if (isAssocInStruct) {
+      // For "[sub.]assoc1.assoc2": not supported, yet (#3977)
+      const multipleAssoc = elem.value.path.slice(0, -1).some(segment => segment._artifact?.target);
+      if (multipleAssoc && elem._redirected !== null) { // null = already reported
+        error('rewrite-not-supported', [ elem.target.location, elem ], { '#': 'secondary' });
+        return;
+      }
+    }
+
+    if (!nav.tableAlias || nav.tableAlias.path) {
+      const navEnv = followNavigationPath( elem.value?.path, nav ) || nav.tableAlias;
       traverseExpr( elem.on, 'rewrite-on', elem,
-                    expr => rewriteExpr( expr, elem, nav.tableAlias ) );
+                    expr => rewriteExpr( expr, elem, nav.tableAlias, navEnv ) );
     }
-    else if (elem._pathHead) {
-      error( 'rewrite-not-supported', [ elem.target.location, elem ] );
+    else if (elem._columnParent) {
+      error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
+      return;
     }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
+      return;
     }
 
     addConditionFromAssocPublishing( elem, assoc, nav );
@@ -528,7 +570,7 @@ function tweakAssocs( model ) {
 
   // Caller must ensure ON-condition correctness via rewriteExpr()!
   function foreignKeysToOnCondition( elem, assoc, nav ) {
-    if (model.options.testMode && !nav.tableAlias && !elem._pathHead && elem.$syntax !== 'calc')
+    if (model.options.testMode && !nav.tableAlias && !elem._columnParent && elem.$syntax !== 'calc')
       throw new CompilerAssertion('rewriting keys to cond: no tableAlias but not inline/calc');
 
     if ((!nav.tableAlias && elem.$syntax !== 'calc') || elem._parent?.kind === 'element' ||
@@ -571,8 +613,11 @@ function tweakAssocs( model ) {
       setLink( rhs.path[0], '_artifact', assoc );
       setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1]._artifact );
 
-      if (elem.$syntax !== 'calc') { // different to lhs!
-        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, elem );
+      if (elem.$syntax !== 'calc') {
+        // Not passing an element, as we don't want to use our own filtered association here!
+        // That's done for lhs.
+        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, null );
+        // different to lhs!
         rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
       }
 
@@ -607,7 +652,13 @@ function tweakAssocs( model ) {
     return cond;
   }
 
-  function rewriteExpr( expr, assoc, tableAlias ) {
+  /**
+   * @param expr
+   * @param assoc
+   * @param tableAlias
+   * @param navEnv Navigation element / table alias, used to traverse/rewrite the path.
+   */
+  function rewriteExpr( expr, assoc, tableAlias, navEnv = tableAlias ) {
     // Rewrite ON condition (resulting in outside perspective) for association
     // 'assoc' in query or including entity from ON cond of mixin element /
     // element in included structure / element in source ref/d by table alias.
@@ -620,7 +671,7 @@ function tweakAssocs( model ) {
       return;
     if (!assoc._main)
       return;
-    if (tableAlias) { // from ON cond of element in source ref/d by table alias
+    if (navEnv) { // from ON cond of element in source ref/d by table alias
       const source = tableAlias._origin;
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
       if (!root || root._main !== source)
@@ -628,7 +679,8 @@ function tweakAssocs( model ) {
       if (expr.scope === 'param' || root.kind === '$parameters')
         return;                 // are not allowed anyway - there was an error before
       const startIndex = (root.kind === '$self' ? 1 : 0);
-      const result = firstProjectionForPath( expr.path, startIndex, tableAlias, assoc );
+      const exprNavigation = (root.kind === '$self' ? tableAlias : navEnv);
+      const result = firstProjectionForPath( expr.path, startIndex, exprNavigation, assoc );
       // For `assoc[…]`, ensure that we don't rewrite to another projection on `assoc`.
       if (result.item && assoc._origin === result.item._artifact)
         result.elem = assoc;
@@ -647,8 +699,8 @@ function tweakAssocs( model ) {
         }
         return;
       }
-      const nav = pathNavigation( expr );
-      if (nav.navigation || nav.tableAlias) { // rewrite src elem, mixin, $self[.elem]
+      if (expr.path[0]._navigation) { // rewrite src elem, mixin, $self[.elem]
+        const nav = pathNavigation( expr );
         const elem = (assoc._origin === root) ? assoc : navProjection( nav.navigation, assoc );
         rewritePath( expr, nav.item, assoc, elem,
                      nav.item ? nav.item.location : expr.path[0].location );
@@ -691,8 +743,9 @@ function tweakAssocs( model ) {
     if (!elem) {
       if (location) {
         const elemref = root._navigation?.kind === '$self' ? path.slice(1) : path;
+        // TODO: Fix message for sub-elements: `s: { a: Association on x=1, x: Integer};` for x
         error( 'rewrite-not-projected', [ location, assoc ], {
-          name: assoc.name.id, art: item._artifact, elemref: { ref: elemref },
+          name: assoc.name.id, art: elemref[0]._artifact, elemref: { ref: elemref },
         }, {
           std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
           element: 'Projected association $(NAME) uses non-projected element $(ELEMREF) of $(ART)',
@@ -729,14 +782,11 @@ function tweakAssocs( model ) {
         if (i === item)
           state = setArtifactLink( i, elem );
       }
-      else if (i) {
-        state = rewriteItem( state, i, i.id, assoc, false );
+      else {
+        state = rewriteItem( state, i, assoc );
         if (!state || state === true)
           break;
       }
-      else {
-        return;
-      }
     }
     if (state !== true)
       setArtifactLink( ref, state );
@@ -749,9 +799,15 @@ function tweakAssocs( model ) {
     path.unshift( root );
   }
 
-  function rewriteItem( elem, item, name, assoc, forKeys ) {
+  /**
+   * @param elem "Navigation environment" (element) for `item`.
+   * @param item Path segment to rewrite.
+   * @param assoc Published association of query.
+   */
+  function rewriteItem( elem, item, assoc ) {
     if (!elem._redirected)
       return true;
+    let name = item.id;
     for (const alias of elem._redirected) {
       // TODO: a message for the same situation as msg 'rewrite-shadowed'?
       if (alias.kind === '$tableAlias') { // _redirected also contains structures for includes
@@ -760,21 +816,8 @@ function tweakAssocs( model ) {
         // but its origins, too.
         const proj = navProjection( alias.elements[name], assoc );
         name = proj?.name?.id;
-        if (!name) {
-          if (!forKeys)
-            break;
-          setArtifactLink( item, null );
-          const culprit = elem.target && !elem.target.$inferred && elem.target ||
-                          elem.value?.path?.[elem.value.path.length - 1] ||
-                          elem;
-          // TODO: probably better to collect the non-projected foreign keys
-          // and have one message for all
-          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), assoc ], {
-            '#': 'std', id: item.id, target: alias._main, name: assoc.name.id,
-          });
-          // ''
-          return null;
-        }
+        if (!name)
+          break;
         item.id = name;
         // TODO: Why not break here? Test test3/scenarios/AFC/db/view/consumption/C_ScopedRole.cds
       }
@@ -802,14 +845,20 @@ function tweakAssocs( model ) {
 
 function navProjection( navigation, preferred ) {
   // TODO: Info if more than one possibility?
-  // console.log(navigation,navigation._projections)
   if (!navigation)
     return {};
-  else if (!navigation._projections)
+
+  if (!navigation._projections && !navigation._complexProjections)
     return null;
-  return (preferred && navigation._projections.includes( preferred ))
-    ? preferred
-    : navigation._projections[0] || null;
+
+  // _complexProjections contains projections that are not "simple",
+  // i.e. contain a filter or arguments. Only used if it contains our
+  // preferred association.
+  if (preferred && ( navigation._complexProjections?.includes( preferred ) ||
+    navigation._projections?.includes( preferred )))
+    return preferred;
+
+  return navigation._projections?.[0] || null;
 }
 
 
@@ -824,6 +873,9 @@ function navProjection( navigation, preferred ) {
  * The returned object `ret` has `ret.item`, which is the path item at index `ret.index`
  * that is projected. `ret.elem` is the element projection.
  *
+ * If nothing was found, `ret.elem` is null, and `ret.item` is the last segment for which
+ * there was a $navElement.
+ *
  * @param {any[]} path
  * @param {number} startIndex
  * @param {object} nav
@@ -844,30 +896,69 @@ function firstProjectionForPath( path, startIndex, nav, elem ) {
 
   let proj = null;
   let navItem = nav;
-  for (let i = startIndex; i < path.length; ++i) {
-    const item = path[i];
+  let navIndex = startIndex;
+  for (; navIndex < path.length; ++navIndex) {
+    const item = path[navIndex];
     navItem = item?.id && navItem.elements?.[item.id];
     if (!navItem) {
       break;
     }
-    else if (navItem._projections) {
+    else if (navItem._projections || navItem._complexProjections) {
       const projElem = navProjection( navItem, elem );
       if (projElem && projElem === elem) {
         // in case the specified association is found, _always_ use it.
-        return { index: i, item, elem };
+        return { index: navIndex, item, elem };
       }
       else if (projElem) {
         const queryIndex = selectedElements.indexOf(projElem);
         if (!proj || queryIndex < proj.queryIndex) {
           proj = {
-            index: i, item, elem: projElem, queryIndex,
+            index: navIndex, item, elem: projElem, queryIndex,
           };
         }
       }
     }
   }
+  if (proj)
+    return proj;
+
+  const index = (navIndex - 1) <= startIndex ? startIndex : (navIndex - 1);
+  return { index, item: path[index], elem: null };
+}
+
+/**
+ * Follow the navigation along the given path to its N-1 path step, so
+ * that the last step can be resolved against the returned navigation like
+ * `returnValue.elements[last.id]`.
+ *
+ * @param {XSN.Path} path
+ * @param {object} nav
+ * @returns {object|null}
+ */
+function followNavigationPath( path, nav ) {
+  if (!nav.item || !path || path.length === 1)
+    return nav.tableAlias;
+
+  const startIndex = path.indexOf(nav.item);
+  if (startIndex === -1)
+    return null;
+
+  // navigation is already at last path step
+  if (startIndex === path.length - 1) {
+    return nav.navigation?.kind === '$navElement'
+      ? nav.navigation._parent
+      : nav.tableAlias;
+  }
+
+  let navItem = nav.navigation || nav.tableAlias;
+  for (let i = startIndex + 1; i < path.length - 1; ++i) {
+    const item = path[i];
+    navItem = item?.id && navItem.elements?.[item.id];
+    if (!navItem)
+      return null;
+  }
 
-  return proj || { index: startIndex, item: path[startIndex], elem: null };
+  return navItem;
 }
 
 /**

package/lib/compiler/utils.js

@@ -607,7 +607,7 @@ function pathStartsWithSelf( ref ) {
 }
 
 function columnRefStartsWithSelf( col ) {
-  for (; col; col = col._pathHead) {
+  for (; col; col = col._columnParent) {
     const ref = col.value;
     const head = ref && !ref.scope && ref.path?.[0];
     if (head?._navigation?.kind === '$self')

package/lib/compiler/xpr-rewrite.js

@@ -355,7 +355,7 @@ function xprRewriteFns( model ) {
     // On select items, use navigation elements or table alias
     // TODO: Expand/inline paths don't have a `_navigation` property on their last
     //       path step, yet.  We need to implement expand/inline.
-    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._pathHead;
+    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._columnParent;
     if (isSimpleSelectItem) {
       const isSelfPath = (expr.path[0]?._navigation?.kind === '$self');
       if (isSelfPath) {
@@ -665,8 +665,9 @@ function xprRewriteFns( model ) {
     }
 
     const item = expr.path[index];
-    // Not a query -> no $navElement -> use `elements`
-    if (!env.query && env.kind !== 'select') {
+    // If the artifact is already in the same definition, we must not check the query.
+    // Or if it is not a query -> no $navElement -> use `elements`
+    if (item._artifact._main === env || !env.query && env.kind !== 'select') {
       if (env.elements?.[item.id])
         return [ env.elements[item.id], index ];
       return [ null, expr.path.length ];

package/lib/edm/annotations/genericTranslation.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isEdmPropertyRendered, transformExpression } = require('../../model/csnUtils');
+const { isEdmPropertyRendered, transformAnnotationExpression } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
@@ -131,7 +131,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           const knownAnnos = filterKnownAnnotations(carrier);
           knownAnnos.forEach((pn) => {
             scopeCheck.anno = pn;
-            transformExpression(carrier, pn, scopeCheck, carrier.$path);
+            transformAnnotationExpression(carrier, pn, scopeCheck, carrier.$path);
           });
         });
       }
@@ -141,7 +141,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       const knownAnnos = filterKnownAnnotations(obj);
       knownAnnos.forEach((pn) => {
         scopeCheck.anno = pn;
-        transformExpression(obj, pn, scopeCheck, obj.$path);
+        transformAnnotationExpression(obj, pn, scopeCheck, obj.$path);
       });
     };
     if (def.$isParamEntity && def._origin) {
@@ -171,7 +171,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
               if (innerAnnotation)
                 newAnno += `.@${innerAnnotation}`;
               edmUtils.assignAnnotation(def, newAnno, def._origin[attr]);
-              transformExpression(def._origin, attr, scopeCheck, def._origin.$path);
+              transformAnnotationExpression(def._origin, attr, scopeCheck, def._origin.$path);
               if (paramAnnoParts.length > 1)
                 delete def._origin[attr];
             }
@@ -419,7 +419,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     knownAnnos.forEach((knownAnno) => {
       if (knownAnno.search(/\.\$edmJson\./g) < 0) {
-        transformExpression(carrier, knownAnno, {
+        transformAnnotationExpression(carrier, knownAnno, {
           ref: (elemref, prop, xpr, csnPath) => {
             if (options.isV2() && elemref.$bparam) {
               error('odata-anno-xpr-ref', ctx.location, {
@@ -842,8 +842,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
      * */
     let newAnno;
     const omissions = { 'Aggregation.default': 1 };
-    const nullList = { 'Core.OperationAvailable': 1 };
-    if (annoValue !== null && !omissions[termName] || nullList[termName]) {
+    const nullList = { 'Core.OperationAvailable': 1, 'Core.OptionalParameter': 1 };
+    if (annoValue != null && !omissions[termName] || nullList[termName]) {
     // termName may contain a qualifier: @UI.FieldGroup#shippingStatus
     // -> remove qualifier from termName and set Qualifier attribute in newAnno
       const i = termName.indexOf('#');
@@ -989,6 +989,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     else {
       const res = handleSimpleValue(cAnnoValue, dTypeName, msg);
       if (((oTermName === 'Core.OperationAvailable' && dTypeName === 'Edm.Boolean') ||
+        (oTermName === 'Core.OptionalParameter' && dTypeName === 'Edm.String') ||
         (oTermName === 'Validation.AllowedValues' && dTypeName === 'Edm.PrimitiveType')) &&
         cAnnoValue === null) {
         oTarget.append(new Edm.ValueThing(v, 'Null'));
@@ -1230,7 +1231,10 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       }
     }
     else if (value === null) {
-      if ((resolvedType == null || resolvedType === 'Edm.PrimitiveType') && typeName === 'String') {
+      if ((resolvedType == null ||
+           resolvedType === 'Edm.PrimitiveType' ||
+           resolvedType === 'Edm.String') &&
+           typeName === 'String') {
         resolvedType = 'Edm.String';
       }
       else {
@@ -1589,7 +1593,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
   function filterKnownAnnotations( carrier ) {
     const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
-    const nullWhitelist = [ '@Core.OperationAvailable' ];
+    const nullWhitelist = [ '@Core.OperationAvailable', '@Core.OptionalParameter.DefaultValue' ];
     const knownAnnosP = annoNames.filter((n) => {
       const tns = whatsMyTermNamespace(n);
       return tns &&

package/lib/edm/csn2edm.js

@@ -266,8 +266,19 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         });
       }
     });
+    if (!options.odataNoCreator) {
+      // remove unqualified @Core.Links and #CAP
+      Object.keys(serviceCsn).forEach((key) => {
+        if (key === '@Core.Links' || key.startsWith('@Core.Links.') ||
+            key === '@Core.Links#CAP' || key.startsWith('@Core.Links#CAP.'))
+          delete serviceCsn[key];
+      });
+    }
+
     // Create annotations and distribute into Schemas, merge vocabulary cross refs into xServiceRefs
-    addAnnotations2XServiceRefs();
+    addAnnotationsAndXServiceRefs();
+    if (!options.odataNoCreator)
+      LeadSchema.prepend(waterMark());
 
     // Finally add cross service references into the EDM and extract the targetSchemaNames
     // for the type cross check
@@ -308,6 +319,18 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     return edm;
 
+    function waterMark() {
+      const rel = new Edm.PropertyValue(v, 'rel');
+      rel._xmlOnlyAttributes.String = 'author';
+      rel._jsonOnlyAttributes['Edm.String'] = 'author';
+      const href = new Edm.PropertyValue(v, 'href');
+      href._xmlOnlyAttributes.String = 'https://cap.cloud.sap';
+      href._jsonOnlyAttributes['Edm.String'] = 'https://cap.cloud.sap';
+      const watermark = new Edm.Annotation(v, 'Core.Links', new Edm.Collection(v, new Edm.Record(v, rel, href)));
+      // watermark._edmAttributes['Qualifier'] = 'CAP';
+      return watermark;
+    }
+
     // Sort definitions into their schema container
     function populateSchemas( schemas ) {
       forEach(reqDefs.definitions, ( fqName, art ) => {
@@ -1099,8 +1122,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
     }
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
-    function addAnnotations2XServiceRefs( ) {
+    function addAnnotationsAndXServiceRefs( ) {
       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

package/lib/edm/edm.js

@@ -111,8 +111,7 @@ function getEdm( options, messageFunctions ) {
         json.$Kind = this.kind;
 
       this.toJSONattributes(json);
-      this.toJSONchildren(json);
-      return json;
+      return this.toJSONchildren(json);
     }
 
     // virtual
@@ -131,6 +130,7 @@ function getEdm( options, messageFunctions ) {
       this._children.filter(c => c._edmAttributes.Name).forEach((c) => {
         json[c._edmAttributes.Name] = c.toJSON();
       });
+      return json;
     }
 
     // virtual
@@ -325,7 +325,12 @@ function getEdm( options, messageFunctions ) {
 
     toJSONchildren(json) {
       // 'edmx:DataServices' should not appear in JSON
-      super.toJSONchildren(json);
+      // Annotations first
+      this._children.filter(c => c._edmAttributes.Term).forEach((c) => {
+        json = { ...json, ...c.toJSON() };
+      });
+
+      json = super.toJSONchildren(json);
       if (this._annotations.length > 0) {
         this._annotations.filter(a => a._edmAttributes.Term).forEach((a) => {
           Object.entries(a.toJSON()).forEach(([ n, v ]) => {
@@ -445,8 +450,7 @@ function getEdm( options, messageFunctions ) {
         json.$Reference = referenceJson;
 
       this._service.toJSONattributes(json);
-      this._service.toJSONchildren(json);
-      return json;
+      return this._service.toJSONchildren(json);
     }
 
     // all(default), metadata, annotations
@@ -1154,8 +1158,7 @@ function getEdm( options, messageFunctions ) {
     toJSON() {
       const json = Object.create(null);
       this.toJSONattributes(json);
-      this.toJSONchildren(json);
-      return json;
+      return this.toJSONchildren(json);
     }
 
     getConstantExpressionValue() {
@@ -1226,6 +1229,7 @@ function getEdm( options, messageFunctions ) {
           json[n] = v;
         });
       });
+      return json;
     }
   }
 
@@ -1242,8 +1246,9 @@ function getEdm( options, messageFunctions ) {
   // since it was discovered, that in JSON the EnumMember type must be
   // transported this is no longer the case....
   class Annotation extends AnnotationBase {
-    constructor(version, termName) {
+    constructor(version, termName, ...children) {
       super(version, { Term: termName } );
+      this.append(...children);
     }
 
     toJSON() {
@@ -1263,6 +1268,11 @@ function getEdm( options, messageFunctions ) {
   }
 
   class Collection extends AnnotationBase {
+    constructor(version, ...children) {
+      super(version);
+      this.append(...children);
+    }
+
     toJSON() {
       // EDM JSON doesn't mention annotations on collections
       return this._children.map(a => a.toJSON());
@@ -1270,6 +1280,10 @@ function getEdm( options, messageFunctions ) {
   }
 
   class Record extends AnnotationBase {
+    constructor(version, ...children) {
+      super(version);
+      this.append(...children);
+    }
     toJSONattributes(json) {
       if (this._jsonOnlyAttributes.Type)
         json['@type'] = this._jsonOnlyAttributes.Type;
@@ -1300,6 +1314,7 @@ function getEdm( options, messageFunctions ) {
             error(null, `Pease debug me: Unhandled Record child: ${c.kind}`);
         }
       });
+      return json;
     }
   }
 

package/lib/edm/edmInboundChecks.js

@@ -3,7 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
   forEachDefinition, forEachMemberRecursively, getUtils,
-  transformExpression, findAnnotationExpression,
+  transformAnnotationExpression,
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { assignAnnotation } = require('./edmUtils.js');
@@ -144,14 +144,12 @@ function inboundQualificationChecks( csn, options, messageFunctions,
                 parent.$bparam = true;
             },
           };
-          let exprAnnos = Object.keys(action).filter(pn => findAnnotationExpression(action, pn));
-          exprAnnos.forEach((pn) => {
-            transformExpression(action, pn, markBindingParam, loc);
+          Object.keys(action).filter(pn => pn[0] === '@').forEach((pn) => {
+            transformAnnotationExpression(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);
+            Object.keys(member).filter(pn => pn[0] === '@').forEach((pn) => {
+              transformAnnotationExpression(member, pn, markBindingParam, path);
             });
           }, loc);
         }