@sap/cds-compiler 5.7.4 → 5.8.2

package/lib/compiler/shared.js

@@ -319,6 +319,7 @@ function fns( model ) {
 
   Object.assign( model.$functions, {
     traverseExpr,
+    traverseTypedExpr,
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked, // TODO: move to some other file
     resolvePathRoot,
@@ -330,28 +331,263 @@ function fns( model ) {
     nestedElements,
     attachAndEmitValidNames,
   } );
+  traverseExpr.STOP = Symbol( 'STOP' );
+  traverseExpr.SKIP = Symbol( 'SKIP' );
+  traverseTypedExpr.STOP = traverseExpr.STOP;
+  traverseTypedExpr.SKIP = traverseExpr.SKIP;
   return;
 
   // Expression traversal function ----------------------------------------------
+
+  /**
+   * Recursively traverse the expression `expr` and call `callback` on the expression nodes.
+   *
+   * …
+   *
+   * Sub queries are not further traversed, but `callback` is called on the
+   * expression node having the property `query`.
+   *
+   * Callbacks can influence the traversal by returning a symbol:
+   *
+   *  - `traverseExpr.STOP`: the traversal is stopped immediately
+   *  - `traverseExpr.SKIP` on a node with a `path` property: the path items
+   *    with its filters and arguments are not traversed
+   *  - `traverseExpr.SKIP` on a path item: the expression in the `where`
+   *    condition is not traversed
+   */
   function traverseExpr( expr, exprCtx, user, callback ) {
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
       return null;
 
-    if (expr.path) {
-      // TODO: move arguments and filter traversal to here
-      return callback( expr, exprCtx, user );
+    let exit = null;
+    // `type` property for `cast, `query` for sub query
+    if (expr.path || expr.type || expr.query) {
+      exit = callback( expr, exprCtx, user );
+      if (exit === traverseExpr.STOP)
+        return exit;
     }
-    let first = (expr.type || expr.query) && callback( expr, exprCtx, user );
-
-    if (expr.args && !first) {
+    if (expr.path && exit !== traverseExpr.SKIP) {
+      for (const step of expr.path) {
+        if (step && (step.args || step.where || step.cardinality) &&
+            traversePathItem( step, exprCtx, user, callback ))
+          return traverseExpr.STOP;
+      }
+    }
+    if (expr.args) {
       const args = Array.isArray( expr.args ) ? expr.args : Object.values( expr.args );
-      // TODO: re-think $expected
-      first = args.find( e => traverseExpr( e, exprCtx, user, callback ) );
+      for (const arg of args ) {
+        if (traverseExpr( arg, exprCtx, user, callback ) === traverseExpr.STOP)
+          return traverseExpr.STOP;
+      }
+    }
+    if (expr.suffix) {
+      for (const arg of expr.suffix) {
+        if (traverseExpr( arg, exprCtx, user, callback ) === traverseExpr.STOP)
+          return traverseExpr.STOP;
+      }
+    }
+    return false;
+  }
+
+  function traversePathItem( step, exprCtx, user, callback ) {
+    const exit = callback( step, exprCtx, user );
+    if (exit === traverseExpr.STOP)
+      return true;
+    if (step.where && exit !== traverseExpr.SKIP &&
+        traverseExpr( step.where,
+                      // TODO: use property in fn dictionary above
+                      ( exprCtx === 'calc' || exprCtx === 'calc-filter'
+                        ? 'calc-filter'
+                        : 'filter' ),
+                      step, callback ) === traverseExpr.STOP)
+      return true;
+    if (step.args) {
+      const ctx = (exprCtx === 'from') ? 'from-args' : exprCtx;
+      const args = Array.isArray( step.args ) ? step.args : Object.values( step.args );
+      // TODO: there should be no array `args` on path item
+      for (const arg of args) {
+        if (traverseExpr( arg, ctx, user, callback ) === traverseExpr.STOP)
+          return true;
+      }
+    }
+    return false;
+  }
+
+  // Special expression traversal function for `resolveExpr`.  Let's see
+  // later whether we can use this version as the general one.
+  // If we continue to have separate ones, remove the STOP stuff – it is not
+  // needed for `resolveExpr`.
+
+  function traverseTypedExpr( expr, exprCtx, user, type, callback ) {
+    if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
+      return null;
+
+    let { args } = expr;
+    let exit = null;
+    // `type` property for `cast, `query` for sub query
+    if (expr.path || expr.type || expr.sym || expr.query) {
+      exit = callback( expr, exprCtx, user, type );
+      if (exit === traverseExpr.STOP)
+        return exit;
+      // `args` with `cast` function
+    }
+    else if (!args) {
+      // empty on purpose
+    }
+    else if (expr.func) {
+      if (!Array.isArray( args ))
+        args = Object.values( args );
+    }
+    else if (expr.op?.val === 'list' || args.length === 1) {
+      exit = type;
+    }
+    else if (expr.op?.val === '?:') {
+      args = traverseChoiceArgs( args, exprCtx, user, type, callback );
+      exit = type;
+    }
+    else {
+      args = traverseSpecialArgs( args, exprCtx, user, type, callback );
+    }
+
+    if (expr.path && exit !== traverseExpr.SKIP) {
+      for (const step of expr.path) {
+        if (step && (step.args || step.where || step.cardinality) &&
+            traverseTypedPathItem( step, exprCtx, user, callback ))
+          return traverseExpr.STOP;
+      }
+    }
+    if (expr.args) {
+      if (!args)
+        return traverseExpr.STOP;
+      for (const arg of args) {
+        if (traverseTypedExpr( arg, exprCtx, user, exit, callback ) === traverseExpr.STOP)
+          return traverseExpr.STOP;
+      }
     }
+    if (expr.suffix) {
+      for (const arg of expr.suffix) {
+        if (traverseTypedExpr( arg, exprCtx, user, null, callback ) === traverseExpr.STOP)
+          return traverseExpr.STOP;
+      }
+    }
+    return exit;
+  }
+
+  /**
+   * Traverse arguments `args` if they match a specific pattern:
+   *
+   * - a (sub) expression is a comparison, i.e. uses one of the binary operators
+   *   `=`, `<>`, `!=`, `in` or `not in`,
+   * - one side of the comparison is a reference or a `cast` function call when
+   *   typed with an enum type,
+   * - the other side is a enum reference, an enum reference in parentheses, or a
+   *   list of enum references.
+   *
+   * Return an array of the arguments which are to be traversed normally, or
+   * `null` if the traversal is stopped immediately
+   */
+  function traverseSpecialArgs( args, exprCtx, user, type, callback ) {
+    if (args.length <= 3) {
+      if (args.length === 3 && args[1].literal === 'token' &&
+          [ '=', '<>', '!=', 'in' ].includes( args[1].val ))
+        return traverseComparison( args[0], args[2], exprCtx, user, callback );
+    }
+    else if (args[0].val === 'case' && args[0].literal === 'token') {
+      return traverseCaseWhen( args, exprCtx, user, type, callback );
+    }
+    else if (args.length === 4 && args[1].val === 'not' && args[2].val === 'in' &&
+             args[1].literal === 'token' && args[2].literal === 'token') {
+      return traverseComparison( args[0], args[3], exprCtx, user, callback );
+    }
+    return args;
+  }
+
+  function traverseComparison( left, right, exprCtx, user, callback ) {
+    if (!left || !right)          // can happen in old parser
+      return [ left || right ];
+    if (left.path || left.type) { // ref or cast fn
+      const type = traverseTypedExpr( left, exprCtx, user, null, callback );
+      if (type === traverseExpr.STOP ||
+          traverseTypedExpr( right, exprCtx, user, type, callback ) === traverseExpr.STOP)
+        return null;
+      return [];
+    }
+    if (right.path || right.type) { // ref or cast fn
+      const type = traverseTypedExpr( right, exprCtx, user, null, callback );
+      if (type === traverseExpr.STOP ||
+          traverseTypedExpr( left, exprCtx, user, type, callback ) === traverseExpr.STOP)
+        return null;
+      return [];
+    }
+    return [ left, right ];
+  }
+
+  // for '?:' operator, only via CDL (translates to `case…when` in CSN):
+  function traverseChoiceArgs( args, exprCtx, user, type, callback ) {
+    if (traverseTypedExpr( args[0], exprCtx, user, null, callback ) === traverseExpr.STOP)
+      return null;
+    return args.slice( 1 );
+    // TODO: adopt if we extend this to ?:?:…
+  }
+
+  function traverseCaseWhen( args, exprCtx, user, type, callback ) {
+    let idx = 1;
+    let when = null;
+    let node = args[1];
+    // For `CASE <expr> WHEN <…> THEN <…>`
+    if (node?.val !== 'when' || node.literal !== 'token') {
+      when = traverseTypedExpr( node, exprCtx, user, null, callback );
+      if (when === traverseExpr.STOP)
+        return null;
+      ++idx;
+    }
+    // Remark: no need to test `literal` in the following - ensured by CDL and CSN
+    // parser
+    while (args[idx]?.val === 'when' && ++idx < args.length) {
+      node = args[idx];
+      // be robust against corrupted sources:
+      if ((node.literal !== 'token' || ![ 'then', 'when', 'end' ].includes( node.val )) &&
+          traverseTypedExpr( args[idx++], exprCtx, user, when, callback ) === traverseExpr.STOP)
+        return null;
 
-    first ??= expr.suffix &&    // fn( … ) OVER …
-      expr.suffix.find( e => traverseExpr( e, exprCtx, user, callback ) );
-    return first;
+      if (args[idx]?.val !== 'then')
+        continue;
+      node = args[++idx];
+      if (node &&
+          (node.literal !== 'token' || node.val !== 'when' && node.val !== 'end') &&
+          traverseTypedExpr( args[idx++], exprCtx, user, type, callback ) === traverseExpr.STOP)
+        return null;
+    }
+    if (args[idx]?.val === 'else') {
+      if (++idx < args.length &&
+          traverseTypedExpr( args[idx], exprCtx, user, type, callback ) === traverseExpr.STOP)
+        return null;
+    }
+    return [];
+  }
+
+  function traverseTypedPathItem( step, exprCtx, user, callback ) {
+    const exit = callback( step, exprCtx, user, null );
+    if (exit === traverseExpr.STOP)
+      return true;
+    if (step.where && exit !== traverseExpr.SKIP &&
+        traverseTypedExpr( step.where,
+                           // TODO: use property in fn dictionary above
+                           ( exprCtx === 'calc' || exprCtx === 'calc-filter'
+                             ? 'calc-filter'
+                             : 'filter' ),
+                           step, null, callback ) === traverseExpr.STOP)
+      return true;
+    if (step.args) {
+      const ctx = (exprCtx === 'from') ? 'from-args' : exprCtx;
+      const args = Array.isArray( step.args ) ? step.args : Object.values( step.args );
+      // TODO: there should be no array `args` on path item
+      for (const arg of args) {
+        if (traverseTypedExpr( arg, ctx, user, arg.name, callback ) === traverseExpr.STOP)
+          return true;
+      }
+    }
+    return false;
   }
 
   // Return absolute name for unchecked path `ref`.  We first try searching for
@@ -740,7 +976,8 @@ function fns( model ) {
       case '$tableAlias': {
         // use a source element having that name if in `extend … with columns`:
         const { $extended } = user._user || user;
-        const elem = $extended && art.elements[head.id];
+        // if query source has duplicates, table alias has no elements
+        const elem = $extended && art.elements?.[head.id];
         if (elem) {
           path.$prefix = art.name.id; // prepend alias name
           info( 'ref-special-in-extend', [ head.location, user ],
@@ -748,7 +985,7 @@ function fns( model ) {
           setLink( head, '_navigation', elem );
           return setArtifactLink( head, elem._origin );
         }
-        else if ($extended) {
+        else if ($extended && art.elements) {
           warning( 'ref-deprecated-in-extend', [ head.location, user ], { id: head.id },
                    // eslint-disable-next-line @stylistic/js/max-len
                    'In an added column, do not use the table alias $(ID) to refer to source elements' );
@@ -783,7 +1020,7 @@ function fns( model ) {
       }
       case 'builtin': {
         if (art.name.id === '$at') {
-          warning( 'ref-deprecated-variable', [ head.location, user ],
+          message( 'ref-deprecated-variable', [ head.location, user ],
                    { code: '$at', newcode: '$valid' },
                    '$(CODE) is deprecated; use $(NEWCODE) instead' );
         }
@@ -1394,21 +1631,30 @@ function fns( model ) {
     const { path, scope } = ref;
     // see getPathItem(): how many path items are for the main artifact ref?
     const artItemsCount = (typeof scope === 'number' && scope) || (scope ? 1 : path.length);
+
     // at least the last main definition should be an entity or an
-    // event (if the user is also an event)
+    // event (if the user is an event) or type (if the user is a type)
     // an additional check for target would need effectiveType()
     const source = path[artItemsCount - 1]._artifact;
-    const variant = (user._main.kind === 'event') ? 'event' : 'std';
-    if (source.kind !== 'entity' && !acceptEventProjectionSource( source, user )) {
-      signalNotFound( 'ref-invalid-source', [ ref.location, user ], null, { '#': variant } );
-      return false;
+    if (user._main?.kind === 'type') {
+      if (!acceptTypeProjectionSource( source )) {
+        signalNotFound( 'ref-invalid-source', [ ref.location, user ], null,
+                        { '#': 'type' } );
+        return (source === art) ? art : false; // art to show cyclic issues
+      }
+    }
+    else if (source.kind !== 'entity' &&
+        !acceptEventProjectionSource( source, user )) {
+      signalNotFound( 'ref-invalid-source', [ ref.location, user ], null,
+                      { '#': user._main.kind } );
+      return (source === art) ? art : false; // art to show cyclic issues
     }
     if (source === art)
       return art;
     const assoc = Functions.effectiveType( art );
     if (assoc.target)
       return art;               // TODO: use target here
-    signalNotFound( 'ref-invalid-source', [ ref.location, user ], null, { '#': variant } );
+    signalNotFound( 'ref-invalid-source', [ ref.location, user ], null, { '#': user._main.kind } );
     return false;
   }
 
@@ -1422,6 +1668,12 @@ function fns( model ) {
     return (kind === 'entity' || kind === 'event' || (kind === 'type' && effectiveType.elements));
   }
 
+  function acceptTypeProjectionSource( source ) {
+    // We require the projection source to be structured.
+    // TODO: Also allow all associations?
+    return Functions.effectiveType( source )?.elements;
+  }
+
   function acceptTypeOrElement( art, user, ref ) { // for type
     // was ['action', 'function'].includes( user._parent?.kind ))
     while (user._outer)
@@ -1475,8 +1727,10 @@ function fns( model ) {
     const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
     const checkFn = semantics.check; // || !semantics.isMainRef && checkElementStd;
 
-    if (checkFn)
-      traverseExpr( expr, exprCtx, user, checkFn );
+    if (checkFn) {
+      traverseExpr( expr, exprCtx, user,
+                    ( ...args ) => (checkFn( ...args ) ? traverseExpr.STOP : traverseExpr.SKIP) );
+    }
   }
 
   // TODO: Don't allow path args and filter!

package/lib/compiler/tweak-assocs.js

@@ -43,6 +43,7 @@ function tweakAssocs( model ) {
     mergeSpecifiedForeignKeys,
     navigationEnv,
     redirectionChain,
+    resolveExprInAnnotations,
   } = model.$functions;
 
   Object.assign(model.$functions, {
@@ -245,8 +246,13 @@ function tweakAssocs( model ) {
     doRewriteAssociation( element );
     if (element.target) {
       extendForeignKeys( element );
-      if (element.foreignKeys$)
+      if (element.foreignKeys$) {
+        // TODO: Also checkSpecifiedElement?
         mergeSpecifiedForeignKeys( element );
+      }
+      for (const key in element.foreignKeys)
+        // TODO: This will re-evaluate all annotations
+        resolveExprInAnnotations( element.foreignKeys[key] );
     }
   }
 
@@ -435,7 +441,10 @@ function tweakAssocs( model ) {
     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, navEnv ) );
+                    ( expr ) => {
+                      rewriteExpr( expr, elem, nav.tableAlias, navEnv );
+                      return traverseExpr.SKIP; // TODO: really necessary?
+                    } );
     }
     else if (elem._columnParent) {
       error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
@@ -461,6 +470,7 @@ function tweakAssocs( model ) {
     function removeArtifactLinks() {
       traverseExpr( elem.on, 'rewrite-on', elem, (expr) => {
         setArtifactLink( expr, null );
+        return traverseExpr.SKIP; // TODO: necessary?
       } );
     }
   }
@@ -556,11 +566,11 @@ function tweakAssocs( model ) {
     const navEnv = nav && followNavigationPath( elem.value?.path, nav ) || nav?.tableAlias;
     traverseExpr( cond, 'rewrite-filter', elem, (expr) => {
       if (!expr.path || expr.path.length === 0)
-        return;
+        return traverseExpr.SKIP;
 
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
       if (!root)
-        return; // only for compile error, e.g. missing definition
+        return traverseExpr.SKIP; // only for compile error, e.g. missing definition
       if (root.kind === '$self') {
         // $projection -> $self for recompilability
         expr.path[0].id = '$self';
@@ -579,6 +589,7 @@ function tweakAssocs( model ) {
         // up to here, filter is relative to original association
         rewriteExpr( expr, elem, nav?.tableAlias, navEnv );
       }
+      return traverseExpr.SKIP;
     } );
 
     checkOnCondition( cond, 'on', elem );

package/lib/compiler/xpr-rewrite.js

@@ -160,10 +160,10 @@ class AnnoRewriteConfig {
   target;
   targetRoot;
   origin;
-  isViaType;
-  isViaCalcElement;
-  viaExpand;
-  viaExpandType;
+  fromTargetType;
+  fromCalcElement;
+  expandedRoot;
+  expandedRootType;
   isInFilter;
   tokenExpr;
 }
@@ -217,21 +217,26 @@ function xprRewriteFns( model ) {
     if (!anno.kind || anno.$invalidPaths)
       return;
 
-    const isViaType = target.type?._artifact === origin;
-    const [ viaExpand, viaExpandType ] = !isViaType && getExpandRoot( target ) || [ null, null ];
-    const isViaCalcElement = !isViaType && target.$calcDepElement &&
+    // Annotation comes from the target's type.  That's important to know, because
+    // path prefixes need to be adapted.
+    const fromTargetType = target.type?._artifact === origin;
+    // Annotation comes from the target's calculated element.  A special case propagation rule, e.g
+    // for `calcString: String = str;`.  We also need to adapt path prefixes.
+    const fromCalcElement = !fromTargetType && target.$calcDepElement &&
       target.value?._artifact === origin;
 
+    const { expandedRoot, expandedRootType } = !fromTargetType && getExpandRoot( target ) || {};
+
     const config = {
       __proto__: AnnoRewriteConfig.prototype,
       anno: annoName,
       target,
       targetRoot: annoRootArt( target ),
       origin,
-      isViaType,
-      isViaCalcElement,
-      viaExpand,
-      viaExpandType,
+      fromTargetType,
+      fromCalcElement,
+      expandedRoot,
+      expandedRootType,
     };
 
     const hasError = rewriteAnnotationExpr( target[annoName], config );
@@ -259,10 +264,10 @@ function xprRewriteFns( model ) {
     else if (expr.$tokenTexts) {
       // used to set `$tokenText` to true in case of rewritten annotation
       config.tokenExpr = expr;
-      return !!traverseExpr(
+      return traverseExpr.STOP === traverseExpr(
         expr, 'annoRewrite', config.target,
-        (e, refCtx) => rewriteAnnoExpr( e, config, refCtx )
-      );
+        // eslint-disable-next-line @stylistic/js/max-len, @stylistic/js/function-paren-newline
+        (e, refCtx) => (rewriteAnnoExpr( e, config, refCtx ) ? traverseExpr.STOP : traverseExpr.SKIP) );
     }
     return false;
   }
@@ -285,15 +290,22 @@ function xprRewriteFns( model ) {
       root._parent.kind !== 'function'))
       return reportAnnoRewriteError( expr, config, 'unsupported' );
 
+    if (root.kind === 'key') {
+      // Foreign keys can't be renamed and since we don't have absolute references to foreign keys,
+      // i.e. `$self.assoc.target_id` always refers to the target side, we don't have to rewrite
+      // them.
+      return null;
+    }
+
     // magic variables / replacement variables are never rewritten; they can't
     // have filters nor can they point to elements.
     if (expr._artifact?.kind === 'builtin')
       return null;
 
     let hasError = false;
-    if (config.isViaType || config.isViaCalcElement)
+    if (config.fromTargetType || config.fromCalcElement)
       hasError = adaptPathPrefixViaType( expr, config );
-    else if (config.viaExpand)
+    else if (config.expandedRoot)
       hasError = adaptPathPrefixViaTypeExpansion( expr, config );
 
     hasError ||= rewriteGenericAnnoPath( expr, config, refCtx );
@@ -309,8 +321,11 @@ function xprRewriteFns( model ) {
         const assocTarget = step._artifact.target._artifact;
         if (target) {
           const filterConfig = { ...config, target: assocTarget, isInFilter: true };
-          if (traverseExpr( step.where, 'filter', step,
-            (e, ctx) => expr.path && rewriteGenericAnnoPath( e, filterConfig, ctx )))
+          if (traverseExpr.STOP === traverseExpr(
+            step.where, 'filter', step,
+            // eslint-disable-next-line @stylistic/js/max-len
+            (e, ctx) => expr.path && (rewriteGenericAnnoPath( e, filterConfig, ctx ) ? traverseExpr.STOP : traverseExpr.SKIP)
+          ))
             return true;
         }
         else {
@@ -490,7 +505,7 @@ function xprRewriteFns( model ) {
     config.tokenExpr.$tokenTexts = true;
 
     const wasAbsolute = isAnnoPathAbsolute( expr );
-    stripPrefixToNewRoot( expr, target, origin );
+    stripAbsolutePathPrefix( expr, origin );
 
     if (wasAbsolute) {
       prependRootPath( origin, target, expr );
@@ -519,28 +534,28 @@ function xprRewriteFns( model ) {
       return false;
     }
 
-    // $self-paths via type expansion always need to be rewritten.
-    config.tokenExpr.$tokenTexts = true;
-
-    const { target } = config;
     // We reject $self-paths because they need to be rewritten.
     // However, with a special flag, we allow rewriting it for testing purposes.
     if (!isBetaEnabled( model.options, 'rewriteAnnotationExpressionsViaType' ))
       return reportAnnoRewriteError( expr, config, 'unsupported' );
 
-    if (rejectOuterReference( expr, config.viaExpandType, config ))
+    if (rejectOuterReference( expr, config.expandedRootType, config ))
       return true;
 
-    stripPrefixToNewRoot( expr, target, config.viaExpandType );
-    prependRootPath( config.viaExpandType, config.viaExpand, expr );
-    setExpandStatusAnnotate( target, 'annotate' );
+    stripAbsolutePathPrefix( expr, config.expandedRootType );
+    prependRootPath( config.expandedRootType, config.expandedRoot, expr );
+    setExpandStatusAnnotate( config.target, 'annotate' );
+
     config.target[config.anno].$inferred = 'anno-rewrite';
+    // $self-paths via type expansion always need to be rewritten.
+    config.tokenExpr.$tokenTexts = true;
+
     return false;
   }
 
   /**
    * Prepend a path to `expr.path` or replace the root item.
-   * The path needs to have been run through exprstripPrefixToNewRoot(…)`.
+   * The path needs to have been run through stripPrefixToNewRoot(…)`.
    * It is prepended if the root item is not the origin.
    * Replaced otherwise.
    *
@@ -559,15 +574,14 @@ function xprRewriteFns( model ) {
 
   /**
    * Strips a prefix path from `expr.path`.  The prefix is defined
-   * by where `newRootArt` appears in the path.
+   * by where `art` appears in the path.
    *
    * @param {XSN.Expression} expr
-   * @param {XSN.Artifact} target
-   * @param {XSN.Artifact} newRootArt
+   * @param {XSN.Artifact} art
    */
-  function stripPrefixToNewRoot( expr, target, newRootArt ) {
-    const relativeRoot = findRelativeRoot( expr, newRootArt );
-    if (relativeRoot === -1 && isAnnoRootArt( newRootArt ))
+  function stripAbsolutePathPrefix( expr, art ) {
+    const relativeRoot = findRelativeRoot( expr, art );
+    if (relativeRoot === -1 && isAnnoRootArt( art ))
       return; // no $self; root item is element
     if (relativeRoot >= 1)
       expr.path = expr.path.slice(relativeRoot);
@@ -614,17 +628,17 @@ function xprRewriteFns( model ) {
    * Returns -1 if `origin` isn't found in the path.
    *
    * @param {XSN.Expression} expr
-   * @param {XSN.Artifact} newRootArt
+   * @param {XSN.Artifact} origin
    * @returns {number}
    */
-  function findRelativeRoot( expr, newRootArt ) {
-    if (!newRootArt._main) // main artifacts can't have outer references
-      return expr.path[0]?._artifact === newRootArt ? 0 : -1;
+  function findRelativeRoot( expr, origin ) {
+    if (!origin._main) // main artifacts can't have outer references
+      return expr.path[0]?._artifact === origin ? 0 : -1;
 
     const { path } = expr;
     for (let i = 0; i < path.length; ++i) {
       const item = path[i];
-      if (item._artifact === newRootArt)
+      if (item._artifact === origin)
         return i;
     }
     return -1;
@@ -738,21 +752,33 @@ function isReturnParam( art ) {
 }
 
 /**
- * Returns the target's parent which is expanded and the type from which the elements originate.
+ * Gets the artifact (e.g. element) that was expanded. `target` 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
- * @returns {[XSN.Artifact, XSN.Artifact]}
+ * @returns { {expandedRoot: XSN.Artifact, expandedRootType: XSN.Artifact}}
  */
 function getExpandRoot( target ) {
-  let viaExpand = target;
-  while (viaExpand.$inferred === 'expanded')
-    viaExpand = viaExpand._parent;
-  const viaExpandType = viaExpand
-    ? (viaExpand.type?._artifact || viaExpand.items?.type?._artifact)
-    : null;
-  const viaInclude = viaExpand?.$inferred === 'include' || false;
-  viaExpand = !viaInclude && viaExpandType ? viaExpand : false;
-  return [ viaExpand, viaExpandType ];
+  if (target.$inferred !== 'expanded' && target.$inferred !== 'rewrite')
+    return { expandedRoot: null, expandedRootType: null };
+
+  let expandedRoot = target;
+
+  // 'expanded' for structures, 'rewrite' for foreign keys
+  while (expandedRoot.$inferred === 'expanded' || expandedRoot.$inferred === 'rewrite')
+    expandedRoot = expandedRoot._parent;
+
+  // `items` may be inferred via a type, hence why we check `items.type` after `type`
+  let expandedRootType = expandedRoot?.type || expandedRoot?.items?.type;
+  expandedRootType = (!expandedRootType?.$inferred && expandedRootType?._artifact) || null;
+
+  const viaInclude = expandedRoot?.$inferred === 'include';
+  expandedRoot = !viaInclude && expandedRootType ? expandedRoot : false;
+
+  return { expandedRoot, expandedRootType };
 }
 
 module.exports = {