@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/compiler/tweak-assocs.js

@@ -4,8 +4,8 @@
 
 const {
   forEachGeneric,
-  forEachMember,
   forEachInOrder,
+  isBetaEnabled,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
@@ -19,6 +19,7 @@ const {
   traverseQueryPost,
   traverseQueryExtra,
   setExpandStatus,
+  getUnderlyingBuiltinType,
 } = require('./utils');
 const { Location } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
@@ -33,7 +34,6 @@ function tweakAssocs( model ) {
     info, warning, error,
   } = model.$messageFunctions;
   const {
-    resolvePath,
     traverseExpr,
     checkExpr,
     checkOnCondition,
@@ -41,6 +41,12 @@ function tweakAssocs( model ) {
     getOrigin,
   } = model.$functions;
 
+  Object.assign(model.$functions, {
+    firstProjectionForPath,
+  });
+
+  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
+
   // Phase 5: rewrite associations
   model._entities.forEach( rewriteArtifact );
   // Think hard whether an on condition rewrite can lead to a new cyclic
@@ -78,8 +84,6 @@ function tweakAssocs( model ) {
     traverseQueryPost( art.query, false, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociationCheck );
     } );
-
-    checkForAnnotationRefs( art );
   }
 
   // function rewriteView( view ) {
@@ -124,90 +128,6 @@ 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') {
-      for (const val of expr.val) {
-        const found = checkAnnotationForRefs( val, user );
-        if (found)
-          return found;
-      }
-      return null;
-    }
-    if (expr.literal !== 'struct')
-      return null;
-    const struct = Object.values( expr.struct );
-    for (const val of struct) {
-      const found = checkAnnotationForRefs( val, user );
-      if (found)
-        return found;
-    }
-    return null;
-  }
-
-  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)
@@ -524,14 +444,39 @@ function tweakAssocs( model ) {
       $inferred: 'copy',
     };
 
-    elem.$filtered = {
-      val: true,
-      literal: 'boolean',
+    // Published paths with filters are always associations, never
+    // compositions, hence we need to change the type to avoid type propagation.
+    const assocType = { id: 'cds.Association', location };
+    setArtifactLink( assocType, model.definitions['cds.Association'] );
+    elem.type = {
+      path: [ assocType ],
+      scope: 'global',
       location,
       $inferred: '$generated',
     };
+    setArtifactLink( elem.type, assocType._artifact );
+
+    if (!isV5preview) { // TODO(v5): Remove, only use $enclosed
+      elem.$filtered = {
+        val: true,
+        literal: 'boolean',
+        location,
+        $inferred: '$generated',
+      };
+    }
+
+    const isComp = (getUnderlyingBuiltinType( assoc )?.name?.id === 'cds.Composition');
+    if (isComp) {
+      elem.$enclosed = {
+        val: true,
+        literal: 'boolean',
+        location,
+        $inferred: '$generated',
+      };
+    }
   }
 
+
   /**
    * Transform a filter on `assocPathStep` into an ON-condition.
    * Paths inside the filter are rewritten relative to `assoc`, so they can be redirected
@@ -617,7 +562,7 @@ function tweakAssocs( model ) {
       setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1]._artifact );
 
       if (elem.$syntax !== 'calc') { // different to lhs!
-        const projectedFk = firstProjectionForPath( rhs.path, nav.tableAlias, elem );
+        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, elem );
         rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
       }
 
@@ -672,7 +617,8 @@ function tweakAssocs( model ) {
         return;                 // not $self or source element
       if (expr.scope === 'param' || root.kind === '$parameters')
         return;                 // are not allowed anyway - there was an error before
-      const result = firstProjectionForPath( expr.path, tableAlias, assoc );
+      const startIndex = (root.kind === '$self' ? 1 : 0);
+      const result = firstProjectionForPath( expr.path, startIndex, tableAlias, 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;
@@ -820,6 +766,7 @@ function tweakAssocs( model ) {
           return null;
         }
         item.id = name;
+        // TODO: Why not break here? Test test3/scenarios/AFC/db/view/consumption/C_ScopedRole.cds
       }
     }
     let env = name && elem._effectiveType; //  should have been computed
@@ -857,51 +804,60 @@ function navProjection( navigation, preferred ) {
 
 
 /**
- * For a path `a.b.c.d`, return a projection for the first path item that is projected.
+ * For a path `a.b.c.d`, return a projection for the first path item that is projected,
+ * starting at `startIndex` in this path using the given navigation (table alias or
+ * navigation element).
  * For example, if a query has multiple projections such as `a.b, a, a.b.c`, the
  * _first_ possible projection will be used and the caller can rewrite `a.b.c.d` to `b.c.d`.
- * This avoids that `extend`s affect the ON-condition.
+ * This avoids `extend`s affect the ON-condition.
  *
- * The returned object `ret` has `ret.item`, which is the path item that is projected.
- * `ret.elem` is the element projection.
+ * 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.
  *
  * @param {any[]} path
- * @param {object} tableAlias
- * @param {object} assoc Preferred association that should be used if projected.
+ * @param {number} startIndex
+ * @param {object} nav
+ * @param {object} elem Preferred association/element that should be used if projected.
  * @return {{elem: object, item: object}|null}
  */
-function firstProjectionForPath( path, tableAlias, assoc ) {
-  const viaSelf = (path[0]._navigation || path[0]._artifact).kind === '$self';
-  const root = viaSelf ? 1 : 0;
-  if (root >= path.length) // e.g. just `$self` path item
+function firstProjectionForPath( path, startIndex, nav, elem ) {
+  if (startIndex >= path.length) // e.g. just `$self` path item
     return { item: undefined, elem: {} };
 
+  let tableAlias = nav;
+  while (tableAlias.kind === '$navElement')
+    tableAlias = tableAlias._parent;
+
   // We want to use the _first_ valid projection that is written by the user (if the preferred
-  // `assoc` is not directly projected).  To achieve that, look into the table alias' elements.
+  // `assoc` is not directly projected).  To achieve that, look into the query's elements.
   const selectedElements = Object.values(tableAlias._parent.elements);
-  const proj = [];
-  let navItem = tableAlias;
-  for (const item of path.slice(root)) {
+
+  let proj = null;
+  let navItem = nav;
+  for (let i = startIndex; i < path.length; ++i) {
+    const item = path[i];
     navItem = item?.id && navItem.elements?.[item.id];
     if (!navItem) {
       break;
     }
     else if (navItem._projections) {
-      const elem = navProjection( navItem, assoc );
-      if (elem && elem === assoc) {
+      const projElem = navProjection( navItem, elem );
+      if (projElem && projElem === elem) {
         // in case the specified association is found, _always_ use it.
-        return { item, elem };
+        return { index: i, item, elem };
       }
-      else if (elem) {
-        const index = selectedElements.indexOf(elem);
-        proj.push({ item, elem, index });
+      else if (projElem) {
+        const queryIndex = selectedElements.indexOf(projElem);
+        if (!proj || queryIndex < proj.queryIndex) {
+          proj = {
+            index: i, item, elem: projElem, queryIndex,
+          };
+        }
       }
     }
   }
 
-  return (proj.length === 0)
-    ? { item: path[root], elem: null }
-    : proj.reduce( (acc, curr) => (acc.index > curr.index ? curr : acc), proj[0] ); // first
+  return proj || { index: startIndex, item: path[startIndex], elem: null };
 }
 
 /**