@sap/cds-compiler 4.4.4 → 4.5.0

package/lib/compiler/tweak-assocs.js

@@ -4,6 +4,7 @@
 
 const {
   forEachGeneric,
+  forEachMember,
   forEachInOrder,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
@@ -32,6 +33,7 @@ function tweakAssocs( model ) {
     info, warning, error,
   } = model.$messageFunctions;
   const {
+    resolvePath,
     traverseExpr,
     checkExpr,
     checkOnCondition,
@@ -62,8 +64,6 @@ function tweakAssocs( model ) {
   function rewriteArtifact( art ) {
     // return;
     if (!art.query) {
-      // console.log(message( null, art.location, art, {target:art._target},
-      //   'Info','RAS').toString())
       rewriteAssociation( art );
       forEachGeneric( art, 'elements', rewriteAssociation );
     }
@@ -78,6 +78,8 @@ function tweakAssocs( model ) {
     traverseQueryPost( art.query, false, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociationCheck );
     } );
+
+    checkForAnnotationRefs( art );
   }
 
   // function rewriteView( view ) {
@@ -122,6 +124,79 @@ function tweakAssocs( model ) {
     }
   }
 
+  function checkForAnnotationRefs( art ) {
+    // TODO: no check for type inheritance yet
+    const origin = art._origin ||
+          art.includes && art.includes[art.includes.length - 1]._artifact;
+    // Make sure not to waste time if no inherited annotation has checked refs:
+    if (!origin?.$contains?.$annotation)
+      return;
+    for (const prop in origin) {
+      const anno = prop.charAt(0) === '@' && !art[prop] && origin[prop];
+      // Remark: to be on the academic safe side, we should consider the
+      // annotations which are not propagated, but they never have references as
+      // value.  So “no” for the moment.  We also do not perform these checks in
+      // propagator.js, as it should go away in compiler v6.
+      if (anno.kind) {          // i.e. with values refs
+        art[prop] = { ...anno, $inferred: 'prop' };
+        setLink( art[prop], '_outer', art );
+        const errorRef = checkAnnotationForRefs( art[prop], art );
+        if (errorRef) {
+          const valid = errorRef.path[errorRef.path.length - 1]._artifact;
+          error( 'anno-missing-rewrite', [ weakLocation( art.location ), art ], {
+            '#': (valid ? 'unrelated' : 'std'),
+            anno: prop,
+            art: origin,
+            elemref: errorRef,
+          } );
+        }
+        art.$contains ??= {};
+        art.$contains.$annotation = true;
+      }
+    }
+    forEachMember( art, checkForAnnotationRefs );
+  }
+
+  function checkAnnotationForRefs( expr, user ) {
+    if (expr.$tokenTexts)
+      return traverseExpr( expr, 'annoRewrite', user, checkAnnotationRef );
+    if (expr.literal === 'array')
+      return expr.val.find( val => checkAnnotationForRefs( val, user ) );
+    if (expr.literal !== 'struct')
+      return null;
+    const struct = Object.values( expr.struct );
+    return struct.find( val => checkAnnotationForRefs( val, user ) );
+  }
+
+  function checkAnnotationRef( ref, refCtx, user ) {
+    const origPath = ref.path;
+    if (!origPath[origPath.length - 1]._artifact) // already wrong in original
+      return null;
+    ref = { ...ref, path: [ ...origPath.map( item => ({ ...item }) ) ] };
+    if (!resolvePath( ref, refCtx, user ))
+      return ref;
+    return ref.path.some( isUnrelated ) && ref;
+
+    function isUnrelated( item, idx ) {
+      let elem = item._artifact;
+      const orig = origPath[idx]._artifact;
+      // With includes, we allow shadowing: an included element might seem to be
+      // unrelated.
+      if (elem._main?.includes && elem._main === (user._main || user))
+        return false;
+      if (!elem._effectiveType) // safety
+        return false;
+      // With redirections, the originally referred object might not be the same
+      // or even the direct _origin
+      do {
+        if (elem === orig)
+          return false;
+        elem = elem._origin;
+      } while (elem);
+      return true;
+    }
+  }
+
   function rewriteAssociationCheck( element ) {
     const elem = element.items || element; // TODO v5: nested items
     if (elem.elements)
@@ -287,7 +362,7 @@ function tweakAssocs( model ) {
           elem[prop] = { $inferred: 'NULL', val: undefined, location };
           break;
         }
-        origin = origin._origin;
+        origin = getOrigin( origin );
       }
     }
   }
