@sap/cds-compiler 6.3.6 → 6.4.2

package/lib/compiler/propagator.js

@@ -12,6 +12,7 @@ const {
   forEachDefinition,
   forEachMember,
   forEachGeneric,
+  isBetaEnabled,
 } = require( '../base/model');
 const {
   setLink,
@@ -34,7 +35,11 @@ function propagate( model ) {
     virtual,
     notNull,
     targetElement: onlyViaParent, // in foreign keys
-    value: onlyViaParent,      // enum symbol value, calculated element
+    value: enumOrCalcValue,      // enum symbol value, calculated element
+    // `value` is also used for column expression
+    // TODO(!): think of having an extra XSN property for calculated elements,
+    // replacing `value:…`+`$syntax:'calc'` and `$calc:…
+    $calc: enumOrCalcValue,
     // masked: special = done in definer
     // key: special = done in resolver
     // actions: struct includes & primary source = in definer/resolver
@@ -59,7 +64,7 @@ function propagate( model ) {
     //   enum: expensive,
     //   params: expensive,          // actually only with parent action
     //   returns,
-    $enclosed: annotation,
+    $enclosed: annotation,      // TODO: hm
   };
   const ruleToFunction = {
     __proto__: null,
@@ -71,7 +76,7 @@ function propagate( model ) {
   for (const rule in propagationRules)
     props[rule] = ruleToFunction[propagationRules[rule]];
 
-  const { rewriteAnnotationsRefs } = xprRewriteFns( model );
+  const { rewriteAnnotationsRefs, rewriteRefsInExpression } = xprRewriteFns( model );
 
   const { message, throwWithError } = model.$messageFunctions;
 
@@ -165,7 +170,9 @@ function propagate( model ) {
     // console.log('PROPS:',ref(source),'->',ref(target),keys.join('+'))
     for (const prop of keys) {
       // TODO: warning with competing props from multi-includes, but not in propagator.js
-      if (target[prop] !== undefined || source[prop] === undefined)
+      if (target[prop] !== undefined &&
+          (prop !== 'value' || !source.$calcDepElement || !target._main?.query) ||
+          source[prop] === undefined)
         continue;
       const transformer = props[prop] || props[prop.charAt(0)];
       if (transformer)
@@ -282,6 +289,22 @@ function propagate( model ) {
     }
   }
 
+  function enumOrCalcValue( prop, destination, origin ) {
+    // Remark: with include, the calc expression has been copied early
+    if (prop === 'value' && !origin.$calcDepElement) {
+      onlyViaParent( prop, destination, origin ); // enum value
+    }
+    else if (destination.kind === 'element' &&
+             destination._main?.query && // query element
+             !destination.$calc && origin.$calc !== true &&
+             isBetaEnabled( model.options, '$calcForDraft' )) {
+      destination.$calc
+        = Object.assign( copyExpr( origin[prop] ), { $inferred: 'prop' } );
+      if (rewriteRefsInExpression( destination, origin, '$calc' ))
+        destination.$calc = true; // TODO: or { val: true }?
+    }
+  }
+
   function notWithExpand( prop, target, source ) {
     if (!target.expand || prop === 'type' && source.elements)
       always( prop, target, source );
@@ -296,13 +319,13 @@ function propagate( model ) {
   function annotation( prop, target, source ) {
     const anno = source[prop];
     if (anno.val !== null)
-      withKind( prop, target, source );
+      withKind( prop, target, source ); // TODO: unfold
   }
 
   function docComment( prop, target, source ) {
     if (model.options.propagateDocComments)
       annotation( prop, target, source );
-    else // TODO: Probably just "never"
+    else // TODO: or just "never"
       onlyViaParent( prop, target, source );
   }
 

package/lib/compiler/resolve.js

@@ -1583,12 +1583,19 @@ function resolve( model ) {
     // (for code completion)
     const last = expr.path[expr.path.length - 1];
     if (!last || !(last.args || last.where || last.cardinality) ||
-        expr.$expected === 'approved-exists' ||
         user.expand || user.inline ||
         expWithFilter.includes( expected ) ||     // `from`, …
         last._navigation?.kind === '$tableAlias') // error already reported
       return ref;
 
+    if (expr.$expected === 'approved-exists') {
+      if (last.where?.args?.length === 0) {
+        // at the moment, empty filter is not allowed on last path step
+        reportUnexpectedArgsAndFilter( last, expected, user, null, 'last-empty-filter' );
+      }
+      return ref;
+    }
+
     const type = effectiveType( last._artifact );
     const art = type && (type.kind === 'entity' ? type : type.target?._artifact);
     if (!art)
@@ -1596,7 +1603,8 @@ function resolve( model ) {
     if (last.args || last.where || last.cardinality) {
       const unexpectedFilter = (expected !== 'annotation' && expected !== 'column' &&
           expected !== 'calc' && 'std') ||
-        isQuasiVirtualAssociation( type ) && 'model-only';
+        isQuasiVirtualAssociation( type ) && 'model-only' ||
+        last.where?.args?.length === 0 && 'last-empty-filter';
       reportUnexpectedArgsAndFilter( last, expected, user, art, unexpectedFilter );
     }
     // TODO: we should have different message-ids for the "last" stuff: adding
@@ -1696,7 +1704,9 @@ function resolve( model ) {
       error( 'expr-unexpected-argument', loc, { '#': variant } );
     }
     if ((step.where || step.cardinality) && variant) {
-      const location = combinedLocation( step.where, step.cardinality );
+      const location = step.where?.location || step.cardinality?.location
+        ? combinedLocation( step.where, step.cardinality )
+        : step.location;
       // XSN TODO: filter$location including […]
       error( 'expr-unexpected-filter', [ location, user ], { '#': variant } );
     }

package/lib/compiler/shared.js

@@ -40,6 +40,7 @@ function fns( model ) {
   } = model.$messageFunctions;
   const Functions = model.$functions;
 
+  // Map `exprCtx` (is a param of traversal functions) to reference semantics
   const referenceSemantics = {
     // global: ------------------------------------------------------------------
     using: {                    // only used to produce error message
@@ -60,10 +61,10 @@ function fns( model ) {
       isMainRef: 'no-generated',
       lexical: userBlock,
       dynamic: modelDefinitions,
-      notFound: undefinedDefinition,
+      notFound: undefinedForExtend,
       accept: extendableArtifact,
     },
-    _extensions: {
+    _uncheckedExtension: {      // to be used only with resolveUncheckedPath()
       isMainRef: 'all',
       lexical: userBlock,
       dynamic: modelDefinitions,
@@ -76,12 +77,6 @@ function fns( model ) {
       notFound: undefinedDefinition,
       accept: acceptStructOrBare,
     },
-    _include: {                 // cyclic include: no accept
-      isMainRef: 'no-generated',
-      lexical: userBlock,
-      dynamic: modelBuiltinsOrDefinitions,
-      notFound: undefinedDefinition,
-    },
     target: {
       isMainRef: 'no-autoexposed',
       lexical: userBlock,
@@ -315,6 +310,7 @@ function fns( model ) {
         rewriteProjectionToSelf: true,
       }),
     },
+    //
   };
 
   Object.assign( model.$functions, {
@@ -853,7 +849,7 @@ function fns( model ) {
     const { isMainRef } = semantics;
     if (isMainRef) {
       artItemsCount = (typeof ref.scope === 'number' && ref.scope) ||
-                      (ref.scope ? 1 : path.length);
+        (ref.scope ? 1 : path.length);
     }
     let art = null;
     const elementsEnv = semantics.navigation || environment;
@@ -1287,26 +1283,36 @@ function fns( model ) {
 
   function undefinedForAnnotate( user, item, valid, _dict, prev, path ) {
     // in a CSN source, only one env was tested (valid.length 1):
-    const art = (!prev) ? item.id : searchName( prev, item.id, 'absolute' );
+    const name = (prev) ? `${ prev.name.id }.${ item.id }` : item.id;
     if (!user.elements && !user.actions && !user.enum && !user.params &&
-        couldBeDraftsEntity( item.id, valid, prev, path ))
-      return;
-    if (couldBeDraftAdminDataEntity( item ) )
+        endsWithSuffix( name, '.drafts', art => art?._service && art.kind === 'entity' ) ||
+        endsWithSuffix( name, '.DraftAdministrativeData',
+                        ( art, prefix ) => (art?.kind === 'service' || prefix === 'DRAFT') ) ||
+        name === 'DRAFT' && path?.length === 2 && path[1].id === 'DraftAdministrativeData' ||
+        name.startsWith( 'localized.' )) // TODO: only if suffix is defined
       return;
     signalNotFound( (valid.length > 1 ? 'ext-undefined-art' : 'ext-undefined-def'),
                     // TODO: ext-undefined-xyz
-                    [ item.location, user ], valid, { art } );
+                    [ item.location, user ], valid, { art: name } );
   }
 
-  function couldBeDraftsEntity( id, valid, prev, path ) {
-    const entity = prev
-      ? prev === path[path.length - 2]._artifact && prev // TODO: Should check for '.drafts'?
-      : path.length === 1 && id.endsWith( '.drafts' ) && model.definitions[id.slice( 0, -7 )];
-    return entity?.kind === 'entity' && !!entity._service;
+  function undefinedForExtend( user, item, valid, _dict, prev ) {
+    // in a CSN source, only one env was tested (valid.length 1):
+    const name = (prev) ? `${ prev.name.id }.${ item.id }` : item.id;
+    if (name.startsWith( 'localized.' )) {
+      error( 'ref-undefined-art', [ user.name.location || user.location, user ],
+             { '#': 'localized', keyword: 'annotate' } );
+    }
+    else {
+      undefinedDefinition( user, item, valid, _dict, prev );
+    }
   }
 
-  function couldBeDraftAdminDataEntity( item ) {
-    return item.id === 'DraftAdministrativeData' && !item._artifact;
+  function endsWithSuffix( name, suffix, cond ) {
+    if (!name.endsWith( suffix ))
+      return false;
+    const prefix = name.slice( 0, -suffix.length );
+    return cond( model.definitions[prefix], prefix, name );
   }
 
   function undefinedParam( user, head, valid, _dict, _art, _path, semantics ) {
@@ -1537,7 +1543,7 @@ function fns( model ) {
     }
     // TODO: combine $requireElementAccess/$autoElement to $bareRoot ?
     else if (!user.expand && !user.inline &&  // $self._artifact to main artifact
-        !(art._main && art.kind !== 'select') && ref.path[0]._navigation?.kind === '$self') {
+             !(art._main && art.kind !== 'select') && ref.path[0]._navigation?.kind === '$self') {
       // TODO: better ref-invalid-self
       const { location, id } = path[0];
       error( 'ref-unexpected-self', [ location, user ], { id } );
@@ -1655,7 +1661,7 @@ function fns( model ) {
       }
     }
     else if (source.kind !== 'entity' &&
-        !acceptEventProjectionSource( source, user )) {
+             !acceptEventProjectionSource( source, user )) {
       signalNotFound( 'ref-invalid-source', [ ref.location, user ], null,
                       { '#': user._main.kind } );
       return (source === art) ? art : false; // art to show cyclic issues
@@ -1937,8 +1943,8 @@ function fns( model ) {
     // has to be run after foreign-key rewrite
     const outer = user._columnParent?._origin;
     let assoc = outer?.foreignKeys &&
-                pathStartsWithSelf( { path } ) == null && // not $self or CDS var like $now
-                outer;
+      pathStartsWithSelf( { path } ) == null && // not $self or CDS var like $now
+      outer;
     for (let index = startIndex; index < path.length; ++index) {
       if (assoc?.target) {
         if (!assoc.foreignKeys) {

package/lib/compiler/tweak-assocs.js

@@ -5,6 +5,7 @@
 const {
   forEachGeneric,
   forEachInOrder,
+  isBetaEnabled,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
@@ -90,7 +91,7 @@ function tweakAssocs( model ) {
 
     if (art.query) {
       traverseQueryPost(art.query, false, (query) => {
-        forEachGeneric( query, 'elements', rewriteAssociationCheck );
+        forEachGeneric( query, 'elements', handleQueryElements );
       });
     }
   }
@@ -116,10 +117,10 @@ function tweakAssocs( model ) {
       return;
     const loc = [ elem.target.location, elem ];
     const main = elem._main || elem;
-    if (!elem.$inferred && !main.$inferred) {
+    if (!elem.$inferred && !main.$inferred && !model.options.$recompile) {
       info( 'assoc-target-not-in-service', loc,
             { target, '#': (elem._main.query ? 'select' : 'define') }, {
-              std: 'Target $(TARGET) of association is outside any service', // not used
+              std: 'Association target $(TARGET) is outside any service', // not used
               define: 'Target $(TARGET) of explicitly defined association is outside any service',
               select: 'Target $(TARGET) of explicitly selected association is outside any service',
             } );
@@ -135,6 +136,26 @@ function tweakAssocs( model ) {
     }
   }
 
+  function handleQueryElements( column ) {
+    rewriteAssociationCheck( column );
+    if (!isBetaEnabled( model.options, '$calcForDraft' ))
+      return;
+    const { value } = column;  // `value` = column expression
+    if (!value || !value.args && !value.suffix)
+      return;
+    // TODO: what about non-simple refs (assocs, even with filter/args)?
+
+    // with “real” expressions, set $calc according to these
+    // (with references, $calc might be inherited from the source element)
+    column.$calc = copyExpr( column.value, null ); // copy while keeping location
+
+    if (traverseExpr.STOP ===
+        traverseExpr( column.$calc, 'rewrite-on', column,
+                      ref => rewriteColumnPath( ref, column ) ))
+      column.$calc = true;
+  }
+
+  // Check explicit ON / keys with REDIRECTED TO
   function rewriteAssociationCheck( element ) {
     const elem = element.items || element; // TODO v6: nested items
     if (elem.elements)
@@ -732,6 +753,7 @@ function tweakAssocs( model ) {
       rewritePathForEnv( expr, navEnv, assoc );
     }
     else if (assoc._main.query) { // from ON cond of mixin element in query
+      // here also $calc
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
       if (expr.scope === 'param' || root?.kind === '$parameters') {
         if (assoc.$errorReported !== 'assoc-unexpected-scope') {
@@ -743,7 +765,8 @@ function tweakAssocs( model ) {
         }
         return;
       }
-      if (expr.path[0]._navigation) { // 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 );
         // TODO: Use rewritePathForEnv(); make it handle mixins
@@ -823,8 +846,11 @@ function tweakAssocs( model ) {
 
     for (let i = startIndex; i < ref.path.length; ++i) {
       if (i > startIndex && art.target) {
-        // if the current artifact is an association, we need to respect the redirection
-        // chain from original target to new one.
+        // TODO: Can we combine this with the code from xpr-rewrite.js
+        // If the current artifact is an association, we need to respect the redirection
+        // chain from original target to new one.  We need to use '_originalArtifact' due
+        // to secondary associations and their redirection chains. See comment in
+        // test3/Redirections/SecondaryAssocs/RedirectedPathRewriteOne.cds
         // FIXME: Won't work with associations in projected structures.
         const origTarget = ref.path[i - 1]?._originalArtifact?.target?._artifact;
         const chain = cachedRedirectionChain( art, origTarget );
@@ -914,6 +940,33 @@ function tweakAssocs( model ) {
     }
   }
 
+  /**
+   * Rewrite the reference `ref` with first elem/mixin ref item `item` for user
+   * `assoc` (the query element), `elem` is the first (or preferred) query element
+   * for item.
+   */
+  function rewriteColumnPath( ref, column ) {
+    if (!ref._artifact)
+      return null;
+    const root = ref.path?.[0];
+    const nav = pathNavigation( ref );
+    if (nav.navigation) {       // TabAlias.elem, elem, mixin
+      const elem = navProjection( nav.navigation, null );
+      // TODO?: Use rewritePathForEnv(); make it handle mixins?
+      if (rewritePath( ref, nav.item, column, elem, null ))
+        return traverseExpr.STOP;
+    }
+    else if (ref.scope === 'param' || root?.kind === '$parameters') {
+      return traverseExpr.STOP;
+    }
+    return null;
+  }
+
+  /**
+   * Rewrite the reference `ref` with first elem/mixin ref item `item` for user
+   * `assoc` (the query element), `elem` is the first (or preferred) query element
+   * for item.
+   */
   function rewritePath( ref, item, assoc, elem, location ) {
     const { path } = ref;
     const root = path[0];
@@ -928,9 +981,9 @@ function tweakAssocs( model ) {
       delete root._navigation;
       setArtifactLink( root, elem );
       setArtifactLink( ref, elem );
-      return;
+      return true;              // ERROR
     }
-    if (item !== root) {
+    if (item !== root) {        // TableAlias.item, $self.item
       // e.g. mixin ON-condition: Base.foo -> $self.foo or multi-path projection,
       // $projection -> $self
       root.id = '$self';
@@ -948,7 +1001,7 @@ function tweakAssocs( model ) {
       setLink( root, '_navigation', elem );
     }
     if (!elem.name)      // nothing to do for own $projection, $projection.elem
-      return;            // (except having it renamed to $self)
+      return false;      // (except having it renamed to $self)
     item.id = elem.name.id;
     let state = null;
     for (const i of path) {
@@ -964,6 +1017,7 @@ function tweakAssocs( model ) {
     }
     if (state !== true)
       setArtifactLink( ref, state );
+    return false;
   }
 
   function prependSelfToPath( path, elem ) {
@@ -1049,24 +1103,6 @@ function tweakAssocs( model ) {
   }
 }
 
-function navProjection( navigation, preferred ) {
-  // TODO: Info if more than one possibility?
-  if (!navigation)
-    return {};
-
-  if (!navigation._projections && !navigation._complexProjections)
-    return 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;
-}
-
 function findRewriteTarget( expr, index, env, user ) {
   if (env.kind === '$navElement' || env.kind === '$tableAlias') {
     const r = firstProjectionForPath( expr.path, index, env, user );
@@ -1216,7 +1252,7 @@ function followNavigationPath( path, nav ) {
  * - $projection.elem      -> also $self.item -> { item: path[1], tableAlias: $self }
  * - $self                 -> { item: undefined, tableAlias: $self }
  * - $parameters.P, :P     -> {}
- * - $now, current_date    -> {}
+ * - $now                  -> {}
  * - undef, redef          -> {}
  * With 'navigation': store that navigation._artifact is projected
  * With 'navigation': rewrite its ON condition
@@ -1245,4 +1281,26 @@ function pathNavigation( ref ) {
   return { navigation: root.elements[item.id], item, tableAlias: root };
 }
 
+/**
+ * Return the first (or preferred) query elements which projections the navigation
+ * element `navigation` (i.e. source element belonging to a specific table alias).
+ */
+function navProjection( navigation, preferred ) {
+  // TODO: Info if more than one possibility?
+  if (!navigation)
+    return {};
+
+  if (!navigation._projections && !navigation._complexProjections)
+    return 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;
+}
+
 module.exports = tweakAssocs;