@sap/cds-compiler 4.8.0 → 4.9.0

package/lib/compiler/shared.js

@@ -19,6 +19,7 @@ const {
   isAssocToPrimaryKeys,
   artifactRefLocation,
 } = require('./utils');
+const { isBetaEnabled } = require('../base/model');
 
 const $inferred = Symbol.for( 'cds.$inferred' );
 const $location = Symbol.for( 'cds.$location' );
@@ -133,14 +134,14 @@ function fns( model ) {
       param: paramSemantics,
     },
     filter: {
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       notFound: undefinedTargetElement,
       param: paramSemantics,
     },
     'calc-filter': {
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       navigation: calcElemNavigation,
@@ -181,7 +182,7 @@ function fns( model ) {
       check: checkColumnRef,
       param: paramSemantics,
       nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarSelf,
+        lexical: justDollarAliases,
         dollar: true,
         dynamic: nestedElements,
         notFound: undefinedNestedElement,
@@ -197,7 +198,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     calc: {
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: calcElemNavigation,
@@ -213,7 +214,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     on: {     // unmanaged assoc: outside query, redirected or new assoc in column
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: assocOnNavigation,
@@ -222,7 +223,7 @@ function fns( model ) {
       check: checkAssocOn,
       param: paramUnsupported,
       nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarSelf,
+        lexical: justDollarAliases,
         dollar: true,
         dynamic: parentElements,
         navigation: assocOnNavigation,
@@ -276,7 +277,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     annotation: { // annotation assignments
-      lexical: justDollarSelf,  // TODO: forbid $projection
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: assocOnNavigation,
@@ -287,8 +288,8 @@ function fns( model ) {
         'ref-undefined-param': 'anno-undefined-param',
       },
       param: paramSemantics,
-      nestedColumn: () => ({       // in expand and inline - TODO
-        lexical: justDollarSelf,
+      nestedColumn: () => ({
+        lexical: justDollarAliases,
         dollar: true,
         dynamic: parentElements,
         navigation: assocOnNavigation,
@@ -298,14 +299,21 @@ function fns( model ) {
     },
     // TODO: introduce some kind of inheritance
     annoRewrite: { // annotation assignments
-      lexical: justDollarSelf,  // TODO: forbid $projection
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: assocOnNavigation,
       noDep: true,
       notFound: null,           // no error, just falsy links
       param: paramSemantics,
-      // nestedColumn:     // in expand and inline - TODO
+      nestedColumn: () => ({
+        lexical: justDollarAliases,
+        dollar: true,
+        dynamic: parentElements,
+        navigation: assocOnNavigation,
+        notFound: undefinedParentElement,
+        rewriteProjectionToSelf: true,
+      }),
     },
   };
 
@@ -313,9 +321,11 @@ function fns( model ) {
     traverseExpr,
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked, // TODO: move to some other file
+    resolvePathRoot,
     resolvePath,
     checkExpr,
     checkOnCondition,
+    navigationEnv,
     nestedElements,
     attachAndEmitValidNames,
   } );
@@ -354,7 +364,6 @@ function fns( model ) {
     const { path } = ref;
     if (!path || path.broken) // incomplete type AST
       return undefined;
-
     const semantics = referenceSemantics[refCtx];
     if (!semantics.isMainRef)
       throw new CompilerAssertion( `resolveUncheckedPath() called for reference ctx '${ refCtx }'` );
@@ -628,6 +637,22 @@ function fns( model ) {
     return art;
   }
 
+  /**
+   * Resolve the _path-root_ only.  Used for rewriting annotation paths.
+   *
+   * @param ref
+   * @param {string} expected
+   * @param user
+   */
+  function resolvePathRoot( ref, expected, user ) {
+    if (ref == null || !ref.path) // no references -> nothing to do
+      return undefined;
+    const s = referenceSemantics[expected];
+    const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
+    const r = getPathRoot( ref, semantics, user );
+    return r && acceptPathRoot( r, ref, semantics, user );
+  }
+
   // Helper functions for resolve[Unchecked]Path, getPath{Root,Item}: -----------
 
   function acceptLexical( art, path, semantics, user ) {
@@ -687,9 +712,14 @@ function fns( model ) {
         // TODO: remove again, should be easy enough in to-csn without.
         if (path.length === 1 && art.kind === '$tableAlias')
           (user._user || user).$noOrigin = true;
+        if (head.id === '$projection' && user.kind === '$annotation') {
+          error( 'ref-unsupported-projection', [ head.location, user ],
+                 { code: '$projection', newcode: '$self' },
+                 '$(CODE) is not supported in annotations; replace by $(NEWCODE)' );
+        }
         return art;
       }
-      case '$parameters': {     // TODO: remove from CC
+      case '$parameters': {
         // TODO: if ref.scope='param' is handled, test that here, too ?
         const { id } = path[1];
         message( 'ref-obsolete-parameters', [ head.location, user ],
@@ -756,10 +786,10 @@ function fns( model ) {
   function userBlock( user ) {
     return definedViaCdl( user ) && user._block;
   }
-  function justDollarSelf( user ) {
+  function justDollarAliases( user ) {
     const query = userQuery( user );
     if (!query)
-      return user._main || user;
+      return user._main || user; // TODO: also contains `up_` for aspects; remove
     // query.$tableAliases contains both aliases and $self/$projection
     const aliases = query.$tableAliases;
     const r = Object.create( null );
@@ -783,7 +813,7 @@ function fns( model ) {
       const aliases = userQuery( user ).$tableAliases;
       user.$extended = Object.keys( aliases )[0];
     }
-    return justDollarSelf( user );
+    return justDollarAliases( user );
   }
 
   // Functions called via semantics.dynamic: ------------------------------------
@@ -829,7 +859,13 @@ function fns( model ) {
     return query._combined;     // TODO: do we need query._parent._combined ?
   }
   function parentElements( user ) {
-    return environment( user._main && user.kind !== 'select' ? user._parent : user );
+    // Note: We could have `$self` in bound actions refer to its entity, but reject it now.
+    // If users request it, we can either allow it later or point them to binding parameters.
+    const useParent = user._main &&
+      user.kind !== 'select' &&
+      user.kind !== 'action' &&
+      user.kind !== 'function';
+    return environment( useParent ? user._parent : user );
   }
 
   function queryElements( user ) {
@@ -1144,7 +1180,7 @@ function fns( model ) {
         // corresponding column expression; this might have references to elements
         // of invisible table aliases; at least one stakeholder uses this,
         // so it can't be an error (yet).
-        warning( 'ref-deprecated-self-element', [ ref.path[0].location, user._user ], {},
+        message( 'ref-deprecated-self-element', [ ref.path[0].location, user._user ], {},
                  // eslint-disable-next-line max-len
                  'Referring to the query\'s own elements here might lead to invalid SQL references; use source elements only' );
         return false;
@@ -1199,8 +1235,12 @@ function fns( model ) {
   }
 
   function acceptRealArtifact( art, user, ref ) {
-    // For compatibility, we accept `extend Unknown` without elements/actions/includes
-    if (art.kind !== 'namespace' || !(user.elements || user.actions || user.includes))
+    if (art.kind !== 'namespace')
+      return art;
+    // For compatibility (≤v4), we accept `extend Unknown` without elements/actions/includes
+    // In v5, only allow `extend with definitions`.
+    if (!isBetaEnabled( model.options, 'v5preview' ) &&
+      !(user.elements || user.actions || user.includes))
       return art;
     const { location } = ref.path[ref.path.length - 1];
     signalNotFound( 'ref-undefined-def', [ location, user ], null, { art } );

package/lib/compiler/tweak-assocs.js

@@ -4,7 +4,6 @@
 
 const {
   forEachGeneric,
-  forEachMember,
   forEachInOrder,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
@@ -33,7 +32,6 @@ function tweakAssocs( model ) {
     info, warning, error,
   } = model.$messageFunctions;
   const {
-    resolvePath,
     traverseExpr,
     checkExpr,
     checkOnCondition,
@@ -78,8 +76,6 @@ function tweakAssocs( model ) {
     traverseQueryPost( art.query, false, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociationCheck );
     } );
-
-    checkForAnnotationRefs( art );
   }
 
   // function rewriteView( view ) {
@@ -124,90 +120,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,6 +436,18 @@ function tweakAssocs( model ) {
       $inferred: 'copy',
     };
 
+    // 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 );
+
     elem.$filtered = {
       val: true,
       literal: 'boolean',
@@ -820,6 +744,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