@sap/cds-compiler 5.1.2 → 5.2.0

package/lib/compiler/populate.js

@@ -789,8 +789,8 @@ function populate( model ) {
         return col.name.id;
       }
     }
-    else if (col.expand || col.value && (col._pathHead || query._parent.kind !== 'select')) {
-      // _pathHead => inline/expand; _parent -> only allowed in sub-selects
+    else if (col.expand || col.value && (col._columnParent || query._parent.kind !== 'select')) {
+      // _columnParent => inline/expand; _parent -> only allowed in sub-selects
       error( 'query-req-name', [ col.value?.location || col.location, query ], {},
              'Alias name is required for this select item' );
     }
@@ -867,7 +867,7 @@ function populate( model ) {
     const inferred = query._main.$inferred;
     const excludingDict = (colParent || query).excludingDict || Object.create( null );
 
-    const envParent = wildcard._pathHead; // TODO: rename _pathHead to _columnParent
+    const envParent = wildcard._columnParent;
     const env = wildcardColumnEnv( wildcard, query );
     if (!env)
       return;
@@ -931,7 +931,7 @@ function populate( model ) {
       // already done in populateQuery (TODO: change that and check whether
       // `*` is allowed at all in definer)
       if (!colParent || colParent.value._artifact) {
-        // avoid "not found" messages if pathHead can't be found
+        // avoid "not found" messages if columnParent can't be found
         const user = colParent || query;
         for (const name in user.excludingDict)
           resolveExcluding( name, env, excludingDict, query );
@@ -939,9 +939,9 @@ function populate( model ) {
     }
   }
 
-  function wildcardColumnEnv( wildcard, query ) { // etc.  wildcard._pathHead;
+  function wildcardColumnEnv( wildcard, query ) { // etc.  wildcard._columnParent;
     // if (envParent) console.log( 'CE:', envParent._origin, query );
-    const colParent = wildcard._pathHead;
+    const colParent = wildcard._columnParent;
     if (!colParent)
       return userQuery( query )._combined; // see combinedSourcesOrParentElements
 
@@ -985,14 +985,14 @@ function populate( model ) {
     }
   }
 
-  function setWildcardExpandInline( queryElem, pathHead, origin, name, location ) {
-    setLink( queryElem, '_pathHead', pathHead );
+  function setWildcardExpandInline( queryElem, columnParent, origin, name, location ) {
+    setLink( queryElem, '_columnParent', columnParent );
     const path = [ { id: name, location } ];
     queryElem.value = { path, location }; // TODO: can we omit that?  We have _origin
     setArtifactLink( path[0], origin );
     setLink( queryElem, '_origin', origin );
     // set _projections when inline with table alias:
-    // const alias = pathHead?.value?.path?.[0]?._navigation;
+    // const alias = columnParent?.value?.path?.[0]?._navigation;
     // if (alias?.kind === '$tableAlias')
     //   pushLink( alias.elements[name], '_projections', queryElem );
   }

package/lib/compiler/propagator.js

@@ -66,6 +66,7 @@ function propagate( model ) {
     __proto__: null,
     never,
     onlyViaArtifact,
+    onlyViaParent,
     notWithPersistenceTable,
   };
   for (const rule in propagationRules)

package/lib/compiler/resolve.js

@@ -174,9 +174,10 @@ function resolve( model ) {
         // TODO: or should we push elems with `expand` sibling to extra list for
         //       better messages?  (Whatever that means exactly.)
 
-        if (elem._pathHead) {
-          if (elem._pathHead?.kind !== '$inline')
-            // we're traversing top-level elements of the query; other _pathHead kinds can't happen
+        if (elem._columnParent) {
+          if (elem._columnParent?.kind !== '$inline')
+            // we're traversing top-level elements of the query;
+            // other _columnParent kinds can't happen
             throw new CompilerAssertion('found unexpected "expand", but expected "inline"');
 
           if (!isPathBreakout( elem.value )) {
@@ -205,13 +206,17 @@ function resolve( model ) {
       if (!nav.item._navigation) // first non-table-alias
         setLink( nav.item, '_navigation', navItem );
 
-      if (path[index].where || path[index].args)
-        return;
+      // We consider an element only projected if the path doesn't have
+      // either arguments or filters; but we build up the navigation env
+      // nonetheless, as it makes rewriting paths later on easier.
+      let isComplexPath = !!(path[index].where || path[index].args);
+
       ++index;
       while (navItem && index < path.length) {
         const step = path[index];
-        if (!step?.id || step.where || step.args)
+        if (!step?.id)
           break;
+        isComplexPath ||= !!(step.where || step.args);
         if (!navItem.elements?.[step.id]) {
           const elements = navItem._origin?.elements ||
             navItem._origin?.target?._artifact?.elements;
@@ -228,26 +233,26 @@ function resolve( model ) {
         setLink( step, '_navigation', navItem );
         ++index;
       }
-      // Last path step, if found, is a simple projection
+      // Last path step, if found, is a projected, either complex or simple.
       if (index === path.length && navItem)
-        pushLink( navItem, '_projections', elem );
+        pushLink( navItem, isComplexPath ? '_complexProjections' : '_projections', elem );
     }
   }
 
   function columnParentPath( elem ) {
-    if (!elem._pathHead || !elem.value?.path || isPathBreakout( elem.value ))
+    if (!elem._columnParent || !elem.value?.path || isPathBreakout( elem.value ))
       return elem.value?.path;
 
     const fullPath = [ ...elem.value.path ];
-    let pathHead = elem._pathHead;
-    while (pathHead) {
-      if (pathHead.kind !== '$inline' || !pathHead.value?.path ||
-          isPathBreakout( pathHead.value )) {
+    let columnParent = elem._columnParent;
+    while (columnParent) {
+      if (columnParent.kind !== '$inline' || !columnParent.value?.path ||
+          isPathBreakout( columnParent.value )) {
         // path breakout for e.g. `$self.{ foo }`, `1 as a .{ foo }`
         return null;
       }
-      fullPath.unshift(...pathHead.value.path);
-      pathHead = pathHead._pathHead;
+      fullPath.unshift(...columnParent.value.path);
+      columnParent = columnParent._columnParent;
     }
     return fullPath;
   }
@@ -285,16 +290,16 @@ function resolve( model ) {
     return false;
   }
 
-  function inheritedSourceKeyProp( { value, _pathHead } ) {
+  function inheritedSourceKeyProp( { value, _columnParent } ) {
     if (!value || !value.path)
       return null;
-    const nav = !_pathHead && pathNavigation( value );
+    const nav = !_columnParent && pathNavigation( value );
     const item = value.path[value.path.length - 1];
     if (nav?.navigation && nav.item === item)
       return item._artifact?.key;
-    if (value.path.length !== 1 || _pathHead?.kind !== '$inline')
+    if (value.path.length !== 1 || _columnParent?.kind !== '$inline')
       return null;
-    const hpath = _pathHead.value?.path;
+    const hpath = _columnParent.value?.path;
     const head = hpath?.length === 1 && hpath[0]._navigation;
     return head?.kind === '$tableAlias' && item._artifact?.key;
   }
@@ -344,7 +349,7 @@ function resolve( model ) {
       const elem = query.elements[name];
 
       if (!elem.$inferred && elem.value?.path) {
-        const path = elem._pathHead ? columnParentPath( elem ) : elem.value.path;
+        const path = elem._columnParent ? columnParentPath( elem ) : elem.value.path;
         if (testExpr({ path }, selectTest, () => false, elem))
           propagateKeys = false;
       }
@@ -1008,7 +1013,7 @@ function resolve( model ) {
     }
     const target = resolvePath( obj.target, 'target', art );
 
-    if (obj._pathHead && obj.type && !obj.type.$inferred && art._main && art._main.query) {
+    if (obj._columnParent && obj.type && !obj.type.$inferred && art._main && art._main.query) {
       // New association inside expand/inline: The on-condition can't be properly checked,
       // so abort early. See #8797
       error( 'query-unexpected-assoc', [ obj.name.location, art ], {},
@@ -1253,18 +1258,7 @@ function resolve( model ) {
       error( 'type-invalid-cast', [ elem.type.location, elem ], { '#': 'assoc' } );
       return;
     }
-    // console.log(message( null, elem.location, elem, {target,art:assoc}, 'Info','RE')
-    //             .toString(), elem.value)
-    const nav = elem._main && elem._main.query && elem.value && pathNavigation( elem.value );
-    if (nav && nav.item !== elem.value.path[elem.value.path.length - 1]) {
-      if (!elem.on && origType.on) {
-        error( 'rewrite-not-supported', [ elem.target.location, elem ] );
-        return;
-      }
-    }
     const origTarget = origType.target._artifact;
-    // console.log(require('../model/revealInternalProperties').ref(elem),
-    //             !!origTarget,!!origType._effectiveType,!!origType.target)
     if (!origTarget || !target)
       return;
 
@@ -1377,7 +1371,7 @@ function resolve( model ) {
         if (a.path && a.kind !== '$self' && a.kind !== 'mixin')
           sources.push( a );
       }
-      if (alias.kind === '$tablealias')
+      if (alias.kind === '$tableAlias')
         news.push( { chain: [ alias, ...chain ], sources } );
       else
         news.push( { chain, sources } );
@@ -1593,7 +1587,8 @@ function pathNavigation( ref ) {
   if (root.kind === '$self')
     return { item, tableAlias: root };
   if (root.kind !== '$tableAlias' || ref.path.length < 2)
-    return {};                // should not happen
+    return {}; // should not happen
+  // table alias
   return { navigation: root.elements?.[item.id], item, tableAlias: root };
 }
 

package/lib/compiler/shared.js

@@ -1,5 +1,4 @@
 // Compiler functions and utilities shared across all phases
-// TODO: rename to paths.js and move non resolve-paths functions to somewhere else
 
 'use strict';
 
@@ -546,7 +545,7 @@ function fns( model ) {
       ruser = ruser._outer;
 
     // Handle expand/inline, `type of`, :param, global (internally for CDL):
-    if (user._pathHead && !semantics.isMainRef) { // in expand/inline
+    if (user._columnParent && !semantics.isMainRef) { // in expand/inline
       const { name } = semantics;
       semantics = semantics.nestedColumn();
       semantics.name = name;
@@ -563,7 +562,7 @@ function fns( model ) {
 
     // Search in lexical environments, including $self/$projection:
     const { isMainRef } = semantics;
-    const lexical = semantics.lexical?.( ruser ); // TODO: _pathHead?
+    const lexical = semantics.lexical?.( ruser ); // TODO: _columnParent?
     if (lexical) {
       const [ nextProp, dictProp ] = (isMainRef)
         ? [ '_block', 'artifacts' ]
@@ -608,7 +607,7 @@ function fns( model ) {
   // element item in the path)
   // TODO - think about setting _navigation for all $navElement – the
   // "ref: ['tabAlias']: inline: […]" handling might be easier
-  // (no _pathHead consultation for key prop and renaming support)
+  // (no _columnParent consultation for key prop and renaming support)
   function getPathItem( ref, semantics, user ) {
     // let art = (headArt && headArt.kind === '$tableAlias') ? headArt._origin : headArt;
     const { path } = ref;
@@ -918,7 +917,7 @@ function fns( model ) {
   }
 
   function nestedElements( user ) {
-    const colParent = user._pathHead;
+    const colParent = user._columnParent;
     Functions.effectiveType( colParent ); // set _origin
     const path = colParent?.value?.path;
     if (!path?.length)
@@ -1129,7 +1128,7 @@ function fns( model ) {
   }
 
   function undefinedNestedElement( user, head, valid, _dict, _art, path, semantics ) {
-    const art = user._pathHead._origin;
+    const art = user._columnParent._origin;
     if (!art)
       return null;              // no consequential error
     return undefinedItemElement( user, head, valid, null, art, path, semantics );
@@ -1551,7 +1550,7 @@ function fns( model ) {
     const location = (user.expand || user.inline)[$location];
     // mention `table alias` in text only with initial single path item ref,
     // but do not mention that $self { … } is allowed, shouldn't be advertised:
-    const txt = (path.length > 1 || user._pathHead) ? 'struct' : 'init';
+    const txt = (path.length > 1 || user._columnParent) ? 'struct' : 'init';
     const code = (user.expand) ? '{ ‹expand› }' : '.{ ‹inline› }';
     message( 'def-unexpected-nested-proj', [ location, user ], { '#': txt, code } );
   }
@@ -1655,7 +1654,7 @@ function fns( model ) {
 
   function checkOnlyForeignKeyNavigation( user, path, startIndex = 0, msgPrefix = '' ) {
     // has to be run after foreign-key rewrite
-    const outer = user._pathHead?._origin;
+    const outer = user._columnParent?._origin;
     let assoc = outer?.foreignKeys &&
                 pathStartsWithSelf( { path } ) == null && // not $self or CDS var like $now
                 outer;

package/lib/compiler/tweak-assocs.js

@@ -73,7 +73,6 @@ function tweakAssocs( model ) {
   // Only top-level queries and sub queries in FROM
 
   function rewriteArtifact( art ) {
-    // return;
     if (!art.query) {
       rewriteAssociation( art );
     }
@@ -333,27 +332,62 @@ function tweakAssocs( model ) {
 
     // 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},
-    //  'Info','FK').toString())
     elem.foreignKeys = Object.create(null); // set already here (also for zero foreign keys)
     forEachInOrder( assoc, 'foreignKeys', ( orig, name ) => {
       const location = weakRefLocation( elem.target );
       const fk = linkToOrigin( orig, name, elem, 'foreignKeys', location );
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
       setLink( fk, '_effectiveType', fk );
-      const te = copyExpr( orig.targetElement, location );
-      if (elem._redirected) {
-        const i = te.path[0];   // TODO: or also follow path like for ON?
-        const state = rewriteItem( elem, i, i.id, elem, true );
-        if (state && state !== true && te.path.length === 1)
-          setArtifactLink( te, state );
-      }
-      fk.targetElement = te;
+      fk.targetElement = copyExpr( orig.targetElement, location );
+      if (elem._redirected)
+        rewriteKey( elem, fk.targetElement );
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
   }
 
+  function rewriteKey( elem, targetElement ) {
+    let projectedKey = null;
+    // rewrite along redirection chain
+    for (const alias of elem._redirected) {
+      if (alias.kind !== '$tableAlias')
+        continue;
+
+      projectedKey = firstProjectionForPath( targetElement.path, 0, alias, null );
+      if (projectedKey.elem) {
+        const item = targetElement.path[projectedKey.index];
+        item.id = projectedKey.elem.name.id;
+        if (projectedKey.index > 0)
+          targetElement.path.splice(0, projectedKey.index);
+      }
+      else {
+        setArtifactLink( targetElement.path[0], null );
+        setArtifactLink( targetElement, null );
+
+        const culprit = !elem.target.$inferred && elem.target ||
+          elem.value?.path?.[elem.value.path.length - 1] ||
+          elem;
+        // TODO: probably better to collect the non-projected foreign keys
+        // and have one message for all
+        error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
+          '#': 'std',
+          id: targetElement.path.map(p => p.id).join('.'),
+          target: alias._main,
+          name: elem.name.id,
+        });
+        return null;
+      }
+    }
+
+    if (projectedKey?.elem) {
+      const item = targetElement.path[0];
+      setArtifactLink( item, projectedKey.elem );
+      setArtifactLink( targetElement, projectedKey.elem );
+      return projectedKey.elem;
+    }
+    return null;
+  }
+
   // TODO: there is no need to rewrite the on condition of non-leading queries,
   // i.e. we could just have on = {…}
   // TODO: re-check $self rewrite (with managed composition of aspects),
@@ -380,27 +414,35 @@ function tweakAssocs( model ) {
     elem.on.$inferred = 'copy';
 
     const { navigation } = nav;
-    if (!navigation) // TODO: what about $projection.assoc as myAssoc ?
+    if (!navigation) { // TODO: what about $projection.assoc as myAssoc ?
+      if (elem._columnParent)
+        error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
       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 ] );
     }
-    else if (!nav.tableAlias || nav.tableAlias.path) {
+    const isAssocInStruct = (navigation !== assoc && navigation._origin !== assoc);
+    if (isAssocInStruct) {
+      // For "[sub.]assoc1.assoc2": not supported, yet (#3977)
+      const multipleAssoc = elem.value.path.slice(0, -1).some(segment => segment._artifact?.target);
+      if (multipleAssoc && elem._redirected !== null) { // null = already reported
+        error('rewrite-not-supported', [ elem.target.location, elem ], { '#': 'secondary' });
+        return;
+      }
+    }
+
+    if (!nav.tableAlias || nav.tableAlias.path) {
+      const navEnv = followNavigationPath( elem.value?.path, nav ) || nav.tableAlias;
       traverseExpr( elem.on, 'rewrite-on', elem,
-                    expr => rewriteExpr( expr, elem, nav.tableAlias ) );
+                    expr => rewriteExpr( expr, elem, nav.tableAlias, navEnv ) );
     }
-    else if (elem._pathHead) {
-      error( 'rewrite-not-supported', [ elem.target.location, elem ] );
+    else if (elem._columnParent) {
+      error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
+      return;
     }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
+      return;
     }
 
     addConditionFromAssocPublishing( elem, assoc, nav );
@@ -528,7 +570,7 @@ function tweakAssocs( model ) {
 
   // Caller must ensure ON-condition correctness via rewriteExpr()!
   function foreignKeysToOnCondition( elem, assoc, nav ) {
-    if (model.options.testMode && !nav.tableAlias && !elem._pathHead && elem.$syntax !== 'calc')
+    if (model.options.testMode && !nav.tableAlias && !elem._columnParent && elem.$syntax !== 'calc')
       throw new CompilerAssertion('rewriting keys to cond: no tableAlias but not inline/calc');
 
     if ((!nav.tableAlias && elem.$syntax !== 'calc') || elem._parent?.kind === 'element' ||
@@ -571,8 +613,11 @@ function tweakAssocs( model ) {
       setLink( rhs.path[0], '_artifact', assoc );
       setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1]._artifact );
 
-      if (elem.$syntax !== 'calc') { // different to lhs!
-        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, elem );
+      if (elem.$syntax !== 'calc') {
+        // Not passing an element, as we don't want to use our own filtered association here!
+        // That's done for lhs.
+        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, null );
+        // different to lhs!
         rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
       }
 
@@ -607,7 +652,13 @@ function tweakAssocs( model ) {
     return cond;
   }
 
-  function rewriteExpr( expr, assoc, tableAlias ) {
+  /**
+   * @param expr
+   * @param assoc
+   * @param tableAlias
+   * @param navEnv Navigation element / table alias, used to traverse/rewrite the path.
+   */
+  function rewriteExpr( expr, assoc, tableAlias, navEnv = tableAlias ) {
     // Rewrite ON condition (resulting in outside perspective) for association
     // 'assoc' in query or including entity from ON cond of mixin element /
     // element in included structure / element in source ref/d by table alias.
@@ -620,7 +671,7 @@ function tweakAssocs( model ) {
       return;
     if (!assoc._main)
       return;
-    if (tableAlias) { // from ON cond of element in source ref/d by table alias
+    if (navEnv) { // from ON cond of element in source ref/d by table alias
       const source = tableAlias._origin;
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
       if (!root || root._main !== source)
@@ -628,7 +679,8 @@ function tweakAssocs( model ) {
       if (expr.scope === 'param' || root.kind === '$parameters')
         return;                 // are not allowed anyway - there was an error before
       const startIndex = (root.kind === '$self' ? 1 : 0);
-      const result = firstProjectionForPath( expr.path, startIndex, tableAlias, assoc );
+      const exprNavigation = (root.kind === '$self' ? tableAlias : navEnv);
+      const result = firstProjectionForPath( expr.path, startIndex, exprNavigation, 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;
@@ -647,8 +699,8 @@ function tweakAssocs( model ) {
         }
         return;
       }
-      const nav = pathNavigation( expr );
-      if (nav.navigation || nav.tableAlias) { // 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 );
         rewritePath( expr, nav.item, assoc, elem,
                      nav.item ? nav.item.location : expr.path[0].location );
@@ -691,8 +743,9 @@ function tweakAssocs( model ) {
     if (!elem) {
       if (location) {
         const elemref = root._navigation?.kind === '$self' ? path.slice(1) : path;
+        // TODO: Fix message for sub-elements: `s: { a: Association on x=1, x: Integer};` for x
         error( 'rewrite-not-projected', [ location, assoc ], {
-          name: assoc.name.id, art: item._artifact, elemref: { ref: elemref },
+          name: assoc.name.id, art: elemref[0]._artifact, elemref: { ref: elemref },
         }, {
           std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
           element: 'Projected association $(NAME) uses non-projected element $(ELEMREF) of $(ART)',
@@ -729,14 +782,11 @@ function tweakAssocs( model ) {
         if (i === item)
           state = setArtifactLink( i, elem );
       }
-      else if (i) {
-        state = rewriteItem( state, i, i.id, assoc, false );
+      else {
+        state = rewriteItem( state, i, assoc );
         if (!state || state === true)
           break;
       }
-      else {
-        return;
-      }
     }
     if (state !== true)
       setArtifactLink( ref, state );
@@ -749,9 +799,15 @@ function tweakAssocs( model ) {
     path.unshift( root );
   }
 
-  function rewriteItem( elem, item, name, assoc, forKeys ) {
+  /**
+   * @param elem "Navigation environment" (element) for `item`.
+   * @param item Path segment to rewrite.
+   * @param assoc Published association of query.
+   */
+  function rewriteItem( elem, item, assoc ) {
     if (!elem._redirected)
       return true;
+    let name = item.id;
     for (const alias of elem._redirected) {
       // TODO: a message for the same situation as msg 'rewrite-shadowed'?
       if (alias.kind === '$tableAlias') { // _redirected also contains structures for includes
@@ -760,21 +816,8 @@ function tweakAssocs( model ) {
         // but its origins, too.
         const proj = navProjection( alias.elements[name], assoc );
         name = proj?.name?.id;
-        if (!name) {
-          if (!forKeys)
-            break;
-          setArtifactLink( item, null );
-          const culprit = elem.target && !elem.target.$inferred && elem.target ||
-                          elem.value?.path?.[elem.value.path.length - 1] ||
-                          elem;
-          // TODO: probably better to collect the non-projected foreign keys
-          // and have one message for all
-          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), assoc ], {
-            '#': 'std', id: item.id, target: alias._main, name: assoc.name.id,
-          });
-          // ''
-          return null;
-        }
+        if (!name)
+          break;
         item.id = name;
         // TODO: Why not break here? Test test3/scenarios/AFC/db/view/consumption/C_ScopedRole.cds
       }
@@ -802,14 +845,20 @@ function tweakAssocs( model ) {
 
 function navProjection( navigation, preferred ) {
   // TODO: Info if more than one possibility?
-  // console.log(navigation,navigation._projections)
   if (!navigation)
     return {};
-  else if (!navigation._projections)
+
+  if (!navigation._projections && !navigation._complexProjections)
     return null;
-  return (preferred && navigation._projections.includes( preferred ))
-    ? preferred
-    : navigation._projections[0] || 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;
 }
 
 
@@ -824,6 +873,9 @@ function navProjection( navigation, preferred ) {
  * 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.
  *
+ * If nothing was found, `ret.elem` is null, and `ret.item` is the last segment for which
+ * there was a $navElement.
+ *
  * @param {any[]} path
  * @param {number} startIndex
  * @param {object} nav
@@ -844,30 +896,69 @@ function firstProjectionForPath( path, startIndex, nav, elem ) {
 
   let proj = null;
   let navItem = nav;
-  for (let i = startIndex; i < path.length; ++i) {
-    const item = path[i];
+  let navIndex = startIndex;
+  for (; navIndex < path.length; ++navIndex) {
+    const item = path[navIndex];
     navItem = item?.id && navItem.elements?.[item.id];
     if (!navItem) {
       break;
     }
-    else if (navItem._projections) {
+    else if (navItem._projections || navItem._complexProjections) {
       const projElem = navProjection( navItem, elem );
       if (projElem && projElem === elem) {
         // in case the specified association is found, _always_ use it.
-        return { index: i, item, elem };
+        return { index: navIndex, item, elem };
       }
       else if (projElem) {
         const queryIndex = selectedElements.indexOf(projElem);
         if (!proj || queryIndex < proj.queryIndex) {
           proj = {
-            index: i, item, elem: projElem, queryIndex,
+            index: navIndex, item, elem: projElem, queryIndex,
           };
         }
       }
     }
   }
+  if (proj)
+    return proj;
+
+  const index = (navIndex - 1) <= startIndex ? startIndex : (navIndex - 1);
+  return { index, item: path[index], elem: null };
+}
+
+/**
+ * Follow the navigation along the given path to its N-1 path step, so
+ * that the last step can be resolved against the returned navigation like
+ * `returnValue.elements[last.id]`.
+ *
+ * @param {XSN.Path} path
+ * @param {object} nav
+ * @returns {object|null}
+ */
+function followNavigationPath( path, nav ) {
+  if (!nav.item || !path || path.length === 1)
+    return nav.tableAlias;
+
+  const startIndex = path.indexOf(nav.item);
+  if (startIndex === -1)
+    return null;
+
+  // navigation is already at last path step
+  if (startIndex === path.length - 1) {
+    return nav.navigation?.kind === '$navElement'
+      ? nav.navigation._parent
+      : nav.tableAlias;
+  }
+
+  let navItem = nav.navigation || nav.tableAlias;
+  for (let i = startIndex + 1; i < path.length - 1; ++i) {
+    const item = path[i];
+    navItem = item?.id && navItem.elements?.[item.id];
+    if (!navItem)
+      return null;
+  }
 
-  return proj || { index: startIndex, item: path[startIndex], elem: null };
+  return navItem;
 }
 
 /**

package/lib/compiler/utils.js

@@ -607,7 +607,7 @@ function pathStartsWithSelf( ref ) {
 }
 
 function columnRefStartsWithSelf( col ) {
-  for (; col; col = col._pathHead) {
+  for (; col; col = col._columnParent) {
     const ref = col.value;
     const head = ref && !ref.scope && ref.path?.[0];
     if (head?._navigation?.kind === '$self')