@sap/cds-compiler 6.3.6 → 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;
 }
 
@@ -181,71 +180,87 @@ function xprRewriteFns( model ) {
 
   return {
     rewriteAnnotationsRefs,
+    rewriteRefsInExpression,
   };
 
   /**
+   * 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 error('anno-missing-rewrite', [
-      weakLocation( config.target.location ), config.target,
-    ], {
-      '#': variant,
-      anno: config.anno,
-      art: config.origin,
-      elemref: expr,
-    });
+    if (config.tokenExpr) {
+      error( 'anno-missing-rewrite', [
+        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;
 
-    // Annotation comes from the target's type.  That's important to know, because
+    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
+  }
+
+  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 = target.type?._artifact === origin;
-    // Annotation comes from the target's calculated element.  A special case propagation rule, e.g
+    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 && target.$calcDepElement &&
-      target.value?._artifact === origin;
+    const fromCalcElement = !fromDestinationType && destination.$calcDepElement &&
+      destination.value?._artifact === origin;
 
-    const { expandedRoot, expandedRootType } = !fromTargetType && getExpandRoot( target ) || {};
+    const { expandedRoot, expandedRootType }
+      = !fromDestinationType && getExpandRoot( destination ) || {};
 
     const config = {
       __proto__: AnnoRewriteConfig.prototype,
-      anno: annoName,
-      target,
-      targetRoot: annoRootArt( target ),
+      anno: propName,
+      destination,
+      destinationRoot: annoRootArt( destination ),
       origin,
-      fromTargetType,
+      fromDestinationType,
       fromCalcElement,
       expandedRoot,
       expandedRootType,
     };
 
-    const hasError = rewriteAnnotationExpr( target[annoName], config );
-    target.$contains ??= {};
-    target.$contains.$annotation ??= {};
-    target.$contains.$annotation.$path ||= origin.$contains.$annotation.$path;
-    target.$contains.$annotation.$self ||= origin.$contains.$annotation.$self;
-    if (hasError)
-      anno.$invalidPaths = true; // avoid subsequent errors
+    if (propName.charAt( 0 ) === '@')
+      return rewriteAnnotationExpr( destination[propName], config );
+    return traverseExpr( destination[propName], 'annoRewrite', destination,
+                         rewriteAnnoExpr.bind( config ) );
   }
 
   /**
@@ -264,36 +279,37 @@ 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') {
-      // 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.
+      // 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 via `annotate`. (Even as annotation value for
+      // foreign keys, `$self.assoc.target_id` always refers to the target side.)
       return null;
     }
 
@@ -303,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)
@@ -341,53 +335,53 @@ function xprRewriteFns( model ) {
       // only understand the string representation.  But we only do so for simple strings, which
       // is the case if this path expression has $tokenTexts. It then is of the form `@a: (path)`.
       const isSimpleStep = step => !step.where && !step.args && isSimpleCdlIdentifier( step.id );
-      if (expr.path.every(isSimpleStep))
-        expr.$tokenTexts = expr.path.map( step => step.id ).join('.');
+      if (expr.path.every(isSimpleStep)) {
+        expr.$tokenTexts = (expr.scope === 'param' ? ':' : '') +
+                            expr.path.map( step => step.id ).join('.');
+      }
     }
 
     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)
@@ -395,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 );
@@ -437,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 );
     }
@@ -454,8 +446,10 @@ function xprRewriteFns( model ) {
 
     for (let i = startIndex; i < expr.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.
+        // 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 = expr.path[i - 1]?._originalArtifact?.target?._artifact;
         const chain = cachedRedirectionChain( art, origTarget );
@@ -476,48 +470,50 @@ 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;
   }
 
   /**
-   * Rewrite an expression that came via type propagation.
+   * Rewrite the initial part of a path in an expression that came via type
+   * propagation or via propagation with ref-only calculated element.
    *
-   * @returns {boolean} Returns the expression if it couldn't be rewritten.
+   * @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.
-    config.tokenExpr.$tokenTexts = true;
+    if (config.tokenExpr)
+      config.tokenExpr.$tokenTexts = true;
 
     const wasAbsolute = isAnnoPathAbsolute( expr );
     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, [ ] );
@@ -526,7 +522,16 @@ function xprRewriteFns( model ) {
     return false;
   }
 
-  function adaptPathPrefixViaTypeExpansion( expr, config ) {
+  /**
+   * Rewrite the initial part of a path in an expression starting with $self on an
+   * expanded element:
+   *
+   *  - nothing to do when not starting with $self (TODO: param?)
+   *  - otherwise error if options.beta.rewriteAnnotationExpressionsViaType is not set
+   *
+   * @returns {boolean} Returns true if it couldn't be rewritten.
+   */
+  function adaptPathPrefixViaTypeExpansion( expr, config, user ) {
     const root = expr.path[0]?._navigation;
     if (root?.kind !== '$self') {
       // non-self paths are always valid in expanded artifacts
@@ -539,16 +544,17 @@ 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.
-    config.tokenExpr.$tokenTexts = true;
+    if (config.tokenExpr)
+      config.tokenExpr.$tokenTexts = true;
 
     return false;
   }
@@ -586,36 +592,33 @@ function xprRewriteFns( model ) {
     if (relativeRoot >= 1)
       expr.path = expr.path.slice(relativeRoot);
     else if (relativeRoot === -1)
-      throw new CompilerAssertion('Error while rewriting annotation');
+      throw new CompilerAssertion( 'Error while rewriting annotation' );
   }
 
   /**
-   * 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 );
@@ -632,7 +635,7 @@ function xprRewriteFns( model ) {
    * @returns {number}
    */
   function findRelativeRoot( expr, origin ) {
-    if (!origin._main) // main artifacts can't have outer references
+    if (!origin._main) // main artifacts can't have outer references: $self → 0, -1 otherwise
       return expr.path[0]?._artifact === origin ? 0 : -1;
 
     const { path } = expr;
@@ -689,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;
@@ -703,7 +706,8 @@ function xprRewriteFns( model ) {
     const item = expr.path[index];
     if (item.id !== found.name.id || (rewriteTarget[1] - index) !== 0) {
       // Path was rewritten; original token text string is no longer accurate
-      config.tokenExpr.$tokenTexts = true;
+      if (config.tokenExpr)
+        config.tokenExpr.$tokenTexts = true;
       item.id = found.name.id;
     }
 
@@ -752,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')