@sap/cds-compiler 6.4.2 → 6.5.0

package/lib/compiler/utils.js

@@ -134,6 +134,28 @@ function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDepreca
   }
 }
 
+// Initialization (define.js), shared with extend.js: ---------------------------
+
+/**
+ * Initialize artifact links inside `obj.items` (for nested ones as well).
+ * Does nothing, it `obj.items` does not exist.
+ *
+ * @param {XSN.Artifact} obj
+ * @param {object} block
+ * @return {XSN.Artifact}
+ */
+function initItemsLinks( obj, block ) {
+  let { items } = obj;
+  while (items) {
+    setLink( items, '_outer', obj );
+    setLink( items, '_parent', obj._parent );
+    setLink( items, '_block', block );
+    obj = items;
+    items = obj.items;
+  }
+  return obj;
+}
+
 /**
  * Set the member `elem` to have a _parent link to `parent` and a corresponding
  * _main link.  Also set the member's name accordingly, where argument `name`
@@ -162,6 +184,76 @@ function createAndLinkCalcDepElement( elem ) {
   setLink( r, '_outer', elem );
 }
 
+function initExprAnnoBlock( art, block ) {
+  // remark: `art` could also be the extension
+  for (const prop in art) {
+    if (prop.charAt(0) !== '@')
+      continue;
+    const anno = art[prop];
+    // _block links needed for `cast( … as Type )`, `[ ..., cast( … as Type ) ]`
+    if (anno.literal === 'array') {
+      anno.kind = '$annotation';
+      for (const item of anno.val)
+        setLink( item, '_block', block );
+    }
+    else if (anno.$tokenTexts) {
+      // remark: it wouldn't hurt to set it always...
+      anno.kind = '$annotation';
+      setLink( anno, '_block', block );
+    }
+  }
+}
+
+function initDollarSelf( art ) {
+  // TODO: use setMemberParent() ?
+  const self = {
+    name: { id: '$self', location: art.location },
+    kind: '$self',
+    location: art.location,
+  };
+  setLink( self, '_parent', art );
+  setLink( self, '_main', art ); // used on main artifact
+  setLink( self, '_origin', art );
+  art.$tableAliases = Object.create( null );
+  art.$tableAliases.$self = self;
+}
+
+function initDollarParameters( art ) {
+  // TODO: use setMemberParent() ?
+  const parameters = {
+    name: { id: '$parameters' },
+    kind: '$parameters',
+    location: art.location,
+    deprecated: true, // hide in code completion
+  };
+  setLink( parameters, '_parent', art );
+  setLink( parameters, '_main', art );
+  // Search for :const after :param.  If there will be a possibility in the
+  // future that we can extend <query>.columns, we must be sure to use
+  // _block of that new column after :param (or just allow $parameters there).
+  setLink( parameters, '_block', art._block );
+  if (art.params) {
+    parameters.elements = art.params;
+    parameters.$tableAliases = art.params; // TODO: find better name - $lexical?
+  }
+  art.$tableAliases.$parameters = parameters;
+}
+
+function initBoundSelfParam( params, main ) {
+  if (!params)
+    return;
+  const first = params[Object.keys( params )[0] || ''];
+  const type = first?.type || first?.items?.type; // this sequence = no derived type
+  const path = type?.path;
+  if (path?.length === 1 && path[0]?.id === '$self') { // TODO: no where: ?
+    const $self = main.$tableAliases?.$self ||
+      main.kind === 'extend' && { name: { id: '$self' } };
+    // remark: an 'extend' has no "table alias" `$self` (relevant for parse-cdl)
+    setLink( type, '_artifact', $self );
+    setLink( path[0], '_artifact', $self );
+  }
+}
+
 /**
  * Adds a dependency user -> art with the given location.
  *
@@ -702,8 +794,13 @@ module.exports = {
   proxyCopyMembers,
   dependsOn,
   dependsOnSilent,
+  initItemsLinks,
   setMemberParent,
   createAndLinkCalcDepElement,
+  initExprAnnoBlock,
+  initDollarSelf,
+  initDollarParameters,
+  initBoundSelfParam,
   storeExtension,
   withAssociation,
   pathName,

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,36 @@ 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) }`);
+    if (isSimpleSelectItem && model.options.testMode &&
+        destination.value?.path[0]._navigation?.kind !== 'mixin')
+      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 +430,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 +471,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 +489,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 +505,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 +532,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 +545,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 +597,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 +693,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 +757,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')