@sap/cds-compiler 6.4.2 → 6.4.6

package/lib/compiler/xpr-rewrite.js

@@ -72,10 +72,10 @@
 //   the path up to the last path step in the type-of.
 // - an element definition, `$self.sub.elem` needs to be replaced by the element name.
 //   Paths without `$self` on the "type-of element" itself need to have
-//   the first path step be replaced by the target element name.
+//   the first path step be replaced by the destination element name.
 // - a parameter, `$self.sub.elem` needs to be replaced by the parameter name.
 //   Paths without `$self` on the "type-of element" itself need to have
-//   the first path step be replaced by the target parameter name.
+//   the first path step be replaced by the destination parameter name.
 // - a return parameter, `$self` needs to be rejected, because there is no way
 //   to refer to `returns`. Paths without `$self` on the "type-of element" itself
 //   (not sub-elements), need to be rejected as well.
@@ -108,7 +108,7 @@
 // was projected or if a prefix was projected (e.g. for structures or associations).
 // The same rules as for ON-condition rewriting apply.
 //
-// Furthermore, as the target is a select item, and this select item belongs to a table
+// Furthermore, as the destination is a select item, and this select item belongs to a table
 // alias, we should rewrite all annotation paths only to projected elements of that
 // table alias.  Cross-rewriting between table aliases should not be done.
 // This is the same we do for association rewriting.
@@ -157,14 +157,13 @@ const { isSimpleCdlIdentifier } = require('../parsers/identifiers');
 // Config object passed around all "rewrite" functions.
 class AnnoRewriteConfig {
   anno;
-  target;
-  targetRoot;
+  destination;
+  destinationRoot;
   origin;
-  fromTargetType;
+  fromDestinationType;
   fromCalcElement;
   expandedRoot;
   expandedRootType;
-  isInFilter;
   tokenExpr;
 }
 
@@ -185,45 +184,50 @@ function xprRewriteFns( model ) {
   };
 
   /**
+   * Report anno-missing-rewrite if rewrite for annotations.
+   * Returns traverseExpr.STOP.
+   *
    * @param expr
    * @param {AnnoRewriteConfig} config
    * @param {string} [variant]
    */
   function reportAnnoRewriteError( expr, config, variant = 'std' ) {
-    return !config.tokenExpr || // TODO: some info message ?
+    if (config.tokenExpr) {
       error( 'anno-missing-rewrite', [
-        weakLocation( config.target.location ), config.target,
+        weakLocation( config.destination.location ), config.destination,
       ], {
         '#': variant,
         anno: config.anno,
         art: config.origin,
         elemref: expr,
       });
+    }
+    return traverseExpr.STOP;
   }
 
   /**
-   * Rewrite the propagated annotation relative to the target.
+   * Rewrite the propagated annotation relative to the destination.
    *
-   * @param {XSN.Artifact} target
+   * @param {XSN.Artifact} destination
    * @param {XSN.Artifact} origin
    * @param {string} annoName
    */