@@ -340,9 +415,9 @@ function tweakAssocs( model ) {
     setExpandStatus( elem, 'target' );
     if (elem._parent?.kind === 'element') {
       // managed association as sub element not supported yet
-      error( null, [ elem.location, elem ], {},
-        // eslint-disable-next-line max-len
-             'Rewriting the ON-condition of unmanaged association in sub element is not supported' );
+      // TODO: Only report once for multi-include chains, see
+      //       Associations/SubElements/UnmanagedInSubElement.err.cds
+      error( 'type-unsupported-rewrite', [ elem.location, elem ], { '#': 'sub-element' } );
       return;
     }
     const nav = (elem._main?.query && elem.value)
@@ -388,23 +463,28 @@ function tweakAssocs( model ) {
    * The added condition (filter) is already rewritten relative to `elem`.
    */
   function addConditionFromAssocPublishing( elem, assoc ) {
-    const publishAssoc = (elem._main?.query && elem.value?.path?.length > 0);
+    const publishAssoc = (elem._main?.query || elem.$syntax === 'calc') &&
+      elem.value?.path?.length > 0;
     if (!publishAssoc)
       return;
 
     const { location } = elem.name;
+    let isRestricted = false;
     const lastStep = elem.value.path[elem.value.path.length - 1];
+    if (!lastStep)
+      return;
 
-    if (lastStep?.cardinality) {
+    if (lastStep.cardinality) {
+      isRestricted = true;
       if (!elem.cardinality)
-        elem.cardinality = assoc.cardinality || { location };
+        elem.cardinality = { ...assoc.cardinality } || { location };
       for (const card of [ 'sourceMin', 'targetMin', 'targetMax' ]) {
         if (lastStep.cardinality[card])
           elem.cardinality[card] = copyExpr( lastStep.cardinality[card], location );
       }
     }
 
-    if (lastStep?.where) {
+    if (lastStep.where) {
       // If there are foreign keys, transform them into an ON-condition first.
       if (assoc.foreignKeys) {
         const cond = foreignKeysToOnCondition( elem );
@@ -415,6 +495,7 @@ function tweakAssocs( model ) {
       }
 
       if (elem.on) {
+        isRestricted = true;
         elem.on = {
           op: { val: 'and', location },
           args: [
@@ -426,6 +507,14 @@ function tweakAssocs( model ) {
           $inferred: 'copy',
         };
       }
+      if (isRestricted) {
+        elem.$filtered = {
+          val: true,
+          literal: 'boolean',
+          location,
+          $inferred: '$generated',
+        };
+      }
     }
   }
 
@@ -468,11 +557,13 @@ function tweakAssocs( model ) {
 
   // Caller must ensure ON-condition correctness via rewriteExpr()!
   function foreignKeysToOnCondition( elem ) {
-    const nav = pathNavigation( elem.value );
-    if (!nav.tableAlias && model.options.testMode && !elem._pathHead)
-      throw new CompilerAssertion('rewriting keys to ON-condition: no tableAlias but not inline');
+    const nav = elem.$syntax === 'calc'
+      ? calcPathNavigation( elem.value )
+      : pathNavigation( elem.value );
+    if (model.options.testMode && !nav.tableAlias && !elem._pathHead && elem.$syntax !== 'calc')
+      throw new CompilerAssertion('rewriting keys to cond: no tableAlias but not inline/calc');
 
-    if (!nav.tableAlias || elem._parent?.kind === 'element' ||
+    if ((!nav.tableAlias && elem.$syntax !== 'calc') || elem._parent?.kind === 'element' ||
        (nav && nav.item !== elem.value.path[elem.value.path.length - 1])) {
       // - no nav.tableAlias for mixins or inside inline; mixins can't have managed assocs, though.
       // - _parent is element for expand
@@ -501,21 +592,27 @@ function tweakAssocs( model ) {
       if (elem.name.id.charAt(0) === '$')
         prependSelfToPath( lhs.path, elem );
 
+      const elemOrigin = getOrigin( elem );
       const rhs = {
         path: [
           // use origin's name; elem could have alias
-          { id: elem._origin.name.id, location: elem._origin.name.location },
+          { id: elemOrigin.name.id, location: elemOrigin.name.location },
           ...copyExpr( fKey.targetElement.path ),
         ],
         location: elem.name.location,
       };
-      setLink( rhs.path[0], '_artifact', elem._origin ); // different to lhs!
+      setLink( rhs.path[0], '_artifact', elemOrigin ); // different to lhs!
       setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1] );
 
-      // Can't use rewriteExpr as that would use `assoc[…]` itself as well.
-      const projectedFk = firstProjectionForPath( rhs.path, nav.tableAlias, elem );
-      rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
-
+      if (elem.$syntax !== 'calc') {
+        // Can't use rewriteExpr as that would use `assoc[…]` itself as well.
+        const projectedFk = firstProjectionForPath( rhs.path, nav.tableAlias, elem );
+        rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
+      }
+      else {
+        // TODO: calc elements: Do we need to rewrite? Shouldn't all elements exist, since
+        //       the calc element is right next to all others?
+      }
       const fkCond = {
         op: { val: 'ixpr', location: elem.name.location },
         args: [
@@ -593,31 +690,39 @@ function tweakAssocs( model ) {
                      nav.item ? nav.item.location : expr.path[0].location );
       }
     }
-    else {                     // from ON cond of element in included structure
+    else { // from ON cond of element that was included (i.e. from included structure)
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
       if (root.builtin || root.kind !== '$self' && root.kind !== 'element')
         return;
       const item = expr.path[root.kind === '$self' ? 1 : 0];
       if (!item)
-        return;                                   // just $self
-      // corresponding elem in including structure
-      const elem = (assoc._main.items || assoc._main).elements[item.id];
+        return;     // just $self
+      // corresponding elem in including structure or…
+      let elem = (assoc._main.items || assoc._main).elements[item.id];
+      if (elem !== assoc && assoc.$syntax === 'calc') {
+        // … special case for calc elements where "elem" points to the referenced
+        // (possibly included) association. For _included_ calc elements of the form,
+        // `calc = assoc[…]` it holds: `elem === assoc`
+        // TODO: expr could be the transformed fkey->ON-condition, where this statement is not true
+        //      And for the reference to the _foreign key_, we must _not_ rewrite it.
+        const calcRoot = assoc.value.path[0]?._navigation;
+        if (assoc.value.path[calcRoot?.kind === '$self' ? 1 : 0]?._artifact === elem)
+          elem = assoc;
+      }
       if (!elem)
         return; // See #11755
-      if (!(Array.isArray( elem ) ||            // no msg for redefs
-            elem === item._artifact ||          // redirection for explicit def
+      if (!(elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {
         const art = assoc._origin;
-        warning( 'rewrite-shadowed', [ elem.name.location, elem ],
-                 { art: art && effectiveType( art ) },
-                 {
-                   // eslint-disable-next-line max-len
-                   std: 'This element is not originally referred to in the ON-condition of association $(ART)',
-                   // eslint-disable-next-line max-len
-                   element: 'This element is not originally referred to in the ON-condition of association $(MEMBER) of $(ART)',
-                 } );
+        // eslint-disable-next-line max-len
+        warning( 'rewrite-shadowed', [ elem.name.location, elem ], { art: art && effectiveType( art ) }, {
+          // eslint-disable-next-line max-len
+          std: 'This element is not originally referred to in the ON-condition of association $(ART)',
+          // eslint-disable-next-line max-len
+          element: 'This element is not originally referred to in the ON-condition of association $(MEMBER) of $(ART)',
+        } );
       }
-      rewritePath( expr, item, assoc, (Array.isArray( elem ) ? false : elem), null );
+      rewritePath( expr, item, assoc, elem, null );
     }
   }
 
@@ -719,12 +824,12 @@ function tweakAssocs( model ) {
       env = env.target._artifact?._effectiveType;
     elem = setArtifactLink( item, env?.elements?.[name] );
 
-    if (elem && !Array.isArray( elem ))
+    if (elem)
       return elem;
     // TODO: better (extra message), TODO: do it
     error( 'query-undefined-element', [ item.location, assoc ],
            { id: name || item.id, '#': 'redirected' } );
-    return (elem) ? false : null;
+    return null;
   }
 }
 
@@ -826,4 +931,20 @@ function pathNavigation( ref ) {
   return { navigation: root.elements[item.id], item, tableAlias: root };
 }
 
+// TODO: Maybe unify with pathNavigation?
+function calcPathNavigation( ref ) {
+  if (!ref._artifact)
+    return {};
+  let item = ref.path && ref.path[0];
+  const root = item && item._artifact;
+  if (!root)
+    return {};
+  if (root.kind === 'element')
+    return { navigation: root, item, tableAlias: root._parent };
+  item = ref.path[1];
+  if (root.kind === '$self')
+    return { item, tableAlias: root };
+  return { navigation: root.elements[item.id], item, tableAlias: root };
+}
+
 module.exports = tweakAssocs;

package/lib/compiler/utils.js

@@ -90,6 +90,7 @@ function setArtifactLink( obj, value ) {
 }
 
 function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
+  // TODO: should `key` propagation be part of this?
   location ||= weakLocation( origin.name.location ); // not ??=
   const elem = {
     name: { location, id: origin.name.id },
@@ -153,12 +154,19 @@ function setMemberParent( elem, name, parent, prop ) {
   setLink( elem, '_main', parent._main || parent );
 }
 
+function createAndLinkCalcDepElement( elem ) {
+  const r = { kind: '$calculation' }; // no name, like /items
+  elem.$calcDepElement = r;
+  setLink( r, '_outer', elem );
+}
+
 /**
  * Adds a dependency user -> art with the given location.
  *
  * @param {XSN.Artifact} user
  * @param {XSN.Artifact} art
  * @param {XSN.Location} location
+ * @param {XSN.Artifact} [semanticLoc]
  */
 function dependsOn( user, art, location, semanticLoc = undefined ) {
   while (user._outer && !user.kind)
@@ -683,6 +691,7 @@ module.exports = {
   dependsOn,
   dependsOnSilent,
   setMemberParent,
+  createAndLinkCalcDepElement,
   storeExtension,
   withAssociation,
   pathName,

package/lib/edm/annotations/edmJson.js

@@ -7,8 +7,9 @@ const {
   EdmTypeFacetNames,
   EdmPrimitiveTypeMap,
 } = require('../EdmPrimitiveTypeDefinitions.js');
-const { mapCdsToEdmType } = require('../edmUtils.js');
 const { isBuiltinType } = require('../../model/csnUtils');
+const { transformExpression } = require('../../transform/db/applyTransformations.js');
+const { xprInAnnoProperties } = require('../../compiler/builtins');
 
 /**
  * Translate a given token stream expression into an edmJson representation
@@ -77,7 +78,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Error transformer
-  const notADynExpr = (parent, op, xpr, parentparent, parentprop, txt) => {
+  const notADynExpr = (parent, op, xpr, csnPath, parentparent, parentprop, txt) => {
     error('odata-anno-xpr', location, {
       anno, op: txt ??= op, '#': 'notadynexpr',
     });
@@ -93,27 +94,27 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     //----------------------------------
     // operators not supported as dynamic expression
     '.': notADynExpr,
-    isNull: (p, o) => notADynExpr(p, o, null, null, null, 'is null'),
-    isNotNull: (p, o) => notADynExpr(p, o, null, null, null, 'is not null'),
+    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, 'UNION'),
+    SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
     like: notADynExpr,
     new: notADynExpr,
   };
 
   //----------------------------------
   // list is a $Collection => []
-  transform.list = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.list = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     parentparent[parentprop] = xpr.filter(a => a);
-    applyTransformations(parentparent, transform);
+    transformExpression(parentparent, transform);
   };
   // XPR
-  transform.xpr = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.xpr = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     // eliminate 'xpr' node by pulling up xpr node to its parent
     parentparent[parentprop] = xpr;
-    applyTransformations(parentparent, transform);
+    transformExpression(parentparent, transform);
   };
   //----------------------------------
   // CASE
@@ -144,12 +145,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       curIf.$If.push(caseExpr[i]);
     parent.$If = edmIf.$If;
     delete parent.case;
-    applyTransformations(parent, transform);
+    transformExpression(parent, transform);
   };
   transform.$If = noOp;
   //----------------------------------
   // Cast => $Cast
-  transform.cast = (parent, prop, castExpr, parentparent, parentprop) => {
+  transform.cast = (parent, prop, castExpr, csnPath, parentparent, parentprop) => {
     const csnType = castExpr[0];
     // try to resolve to final scalar base type and use that instead of derived type
     if (!isBuiltinType(csnType.type)) {
@@ -161,7 +162,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         });
       }
     }
-    const edmTypeName = mapCdsToEdmType(csnType, messageFunctions, options.isV2(), false, location);
+    const edmTypeName = edmUtils.mapCdsToEdmType(csnType, messageFunctions, options.isV2(), false, location);
     const typeFunc = { func: 'Type', args: [ { val: edmTypeName } ] };
     const castFunc = { func: '$Cast', args: [ typeFunc, castExpr[1] ] };
 
@@ -184,7 +185,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
 
     parentparent[parentprop] = castFunc;
-    applyTransformations(parentparent, transform);
+    transformExpression(parentparent, transform);
   };
   //----------------------------------
   const evalArgs = (argDef, args, propName) => {
@@ -220,7 +221,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ exact }, xpr, prop);
     parent[opStr] = xpr;
     delete parent[prop];
-    applyTransformations(parent, transform);
+    transformExpression(parent, transform);
   };
   //----------------------------------
   // LOGICAL
@@ -249,12 +250,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ min: 1 }, xpr[1].list, prop);
     parent.$In = [ xpr[0], ...xpr[1].list ];
     delete parent[prop];
-    applyTransformations(parent, transform);
+    transformExpression(parent, transform);
   };
   transform.$In = noOp;
-  transform.between = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.between = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     evalArgs({ exact: 2 }, xpr.slice(1), prop);
-    applyTransformations(xpr, transform);
+    transformExpression(xpr, transform);
     delete parent[prop];
     parentparent[parentprop]
     = {
@@ -264,22 +265,22 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         ],
       };
   };
-  transform['||'] = (parent, prop, xpr, parentparent, parentprop) => {
+  transform['||'] = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     evalArgs({ exact: 2 }, xpr, prop);
-    applyTransformations(xpr, transform);
+    transformExpression(xpr, transform);
     delete parent[prop];
     parentparent[parentprop].$Apply = [ { $Function: 'odata.concat' }, ...xpr ];
   };
   //----------------------------------
   // ARITHMETICAL AND UNARY
-  transform['+'] = (parent, prop, xpr, parentparent, parentprop) => {
+  transform['+'] = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     if (Array.isArray(xpr)) {
       op('$Add')(parent, prop, xpr);
     }
     else {
       delete parent[prop];
       parentparent[parentprop] = xpr;
-      applyTransformations(parentparent, transform);
+      transformExpression(parentparent, transform);
     }
   };
   transform.$Add = noOp;
@@ -295,13 +296,13 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   // $DivBy, $Mod are functions
   //----------------------------------
   // LITERALS
-  transform.val = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.val = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     if (xpr === null)
       parent.$Null = true;
     else
       parentparent[parentprop] = xpr;
   };
-  transform.ref = (parent, prop, xpr, parentparent, parentprop) => {
+  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',
@@ -311,7 +312,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Functions
-  transform.func = (parent, prop, xpr, parentparent, parentprop) => {
+  transform.func = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     const rewriteArgs = (argDefs, evalVal = true) => {
       Object.entries(argDefs).forEach(([ argName, argDef ]) => {
         const [ foundProps, newArgs ]
@@ -694,7 +695,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       // $Record ???
       $Collection: () => {
         standard(parentparent, parentprop);
-        applyTransformations(parentparent, transform);
+        transformExpression(parentparent, transform);
       },
       $Path: () => {
         oneArg(parent, xpr);
@@ -704,7 +705,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             anno, op: `${xpr}(…)`, meta: 'string', '#': 'wrongval_meta',
           });
         }
-        applyTransformations(parentparent, transform);
+        transformExpression(parentparent, transform);
       },
       $Null: () => {
         parent[xpr] = true;
@@ -724,7 +725,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         funcDef.forEach(f => f());
       else
         funcDef();
-      applyTransformations(parent, transform);
+      transformExpression(parent, transform);
     }
     else {
       const funcName = xpr.startsWith('odata.') ? xpr : `odata.${xpr}`;
@@ -740,7 +741,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
           parentparent[parentprop].$Apply = [ { $Function: funcName }, ...(parent.args || []) ];
           delete parentparent[parentprop].func;
           delete parentparent[parentprop].args;
-          applyTransformations(parentparent, transform);
+          transformExpression(parentparent, transform);
         }
       }
       else {
@@ -752,41 +753,14 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     delete parent[prop];
   };
 
-  return applyTransformations({ annoVal }, {
-    '=': (parent, prop, xpr, parentparent, parentprop) => {
-      delete parent['='];
-      parentparent[parentprop] = applyTransformations({ $edmJson: parseExpr( parent, { array: false }) }, transform);
+  return transformExpression({ annoVal }, {
+    '=': (parent, prop, xpr, csnPath, parentparent, parentprop) => {
+      if (parent?.['='] !== undefined && xprInAnnoProperties.some(xProp => parent[xProp] !== undefined)) {
+        delete parent['='];
+        parentparent[parentprop] = transformExpression({ $edmJson: parseExpr( parent, { array: false }) }, transform);
+      }
     },
   }).annoVal;
-
-  function applyTransformations( parent, customTransformers ) {
-    function standard( _parent, _prop, node ) {
-      if (!node || typeof node !== 'object' ||
-          !{}.propertyIsEnumerable.call( _parent, _prop ) ||
-          (typeof _prop === 'string' && _prop.startsWith('@')))
-        return;
-
-
-      if (Array.isArray(node)) {
-        node.forEach( (n, i) => standard( node, i, n ) );
-      }
-      else {
-        for (const name of Object.getOwnPropertyNames( node )) {
-          const ct = customTransformers[name];
-          if (ct) {
-            if (Array.isArray(ct))
-              ct.forEach(cti => cti(node, name, node[name], _parent, _prop));
-            else
-              ct(node, name, node[name], _parent, _prop);
-          }
-          standard(node, name, node[name]);
-        }
-      }
-    }
-    for (const name of Object.getOwnPropertyNames( parent ))
-      standard( parent, name, parent[name] );
-    return parent;
-  }
 }
 
 // Not everything that can occur in OData annotations can be expressed with

package/lib/edm/annotations/genericTranslation.js

@@ -302,7 +302,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       if (knownAnnos.length === 0)
         return;
     }
-    if (isBetaEnabled(options, 'annotationExpressions')) {
+    if (isBetaEnabled(options, 'odataAnnotationExpressions')) {
       knownAnnos.forEach((knownAnno) => {
         if (knownAnno.search(/\.\$edmJson\./g) < 0)
           carrier[knownAnno] = xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
@@ -841,8 +841,9 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       else {
         // regular record
         if (dTypeIsACollection) {
-          message('odata-anno-value', msg.location,
-                  { anno: msg.anno(), str: 'structured', '#': 'incompval' });
+          message('odata-anno-value', msg.location, {
+            anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'incompval',
+          });
         }
         oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, dTypeIsACollection, msg));
       }
@@ -1100,8 +1101,15 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       }
     }
 
-    if ( [ 'Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(resolvedType) )
-      resolvedType = resolvedType.split('.')[1];
+    if ( EdmPathTypeMap[resolvedType] ) {
+      if (resolvedType === 'Edm.AnyPropertyPath') {
+        resolvedType = 'PropertyPath';
+        typeName = resolvedType;
+      }
+      else {
+        resolvedType = resolvedType.split('.')[1];
+      }
+    }
 
     return {
       name: typeName,

package/lib/edm/annotations/preprocessAnnotations.js

@@ -40,11 +40,10 @@ function preprocessAnnotations( csn, serviceName, options ) {
     const keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
     if (keyNames.length === 0) {
       keyNames.push('MISSING');
-      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'nokey' },
-              'target $(NAME) has no key');
+      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'nokey' } );
     }
     else if (keyNames.length > 1) {
-      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'multkeys' });
+      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'multkeys' });
     }
 
     return keyNames[0];