@sap/cds-compiler 4.4.4 → 4.6.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 );
       }
     }
   }
@@ -303,6 +378,10 @@ function tweakAssocs( model ) {
   }
 
   function rewriteKeys( elem, assoc ) {
+    addConditionFromAssocPublishing( elem, assoc, null );
+    if (elem.on)
+      return; // foreign keys were transformed into ON-condition
+
     // 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},
@@ -324,8 +403,6 @@ function tweakAssocs( model ) {
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
-
-    addConditionFromAssocPublishing( elem, assoc );
   }
 
   // TODO: there is no need to rewrite the on condition of non-leading queries,
@@ -340,35 +417,32 @@ 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)
       ? pathNavigation( elem.value ) // redirected source elem or mixin
       : { navigation: assoc };       // redirected user-provided
-    const cond = copyExpr( assoc.on,
+    elem.on = copyExpr( assoc.on,
       // replace location in ON except if from mixin element
-                           nav.tableAlias && elem.name.location );
-    elem.on = cond;
-    addConditionFromAssocPublishing( elem, assoc );
-    // `cond` still points to the original condition; does not include possible assoc filter
+                        nav.tableAlias && elem.name.location );
     elem.on.$inferred = 'copy';
 
     const { navigation } = nav;
     if (!navigation) // TODO: what about $projection.assoc as myAssoc ?
       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 ] );
-      return;
     }