-  function rewriteAnnotationsRefs( target, origin, annoName ) {
+  function rewriteAnnotationsRefs( destination, origin, annoName ) {
     // Make sure not to waste time if no inherited annotation has references:
     if (!origin?.$contains?.$annotation?.$path)
       return;
 
-    const anno = target[annoName];
+    const anno = destination[annoName];
     // only annotations with expressions have a kind
     // also, don't report errors twice
     if (!anno.kind || anno.$invalidPaths)
       return;
 
-    const hasError = rewriteRefsInExpression( target, origin, annoName );
-    target.$contains ??= {};
-    target.$contains.$annotation ??= {};
-    target.$contains.$annotation.$path ||= origin.$contains.$annotation.$path;
-    target.$contains.$annotation.$self ||= origin.$contains.$annotation.$self;
+    const hasError = rewriteRefsInExpression( destination, origin, annoName );
+    destination.$contains ??= {};
+    destination.$contains.$annotation ??= {};
+    destination.$contains.$annotation.$path ||= origin.$contains.$annotation.$path;
+    destination.$contains.$annotation.$self ||= origin.$contains.$annotation.$self;
     if (hasError)
       anno.$invalidPaths = true; // avoid subsequent errors
   }
@@ -231,23 +235,23 @@ function xprRewriteFns( model ) {
   function rewriteRefsInExpression( destination, origin, propName ) {
     // Annotation comes from the destination's type.  That's important to know, because
     // path prefixes need to be adapted.
-    const fromTargetType = destination.type?._artifact === origin;
+    const fromDestinationType = destination.type?._artifact === origin;
     // Annotation comes from the destination's calculated element.
     // A special case propagation rule, e.g
     // for `calcString: String = str;`.  We also need to adapt path prefixes.
-    const fromCalcElement = !fromTargetType && destination.$calcDepElement &&
+    const fromCalcElement = !fromDestinationType && destination.$calcDepElement &&
       destination.value?._artifact === origin;
 
     const { expandedRoot, expandedRootType }
-      = !fromTargetType && getExpandRoot( destination ) || {};
+      = !fromDestinationType && getExpandRoot( destination ) || {};
 
     const config = {
       __proto__: AnnoRewriteConfig.prototype,
       anno: propName,
-      target: destination,
-      targetRoot: annoRootArt( destination ),
+      destination,
+      destinationRoot: annoRootArt( destination ),
       origin,
-      fromTargetType,
+      fromDestinationType,
       fromCalcElement,
       expandedRoot,
       expandedRootType,
@@ -255,10 +259,8 @@ function xprRewriteFns( model ) {
 
     if (propName.charAt( 0 ) === '@')
       return rewriteAnnotationExpr( destination[propName], config );
-    return traverseExpr.STOP === traverseExpr(
-      destination[propName], 'annoRewrite', destination,
-      // eslint-disable-next-line @stylistic/max-len, @stylistic/function-paren-newline
-      (e, refCtx) => (rewriteAnnoExpr( e, config, refCtx ) ? traverseExpr.STOP : traverseExpr.SKIP) );
+    return traverseExpr( destination[propName], 'annoRewrite', destination,
+                         rewriteAnnoExpr.bind( config ) );
   }
 
   /**
@@ -277,37 +279,36 @@ function xprRewriteFns( model ) {
     else if (expr.$tokenTexts) {
       // used to set `$tokenText` to true in case of rewritten annotation
       config.tokenExpr = expr;
-      return traverseExpr.STOP === traverseExpr(
-        expr, 'annoRewrite', config.target,
-        // eslint-disable-next-line @stylistic/max-len, @stylistic/function-paren-newline
-        (e, refCtx) => (rewriteAnnoExpr( e, config, refCtx ) ? traverseExpr.STOP : traverseExpr.SKIP) );
+      return traverseExpr( expr, 'annoRewrite', config.destination,
+                           rewriteAnnoExpr.bind( config ) );
     }
     return false;
   }
 
   /**
-   * @param {XSN.Expression} expr
-   * @param {AnnoRewriteConfig} config
-   * @param {string} refCtx
-   * @returns {null|true} Returns true if the expression couldn't be rewritten.
+   * Rewrite the annotation expression `expr`.
+   * Returns traverseExpr.STOP if the expression couldn't be rewritten.
    */
-  function rewriteAnnoExpr( expr, config, refCtx ) {
+  function rewriteAnnoExpr( expr, refCtx, user ) {
+    const config = this;        // we use rewriteAnnoExpr.bind( config )
     const root = expr.path && (expr.path[0]?._navigation || expr.path[0]?._artifact);
     if (!root || !expr._artifact)
       return null; // invalid path
 
-    const { target } = config;
+    if (refCtx === 'filter')
+      return rewriteGenericAnnoPath( expr, refCtx, config, user );
 
     // Report obsolete $parameters; parameters on non-actions not supported, yet.
-    if (root.kind === '$parameters' || (root.kind === 'param' && root._parent.kind !== 'action' &&
-      root._parent.kind !== 'function'))
+    if (root.kind === '$parameters' ||
+        (root.kind === 'param' && root._parent.kind !== 'action' &&
+         root._parent.kind !== 'function'))
       return reportAnnoRewriteError( expr, config, 'unsupported' );
 
     if (root.kind === 'key') {
       // References starting with a foreign key name (only possible in an
       // annotation on a foreign key) have length 1 + the foreign key cannot be
       // renamed → nothing to do. Otherwise, foreign keys cannot be directly
-      // addressed, except as `annotate` target. (Even as annotation value for
+      // addressed, except via `annotate`. (Even as annotation value for
       // foreign keys, `$self.assoc.target_id` always refers to the target side.)
       return null;
     }
@@ -318,37 +319,15 @@ function xprRewriteFns( model ) {
       return null;
 
     let hasError = false;
-    if (config.fromTargetType || config.fromCalcElement)
-      hasError = adaptPathPrefixViaType( expr, config );
+    if (config.fromDestinationType || config.fromCalcElement)
+      hasError = adaptPathPrefixViaType( expr, config, user );
     else if (config.expandedRoot)
-      hasError = adaptPathPrefixViaTypeExpansion( expr, config );
+      hasError = adaptPathPrefixViaTypeExpansion( expr, config, user );
 
-    hasError ||= rewriteGenericAnnoPath( expr, config, refCtx );
+    hasError ||= rewriteGenericAnnoPath( expr, refCtx, config, user );
 
     if (hasError)
-      return true;
-
-    // TODO: Remove extra loop once filter traversal is added to traverseExpr (#12068)
-    for (const step of expr.path) {
-      if (step?._artifact && step.where && !Array.isArray( step._artifact ) ) {
-        // We must not prefix `$`-renamed variables with `$self`, as it would
-        // change meaning, see (#11775).  Also, the path's target changes.
-        const assocTarget = step._artifact.target._artifact;
-        if (target) {
-          const filterConfig = { ...config, target: assocTarget, isInFilter: true };
-          if (traverseExpr.STOP === traverseExpr(
-            step.where, 'filter', step,
-            // eslint-disable-next-line @stylistic/max-len
-            (e, ctx) => expr.path && (rewriteGenericAnnoPath( e, filterConfig, ctx ) ? traverseExpr.STOP : traverseExpr.SKIP)
-          ))
-            return true;
-        }
-        else {
-          // can't happen: rejected earlier by compiler
-          return reportAnnoRewriteError( expr, config, 'unsupported' );
-        }
-      }
-    }
+      return traverseExpr.STOP;
 
     if (expr.$tokenTexts === true) {
       // TODO: do not do with Universal-CSN (and gensrc, but that does not matter)
@@ -365,46 +344,44 @@ function xprRewriteFns( model ) {
     if (model.options.testMode) {
       // re-resolve the modified path; all paths steps must match what we rewrote
       const ref = { ...expr, path: [ ...expr.path.map(item => ({ ...item })) ] };
-      if (!resolvePath( ref, refCtx, target ))
+      if (!resolvePath( ref, refCtx, user ))
         throw new CompilerAssertion(`rewritten anno path must be resolvable: ${ JSON.stringify(ref.path) }`);
-
-      for (let i = 0; i < ref.path.length; ++i) {
-        const actual = ref.path[i];
-        const expected = ref.path[i];
-        if (actual._artifact !== expected._artifact) {
-          throw new CompilerAssertion(`rewritten anno path contains incorrect artifact links: ${
-            JSON.stringify(ref.path) }; step ${ i }`);
-        }
-        else if (actual._navigation !== undefined && actual._navigation !== expected._navigation) {
-          throw new CompilerAssertion(`rewritten anno path contains incorrect navigation links: ${
-            JSON.stringify(ref.path) }; step ${ i }`);
-        }
-      }
     }
-
     return false;
   }
 
   /**
-   * @param {XSN.Expression} expr
-   * @param {AnnoRewriteConfig} config
-   * @returns {*}
+   * Return the destination node of the expr rewrite (stored in param `config`), or
+   * if we are in a filter expression, the association target of the corresponding
+   * path item (provided via param `user`).
+   *
+   * TODO: in the end, we should directly use the standard expression parameter
+   * `user` in all functions below.  Probably if we unify this module with
+   * rewriteCondition() of tweak-assocs.js.
    */
-  function getRootEnv( expr, config ) {
-    const { target } = config;
+  function destinationOrAssocTarget( config, user ) {
+    return (user.id && user.where)
+      ? user._artifact.target._artifact
+      : config.destination;
+  }
 
+  /**
+   * TODO: what exactly is a root environment?
+   */
+  function getRootEnv( expr, config, destination ) {
     if (expr.scope === 'param') // path is absolute
-      return navigationEnv( config.targetRoot, null, null, 'nav' );
+      return navigationEnv( config.destinationRoot, null, null, 'nav' );
 
     // On select items, use navigation elements or table alias
     // TODO: Expand/inline paths don't have a `_navigation` property on their last
     //       path step, yet.  We need to implement expand/inline.
-    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._columnParent;
+    const isSimpleSelectItem = destination.value?.path && destination._main?.query &&
+      !destination._columnParent;
     if (isSimpleSelectItem) {
       const isSelfPath = (expr.path[0]?._navigation?.kind === '$self');
       if (isSelfPath) {
         // Path is absolute, use table alias to resolve it.
-        let tableAlias = target.value.path[0]._navigation;
+        let tableAlias = destination.value.path[0]._navigation;
         while (tableAlias && tableAlias.kind === '$navElement')
           tableAlias = tableAlias._parent;
         if (tableAlias)
@@ -412,37 +389,35 @@ function xprRewriteFns( model ) {
       }
       else {
         // Path is relative
-        const nav = target.value.path[target.value.path.length - 1]._navigation?._parent;
+        const nav = destination.value.path[destination.value.path.length - 1]._navigation?._parent;
         if (nav)
           return nav;
       }
     }
 
     if (isSimpleSelectItem && model.options.testMode)
-      throw new CompilerAssertion(`select item has no table alias: ${ JSON.stringify(target.value.path) }`);
+      throw new CompilerAssertion(`select item has no table alias: ${ JSON.stringify(destination.value.path) }`);
 
     if (isAnnoPathAbsolute( expr ))
-      return navigationEnv( config.targetRoot, null, null, 'nav' );
+      return navigationEnv( config.destinationRoot, null, null, 'nav' );
 
     // anno path is relative / element reference (others were already rejected)
-    // if the target is a root artifact, use it. Otherwise, use its parent.
-    return navigationEnv( isAnnoRootArt( target ) ? target : target._parent, null, null, 'nav' );
+    // if the destination is a root artifact, use it. Otherwise, use its parent.
+    return navigationEnv( isAnnoRootArt( destination ) ? destination : destination._parent,
+                          null, null, 'nav' );
   }
 
-  /**
-   * @param {XSN.Expression} expr
-   * @param {AnnoRewriteConfig} config
-   * @param {string} refCtx
-   * @returns {boolean}
-   */
-  function rewriteGenericAnnoPath( expr, config, refCtx ) {
+  function rewriteGenericAnnoPath( expr, refCtx, config, user ) {
+    if (expr._artifact?.kind === 'builtin')
+      return false;
+    const destination = destinationOrAssocTarget( config, user );
     const isAbsolute = isAnnoPathAbsolute( expr );
     const startIndex = isAbsolute ? 1 : 0;
 
     // We get the root environment now, even though below we resolve the root item
     // again if it was absolute (e.g. $self).  We do so, because for queries, we
     // want to respect the select item's corresponding table alias.
-    const rootEnv = getRootEnv( expr, config );
+    const rootEnv = getRootEnv( expr, config, destination );
 
     // reset artifact link; we'll set it again if there are no errors
     setArtifactLink( expr, null );
@@ -454,7 +429,7 @@ function xprRewriteFns( model ) {
       delete expr.path[0]._navigation;
       // TODO: What about `up_`? Shouldn't we set `_navigation` as well?
       // TODO: Can we handle `$self` of anonymous-composition-of-aspect?
-      const root = resolvePathRoot( expr, refCtx, config.target );
+      const root = resolvePathRoot( expr, refCtx, destination );
       if (!root)
         return reportAnnoRewriteError( expr, config );
     }
@@ -495,13 +470,13 @@ function xprRewriteFns( model ) {
     setArtifactLink( expr, art );
 
     if (startIndex === 0 && expr.path[0].id.startsWith('$')) {
-      if (config.isInFilter) {
+      if (refCtx === 'filter') {
         // In filters, we must not prepend `$self`, as that would change its meaning.
         // We must reject it. See #11775
         return reportAnnoRewriteError( expr, config );
       }
       // After rewriting, if an element starts with `$` -> add root prefix
-      prependRootPath( config.origin, config.targetRoot, expr );
+      prependRootPath( config.origin, config.destinationRoot, expr );
     }
 
     return false;
@@ -513,12 +488,12 @@ function xprRewriteFns( model ) {
    *
    * @returns {boolean} Returns true if it couldn't be rewritten.
    */
-  function adaptPathPrefixViaType( expr, config ) {
-    const { target, origin } = config;
-    if (!target._main && !origin._main)
+  function adaptPathPrefixViaType( expr, config, user ) {
+    const { destination, origin } = config;
+    if (!destination._main && !origin._main)
       return false; // no need to rewrite; both are top-level
 
-    if (rejectOuterReference( expr, origin, config ))
+    if (rejectOuterReference( expr, origin, config, user ))
       return true;
 
     // $self-paths via types from/to non-main artifacts always need to be rewritten.
@@ -529,16 +504,16 @@ function xprRewriteFns( model ) {
     stripAbsolutePathPrefix( expr, origin );
 
     if (wasAbsolute) {
-      prependRootPath( origin, target, expr );
+      prependRootPath( origin, destination, expr );
     }
-    else if (!isAnnoRootArt( target )) { // target is element
-      const item = { id: target.name.id };
-      setArtifactLink( item, target );
+    else if (!isAnnoRootArt( destination )) { // destination is element
+      const item = { id: destination.name.id };
+      setArtifactLink( item, destination );
       prependToStrippedPath( origin, expr, [ item ] );
     }
-    else if (target.kind === 'param') {
+    else if (destination.kind === 'param') {
       // annotations on parameters need a `:prefix`
-      prependRootPath( origin, target, expr );
+      prependRootPath( origin, destination, expr );
     }
     else {
       prependToStrippedPath( origin, expr, [ ] );
@@ -556,7 +531,7 @@ function xprRewriteFns( model ) {
    *
    * @returns {boolean} Returns true if it couldn't be rewritten.
    */
-  function adaptPathPrefixViaTypeExpansion( expr, config ) {
+  function adaptPathPrefixViaTypeExpansion( expr, config, user ) {
     const root = expr.path[0]?._navigation;
     if (root?.kind !== '$self') {
       // non-self paths are always valid in expanded artifacts
@@ -569,14 +544,14 @@ function xprRewriteFns( model ) {
     if (!isBetaEnabled( model.options, 'rewriteAnnotationExpressionsViaType' ))
       return reportAnnoRewriteError( expr, config, 'unsupported' );
 
-    if (rejectOuterReference( expr, config.expandedRootType, config ))
+    if (rejectOuterReference( expr, config.expandedRootType, config, user ))
       return true;
 
     stripAbsolutePathPrefix( expr, config.expandedRootType );
     prependRootPath( config.expandedRootType, config.expandedRoot, expr );
-    setExpandStatusAnnotate( config.target, 'annotate' );
+    setExpandStatusAnnotate( config.destination, 'annotate' );
 
-    config.target[config.anno].$inferred = 'anno-rewrite';
+    config.destination[config.anno].$inferred = 'anno-rewrite';
     // $self-paths via type expansion always need to be rewritten.
     if (config.tokenExpr)
       config.tokenExpr.$tokenTexts = true;
@@ -621,32 +596,29 @@ function xprRewriteFns( model ) {
   }
 
   /**
-   * Returns false if the path can be propagated to the target without referring
-   * to any "outer" elements.  It differentiates between the target being a main
+   * Returns false if the path can be propagated to the destination without referring
+   * to any "outer" elements.  It differentiates between the destination being a main
    * artifact and elements, because an element annotation referring to itself can't
    * be propagated to a type:
    *
    *     type T1 : { @a: (elem) elem: String; };
    *     type T2 : T1:elem; // invalid
    *
-   * Also considers other targets such as `returns`, etc.
-   *
-   * @param {XSN.Expression} expr
-   * @param {XSN.Artifact} origin
-   * @param {AnnoRewriteConfig} config
-   * @returns {boolean}
+   * Also considers other destinations such as `returns`, etc.
    */
-  function rejectOuterReference( expr, origin, config ) {
+  function rejectOuterReference( expr, origin, config, user ) {
     if (!isAnnoPathAbsolute( expr ) && !origin._main)
       return false;
 
     const root = expr.path[0]?._navigation;
     const found = findRelativeRoot( expr, origin );
+    const destination = destinationOrAssocTarget( config, user );
     const isInvalid = (found === -1) ||
       // Can't use paths with `$self` in `returns`.
-      (root?.kind === '$self' && isReturnParam( config.targetRoot )) ||
+      (root?.kind === '$self' && isReturnParam( config.destinationRoot )) ||
       // siblings are allowed for non-main artifacts, except for 'returns'
-      (!config.target._main || isReturnParam( config.target )) && (expr.path.length - found) <= 1;
+      (!destination._main || isReturnParam( destination )) &&
+      (expr.path.length - found) <= 1;
 
     if (isInvalid)
       return reportAnnoRewriteError( expr, config );
@@ -720,7 +692,7 @@ function xprRewriteFns( model ) {
    * @returns {*|null}
    */
   function rewriteItem( expr, config, env, index ) {
-    const rewriteTarget = findRewriteTarget( expr, index, env, config.target );
+    const rewriteTarget = findRewriteTarget( expr, index, env, config.destination );
     const found = setArtifactLink( expr.path[index], rewriteTarget[0] );
     if (!found)
       return null;
@@ -784,20 +756,20 @@ function isReturnParam( art ) {
 }
 
 /**
- * Gets the artifact (e.g. element) that was expanded. `target` is a sub-artifact of that root and
- * is an expanded element.
+ * Gets the artifact (e.g. element) that was expanded.
+ * `destination` is a sub-artifact of that root and is an expanded element.
  *
  * - expandedRoot:     Top-most structure that was expanded.
  * - expandedRootType: The type of expandedRoot.
  *
- * @param {XSN.Artifact} target
+ * @param {XSN.Artifact} destination
  * @returns { {expandedRoot: XSN.Artifact, expandedRootType: XSN.Artifact}}
  */
-function getExpandRoot( target ) {
-  if (target.$inferred !== 'expanded' && target.$inferred !== 'rewrite')
+function getExpandRoot( destination ) {
+  if (destination.$inferred !== 'expanded' && destination.$inferred !== 'rewrite')
     return { expandedRoot: null, expandedRootType: null };
 
-  let expandedRoot = target;
+  let expandedRoot = destination;
 
   // 'expanded' for structures, 'rewrite' for foreign keys
   while (expandedRoot.$inferred === 'expanded' || expandedRoot.$inferred === 'rewrite')

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-2f488eae5a0a809b97737edac6e2a42d
+8e38091fda3711e1d4d2b8b87fbdd328

package/lib/gen/CdlParser.js

@@ -2111,6 +2111,7 @@ default:this.gr([';']);continue
 }
 default:
 this.attachLocation( $.art )
+if (!$.art.name) this.addDef( $.art, $.outer, 'elements', 'element' )
 return this.exit_()
 }
 }
@@ -4451,8 +4452,8 @@ case 820:switch(this.l()){
 case')':this.gc(821,'fail')&&this.c(0);continue
 default:this.s=821;continue
 }
-case 821:if(this.condition(_={},822))$.value=_.expr;continue
-case 822:if(this.m(0,')')){ $.value.$tokenTexts = this.ruleTokensText(); }continue
+case 821:if(this.condition(_={},822)){$.value=_.expr; $.value.$tokenTexts = this.ruleTokensText(); }continue
+case 822:this.m(0,')');continue
 default:
 this.attachLocation( $.value )
 return this.exit_()

package/lib/parsers/AstBuildingParser.js

@@ -696,7 +696,7 @@ class AstBuildingParser extends BaseParser {
 
   ruleTokensText() {
     let tokenIdx = this.stack.at(-1).tokenIdx + 1;
-    const stop = this.tokenIdx - 1;
+    const stop = this.tokenIdx;
 
     let { text: result, location: prev } = this.tokens[tokenIdx];
     while (++tokenIdx < stop) {

package/lib/transform/db/assocsToQueries/transformExists.js

@@ -283,7 +283,7 @@ function handleExists( csn, options, messageFunctions, csnUtils ) {
 
         newExpr.push('exists');
         if (ref?.where) {
-          const remappedWhere = remapExistingWhere(target, ref.where, exprPath, current);
+          const remappedWhere = remapExistingWhere( target, ref.where );
           subselect.SELECT.where.push('and');
           if (remappedWhere.length > 3)
             subselect.SELECT.where.push( { xpr: remappedWhere } );
@@ -361,21 +361,14 @@ function handleExists( csn, options, messageFunctions, csnUtils ) {
    *
    * This function does this by adding the assoc target before all the refs so that the refs are resolvable in the WHERE.
    *
-   * This function also rejects $self paths in filter conditions.
-   *
    * @param {string} target
    * @param {TokenStream} where
-   * @param {CSN.Path} path path to the part, used if error needs to be thrown
-   * @param {CSN.Artifact} parent the host of the `where`, used if error needs to be thrown
    *
    * @returns {TokenStream} where The input-where with the refs transformed to absolute ones
    */
-  function remapExistingWhere( target, where, path, parent ) {
+  function remapExistingWhere( target, where ) {
     return where.map((part) => {
-      if (part.$scope === '$self') {
-        error('ref-unexpected-self', path, { '#': 'exists-filter', elemref: parent, id: part.ref[0] });
-      }
-      else if (part.ref && part.$scope !== '$magic') {
+      if (part.ref && part.$scope !== '$magic') {
         part.ref = [ target, ...part.ref ];
         return part;
       }

package/lib/transform/db/assocsToQueries/utils.js

@@ -145,11 +145,6 @@ function getHelpers( csn, inspectRef, error ) {
    * @returns {object[]} The stuff to add to the where
    */
   function translateManagedAssocToWhere( root, target, isPrefixedWithTableAlias, base, current ) {
-    if (current.$scope === '$self') {
-      error('ref-unexpected-self', current.$path, { '#': 'exists', id: current.ref[0], name: 'exists' });
-      return [];
-    }
-
     const whereExtension = [];
     for (let j = 0; j < root.keys.length; j++) {
       const lop = { ref: [ target, ...root.keys[j].ref ] }; // target side

package/lib/transform/localized.js

@@ -58,23 +58,7 @@ const annoPersistenceSkip = '@cds.persistence.skip';
  * @param {CSN.Model} csn
  *     Input CSN model.  Should not have existing convenience views.
  *
- * @param {object} options
- *     CSN options.  Only few options are used, see below for important ones.
- *     Options such as `testMode` or `testSortCsn` can also be set.
- *
- * @param {string} [options.localizedLanguageFallback]
- *     Valid values (if set): 'none', 'coalesce' (default)
- *     Whether to use a `coalesce()` function when selecting from `.texts` entities.
- *     If not set, untranslated strings may not return any value.  If 'coalesce'
- *     is used, it will fall back to the original string.
- *
- * @param {boolean} [options.localizedWithoutCoalesce]
- *     Deprecated version of localizedLanguageFallback. Do not use.
- *
- * @param {boolean} [options.fewerLocalizedViews]
- *     Default: true
- *
- * @param {boolean} [options.testMode]
+ * @param {CSN.Options} options
  *
  * @param {object} config
  *     Configuration for creating convenience views.  Non-user visible options.
@@ -252,12 +236,14 @@ function _addLocalizationViews(csn, options, config) {
     }
 
     function createJoinConditionFromLocaleElement() {
+      const targetAlias = 'localized_1';
+      const sourceAlias = 'L_0';
       return adaptExpr(entity.elements.localized.on);
 
       function adaptExpr(expr) {
         // We only support a few specific ON-conditions, not generic expressions.
         // In case of unsupported ON-conditions, we emit an error.
-        return expr.map((x) => {
+        const res = expr.map((x) => {
           if (!x || typeof x === 'string')
             return x;
           if (x.xpr)
@@ -273,14 +259,21 @@ function _addLocalizationViews(csn, options, config) {
           );
           return x;
         });
+
+        // the `localized` association does not contain the `tenant` element, so we need to add it here
+        const addTenantCol = options.tenantDiscriminator && entity.elements.tenant?.key;
+        if (addTenantCol)
+          return [ { ref: [ targetAlias, 'tenant' ] }, '=', { ref: [ sourceAlias, 'tenant' ] }, 'AND', { xpr: [ ...res ] } ];
+
+        return res;
       }
 
       function adaptRef(expr) {
         if (expr.ref[0].charAt(0) === '$') // variable
           return { ref: [ ...expr.ref ] };
         if (expr.ref[0] === 'localized') // target side
-          return { ref: [ 'localized_1', ...expr.ref.slice(1) ] };
-        return { ref: [ 'L_0', ...expr.ref ] }; // source side
+          return { ref: [ targetAlias, ...expr.ref.slice(1) ] };
+        return { ref: [ sourceAlias, ...expr.ref ] }; // source side
       }
     }
   }