-    if (!nav.tableAlias || nav.tableAlias.path) {
-      traverseExpr( cond, 'rewrite-on', elem,
+    else if (!nav.tableAlias || nav.tableAlias.path) {
+      traverseExpr( elem.on, 'rewrite-on', elem,
                     expr => rewriteExpr( expr, elem, nav.tableAlias ) );
     }
     else {
@@ -376,6 +450,12 @@ function tweakAssocs( model ) {
       error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
     }
+
+    // filter was copied in original element already
+    // TODO: not correct for e.g. composition-of-inline-aspect (#12223)
+    if (elem.$inferred !== 'include')
+      addConditionFromAssocPublishing( elem, assoc, nav );
+
     elem.on.$inferred = 'rewrite';
   }
 
@@ -387,56 +467,67 @@ 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);
+  function addConditionFromAssocPublishing( elem, assoc, nav ) {
+    const publishAssoc = (elem._main?.query || elem.$syntax === 'calc') &&
+      elem.value?.path?.length > 0;
     if (!publishAssoc)
       return;
 
+    nav ??= (elem._main?.query && elem.value)
+      ? pathNavigation( elem.value ) // redirected source elem or mixin
+      : { navigation: assoc };       // redirected user-provided
+
     const { location } = elem.name;
     const lastStep = elem.value.path[elem.value.path.length - 1];
+    if (!lastStep || !lastStep.where)
+      return;
 
-    if (lastStep?.cardinality) {
-      if (!elem.cardinality)
-        elem.cardinality = assoc.cardinality || { location };
+    if (lastStep.cardinality) {
+      elem.cardinality ??= { ...assoc.cardinality };
+      elem.cardinality.location = location;
       for (const card of [ 'sourceMin', 'targetMin', 'targetMax' ]) {
         if (lastStep.cardinality[card])
           elem.cardinality[card] = copyExpr( lastStep.cardinality[card], location );
       }
     }
 
-    if (lastStep?.where) {
-      // If there are foreign keys, transform them into an ON-condition first.
-      if (assoc.foreignKeys) {
-        const cond = foreignKeysToOnCondition( elem );
-        if (cond) {
-          elem.on = cond;
-          elem.foreignKeys = undefined;
-        }
-      }
-
-      if (elem.on) {
-        elem.on = {
-          op: { val: 'and', location },
-          args: [
-            // TODO: Get rid of $parens
-            { ...elem.on, $parens: [ assoc.location ] },
-            filterToCondition( lastStep, elem ),
-          ],
-          location,
-          $inferred: 'copy',
-        };
+    // If there are foreign keys, transform them into an ON-condition first.
+    if (assoc.foreignKeys) {
+      const cond = foreignKeysToOnCondition( elem, assoc, nav );
+      if (cond) {
+        elem.on = cond;
+        elem.foreignKeys = undefined;
       }
     }
+
+    elem.on = {
+      op: { val: 'and', location },
+      args: [
+        // TODO: Get rid of $parens
+        { ...elem.on, $parens: [ assoc.location ] },
+        filterToCondition( lastStep, elem, nav ),
+      ],
+      location,
+      $inferred: 'copy',
+    };
+
+    elem.$filtered = {
+      val: true,
+      literal: 'boolean',
+      location,
+      $inferred: '$generated',
+    };
   }
 
   /**
-   * Transform a filter on `assoc` into an ON-condition.
-   * Paths inside the filter are rewritten relative to `elem`.
+   * Transform a filter on `assocPathStep` into an ON-condition.
+   * Paths inside the filter are rewritten relative to `assoc`, so they can be redirected
+   * using `rewriteExpr()` later on. `$self` paths remain unchanged.
    */
-  function filterToCondition( assoc, elem ) {
-    const cond = copyExpr( assoc.where );
+  function filterToCondition( assocPathStep, elem, nav ) {
+    const cond = copyExpr( assocPathStep.where );
     // TODO: Get rid of $parens
-    cond.$parens = [ assoc.location ];
+    cond.$parens = [ assocPathStep.location ];
     traverseExpr( cond, 'rewrite-filter', elem, (expr) => {
       if (!expr.path || expr.path.length === 0)
         return;
@@ -450,15 +541,17 @@ function tweakAssocs( model ) {
       }
       else if (!root.builtin && root.kind !== 'builtin') {
         expr.path.unshift({
-          id: elem.name.id,
+          id: assocPathStep.id,
           location: elem.name.location,
         });
-        setLink( expr.path[0], '_artifact', elem );
-        // _navigation link not necessary because this condition is not rewritten
-        // inside the same view (would otherwise be needed for mixins).
-
-        if (elem.name.id.charAt(0) === '$')
-          prependSelfToPath( expr.path, elem );
+        setLink( expr.path[0], '_artifact', assocPathStep._artifact );
+        if (assocPathStep._navigation?.kind === 'mixin') {
+          // _navigation link necessary because condition is rewritten
+          // inside the same view (needed for mixins).
+          setLink( expr.path[0], '_navigation', assocPathStep._navigation );
+        }
+        // up to here, filter is relative to original association
+        rewriteExpr( expr, elem, nav?.tableAlias );
       }
     } );
 
@@ -467,13 +560,12 @@ 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');
+  function foreignKeysToOnCondition( elem, assoc, nav ) {
+    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' ||
-       (nav && nav.item !== elem.value.path[elem.value.path.length - 1])) {
+    if ((!nav.tableAlias && elem.$syntax !== 'calc') || elem._parent?.kind === 'element' ||
+       (nav && nav.item && 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
       // - nav.item is different for multi-path steps e.g. `sub.assoc`, which is not supported, yet
@@ -483,38 +575,39 @@ function tweakAssocs( model ) {
     }
 
     let cond = [];
-    forEachInOrder( elem, 'foreignKeys', function keyToCond( fKey ) {
+    forEachInOrder( assoc, 'foreignKeys', function keyToCond( fKey ) {
       // Format:      lhs = rhs
       //         assoc.id = assoc_id
-      // lhs and rhs look the same, but have different ids and _artifact links.
-      // rhs is rewritten further down to ensure that the foreign key is projected.
+      // lhs and rhs look the same but are rewritten differently. We must ensure that
+      // the rhs is rewritten to a projected element (or it must remain the assoc's
+      // foreign key in case of calc elements).
       const lhs = {
         path: [
-          { id: elem.name.id, location: elem.name.location },
+          { id: assoc.name.id, location: elem.name.location },
           ...copyExpr( fKey.targetElement.path ),
         ],
         location: elem.name.location,
       };
-      setLink( lhs.path[0], '_artifact', elem ); // different to rhs!
-      setLink( lhs, '_artifact', lhs.path[lhs.path.length - 1] );
+      setLink( lhs.path[0], '_artifact', assoc );
+      setLink( lhs, '_artifact', lhs.path[lhs.path.length - 1]._artifact );
 
-      if (elem.name.id.charAt(0) === '$')
-        prependSelfToPath( lhs.path, elem );
+      rewritePath( lhs, lhs.path[0], assoc, elem, elem.value.location ); // different to rhs!
 
       const rhs = {
         path: [
           // use origin's name; elem could have alias
-          { id: elem._origin.name.id, location: elem._origin.name.location },
+          { id: assoc.name.id, location: elem.name.location },
           ...copyExpr( fKey.targetElement.path ),
         ],
         location: elem.name.location,
       };
-      setLink( rhs.path[0], '_artifact', elem._origin ); // different to lhs!
-      setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1] );
+      setLink( rhs.path[0], '_artifact', assoc );
+      setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1]._artifact );
 
-      // 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') { // different to lhs!
+        const projectedFk = firstProjectionForPath( rhs.path, nav.tableAlias, elem );
+        rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
+      }
 
       const fkCond = {
         op: { val: 'ixpr', location: elem.name.location },
@@ -593,31 +686,34 @@ 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 (assoc.$syntax === 'calc' && assoc._origin === elem) {
+        // … calc element where "elem" points to the referenced (possibly included)
+        // sibling element (association).
+        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 );
     }
   }
 
@@ -680,9 +776,9 @@ function tweakAssocs( model ) {
 
   function prependSelfToPath( path, elem ) {
     const root = { id: '$self', location: path[0].location };
-    path.unshift( root );
     setLink( root, '_navigation', elem._parent.$tableAliases.$self );
     setArtifactLink( root, elem._parent );
+    path.unshift( root );
   }
 
   function rewriteItem( elem, item, name, assoc, forKeys ) {
@@ -719,12 +815,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;
   }
 }
 

package/lib/compiler/utils.js

@@ -29,7 +29,8 @@ function pushLink( obj, prop, value ) {
 // for annotations:
 
 function annotationVal( anno ) {
-  return anno && (anno.val === undefined || anno.val); // XSN TODO: set val for anno short form
+  // XSN TODO: set val but no location for anno short form
+  return anno && (anno.val === undefined || anno.val);
 }
 function annotationIsFalse( anno ) {                   // falsy, but not null (unset)
   return anno && (anno.val === false || anno.val === 0 || anno.val === '');
@@ -90,6 +91,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 +155,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 +692,7 @@ module.exports = {
   dependsOn,
   dependsOnSilent,
   setMemberParent,
+  createAndLinkCalcDepElement,
   storeExtension,
   withAssociation,
   pathName,