@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/populate.js

@@ -41,14 +41,15 @@ const {
   linkToOrigin,
   setMemberParent,
   proxyCopyMembers,
-  dependsOn,
   setExpandStatus,
   setExpandStatusAnnotate,
+  dependsOnSilent,
+  columnRefStartsWithSelf,
 } = require('./utils');
 const { typeParameters } = require('./builtins');
 
-const $inferred = Symbol.for('cds.$inferred');
-const $location = Symbol.for('cds.$location');
+const $inferred = Symbol.for( 'cds.$inferred' );
+const $location = Symbol.for( 'cds.$location' );
 
 /**
  * These properties are copied from specified elements.
@@ -73,6 +74,7 @@ function populate( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    nestedElements,
     attachAndEmitValidNames,
     initArtifact,
     extendArtifactBefore,
@@ -81,8 +83,7 @@ function populate( model ) {
   Object.assign( model.$functions, {
     effectiveType,
     getOrigin,
-    resolveType,
-    navigationEnv,
+    getInheritedProp,
   } );
   // let depth = 100;
 
@@ -111,12 +112,17 @@ function populate( model ) {
   newAutoExposed = true;      // internal error if auto-expose after here
   return;
 
+  /** Make sure that effectiveType() is called on all members and items */
   function traverseElementEnvironments( art ) {
-    navigationEnv( art );
+    let type = effectiveType( art );
+    while (type?.items)
+      type = effectiveType( type.items );
     if (art.$queries)
       art.$queries.forEach( traverseElementEnvironments );
     if (art.mixin)
-      dictForEach( art.mixin, navigationEnv );
+      dictForEach( art.mixin, effectiveType );
+    if (art.targetAspect?.elements)
+      effectiveType( art.targetAspect );
     if (art !== art._main?._leadingQuery) // already done
       forEachMember( art, traverseElementEnvironments );
   }
@@ -125,37 +131,6 @@ function populate( model ) {
   //--------------------------------------------------------------------------
   // The central functions for path resolution - must work on-demand
   //--------------------------------------------------------------------------
-  // Phase 2: call effectiveType() on-demand, which also calculates view elems
-
-  // TODO: move setting dependencies and complaining about assocs in keys
-  // to resolvePath - then remove params: location, user
-  function navigationEnv( art, location, user, assocSpec ) {
-    // = effectiveType() on from-path, TODO: should actually already part of
-    // resolvePath() on FROM
-    if (!art)
-      return undefined;
-    let type = effectiveType( art );
-    while (type?.items)          // TODO: disallow navigation to many sometimes
-      type = effectiveType( type.items );
-    if (!type?.target || assocSpec === 'targetAspectOnly')
-      return type;
-
-    if (assocSpec === false) {
-      // TODO: combine this with setTargetReferenceKey&Co in getPathItem?
-      error( null, [ location, user ], {},
-             'Following an association is not allowed in an association key definition' );
-    }                   // TODO: else warning for assoc usage with falsy assocSpec
-    const target = resolvePath( type.target, 'target', type );
-    if (!target)
-      return target;
-    if (target && assocSpec && user)
-      dependsOn( user, target, location || user.location );
-    const effectiveTarget = effectiveType( target );
-    if (effectiveTarget === 0 && location)
-      dependsOn( user, user, (user.target || user.type || user.value || user).location );
-    // console.log('NT:',assocSpec,!!user,target)
-    return effectiveTarget;
-  }
 
   /**
    * Return the artifact having properties which are relevant for further name
@@ -189,10 +164,11 @@ function populate( model ) {
    * artifact is an association or composition; it also does not give you the
    * information about the technical base type of an enum.
    *
-   * Calculating an effective association/composition does not imply calculating
-   * its effective target.  Calculating an effective structure (entities, …)
-   * does not imply calculating the effective types of its elements.  Calculating
-   * an effective array does not imply calculating its effective line type.
+   * Calculating an effective association/composition implies calculating its
+   * target entity (including redirections), but not induce calculating the
+   * target's elements.  Calculating an effective structure (entities, …) does
+   * not imply calculating the effective types of its elements.  Calculating an
+   * effective array does not imply calculating its effective line type.
    */
   function effectiveType( art ) {
     if (!art)
@@ -212,22 +188,34 @@ function populate( model ) {
     }
     if (art)
       art = art._effectiveType;
-    if (art === 0)
+    if (art === 0) {
+      model.$assert = 'cycle';
+      // throw Error(`CYCLE: ${ chain.length }`);
       return art;
-
+    }
     chain.reverse();
     for (const a of chain) {
+      // Ensure that the _effectiveType of the parent has been calculated.  This
+      // is usually the case, but might not be for elements of anonymous target
+      // aspects.  Without it, extensions/annotations might get lost.
+      // For a query and its parent (usually the query entity!), it is the other way
+      // around: to calculate the _effectiveType of the query entity, we might need
+      // to calculate the _effectiveType of a query in FROM first.
+      if (a.kind !== 'select')
+        effectiveType( a._outer || a._main && a._parent );
+      // TODO: forbid $self+$self.elem inline, see expandWildcard()
       // Without type, value.path or _origin at beginning, link to itself:
       extendArtifactBefore( a );
       art = populateArtifact( a, art ) || a;
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
+      // console.log('PE:',require('../model/revealInternalProperties').ref(a))
       if (a.elements$ || a.enum$)
         mergeSpecifiedElementsOrEnum( a );
       // console.log( 'ET-DO:', effectiveSeqNo, a?.kind, a?.name, a._extensions?.elements?.length )
       extendArtifactAfter( a ); // after setting _effectiveType (for messages)
       if (a.typeProps$)
-        setSpecifiedElementTypeProperties(a);
+        setSpecifiedElementTypeProperties( a );
     }
     // console.log( 'ET-END:', art?.kind, art?.name )
     return art;
@@ -237,13 +225,16 @@ function populate( model ) {
     // Name-resolution relevant properties directly at artifact:
     // ‹view›.elements of input must have been moved (to elements$) before!
     // console.log('Q:',art.elements,art.enum,art.items,!!art.query)
+    // console.log('PA:',require('../model/revealInternalProperties').ref(art))
     if (art.includes)           // first version of includes via effectiveTpe()
       art.includes.forEach( i => effectiveType( i._artifact ) );
     if (art.elements != null || art.enum != null || art.items != null)
       return art;
     if (art.target) {
+      // make sure that target._artifact is set:
+      const target = resolvePath( art.target, 'target', art );
       // try to implicitly redirect explicitly provided target:
-      if (!origEffective?.target && art.kind !== 'mixin')
+      if (target && !origEffective?.target && art.kind !== 'mixin')
         redirectImplicitly( art, art );
       if (!art.expand)
         return art;
@@ -257,8 +248,14 @@ function populate( model ) {
       const leading = art.$queries[0];
       if (!leading)             // parse error
         return null;
-      // assert that there is no _effectiveType on leading (should be the case, as
-      // you cannot refer to a query of another artifact)
+      if (leading._effectiveType !== undefined) {
+        // You cannot refer to a query of another artifact:
+        throw new CompilerAssertion(
+          `Unexpected _effectiveType on leading query of ${ art.name.absolute }`
+        );
+      }
+      // TODO: try just return (effectiveType( leading )) === 0 ? 0 : art;
+      setLink( leading, '_effectiveType', 0 ); // relevant to detect invalid $self.*
       populateQuery( leading );
       setLink( leading, '_effectiveType', leading );
       leading.$effectiveSeqNo = ++effectiveSeqNo;
@@ -313,7 +310,7 @@ function populate( model ) {
     if (art._origin !== undefined)
       return art._origin;
     if (art.type)               // not stored in _origin
-      return resolveType( art.type, art );
+      return resolvePath( art.type, 'type', art );
     return setLink( art, '_origin', getOriginRaw( art ) );
   }
 
@@ -321,17 +318,23 @@ function populate( model ) {
     if (!art._main) {
       if (art.query)
         return getOrigin( art.$queries?.[0] );
+      // TODO: if we add the `includes` mechanism, use resolveUncheckedPath() for
+      // includes here, because the accept function for includes requires the
+      // elements to have been calculated!
     }
     else {
       // TODO: write checks for path in enum?
       if (art.value?.path)
-        return resolvePath( art.value, (art.$syntax === 'calc' ? 'calc' : 'expr'), art );
-      if (art.kind === 'select')
-        return getOrigin( dictFirst( art.$tableAliases ) );
+        return resolvePath( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
+      if (art.kind === 'select') {
+        const alias = dictFirst( art.$tableAliases );
+        // With parse errors, the first “alias” might be $self.  Using its origin
+        // would lead to a cyclic processing dependency.
+        return (alias.kind === '$tableAlias') ? getOrigin( alias ) : null;
+      }
       // init sets _origin for alias to sub query, only need to handle ref here:
       if (art.kind === '$tableAlias') {
-        // do not use navigationEnv(): it would always call effectiveType() on the
-        // source → we would have a deeper callstack
+        // do not call effectiveType() on the source to avoid a deeper callstack
         const source = resolvePath( art, 'from', art._parent );
         if (!source?._main)
           return source;        // direct entity (or undefined)
@@ -339,33 +342,19 @@ function populate( model ) {
         // to call effectiveType() on the last assoc of a from ref:
         // TODO: check this with test3/Queries/DollarSelf/CorruptedSource.err.cds
         const assoc = effectiveType( source );
-        return resolvePath( assoc?.target, 'target', assoc );
+        return assoc?.target._artifact;
       }
     }
     return '';
   }
 
-  function resolveType( ref, user ) {
-    if (ref._artifact !== undefined)
-      return ref._artifact;
-    while (user._outer)         // in items
-      user = user._outer;
-    if (user.kind === 'event')
-      return resolvePath( ref, 'eventType', user );
-    if (user.kind === 'param' && user._parent &&
-      (user._parent.kind === 'action' || user._parent.kind === 'function'))
-      return resolvePath( ref, 'actionParamType', user );
-    return resolvePath( ref, 'type', user );
-  }
-
-  function getCardinality( assoc ) {
-    while (assoc?._effectiveType) {
-      // if (--depth) throw Error(`GCARD: ${ Object.keys(art) }`)
-      if (assoc.cardinality)
-        return assoc.cardinality;
-      assoc = getOrigin( assoc );
+  function getInheritedProp( art, prop ) {
+    while (art?._effectiveType) {
+      if (art[prop] !== undefined)
+        return art[prop];
+      art = getOrigin( art );
     }
-    return {};
+    return undefined;
   }
 
   function userQuery( user ) {
@@ -404,7 +393,7 @@ function populate( model ) {
       proxyCopyMembers( art, 'elements', struct.elements, art.path?.location, '$navElement' );
       return true;
     }
-    if (art.elements || art.kind === '$tableAlias' || art.kind === '$inline' ||
+    if (art.elements || art.kind === '$inline' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
         struct.kind !== 'type' && struct.kind !== 'element' && struct.kind !== 'param' &&
@@ -418,7 +407,8 @@ function populate( model ) {
     const location = ref && ref.location || art.location;
     // console.log( message( null, location, art, {target:struct,art}, 'Info','EXPAND-ELEM')
     //              .toString(), Object.keys(struct.elements))
-    proxyCopyMembers( art, 'elements', struct.elements, weakLocation( location ) );
+    proxyCopyMembers( art, 'elements', struct.elements, weakLocation( location ),
+                      null, isDeprecatedEnabled( options, 'noKeyPropagationWithExpansions' ) );
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
@@ -511,7 +501,7 @@ function populate( model ) {
   //--------------------------------------------------------------------------
 
   // TODO: delete XSN._entities
-  // TODO: delete ENTITY._from
+  // TODO: delete ENTITY._from - use _origin? instead _from[0]
   // TODO (after on-demand ext): delete XSN.$entity
 
   /**
@@ -533,8 +523,12 @@ function populate( model ) {
       const ielem = art.elements ? art.elements[id] : art.enum[id];  // inferred element
       const selem = art.elements$ ? art.elements$[id] : art.enum$[id]; // specified element
       if (!selem) {
-        info( 'query-missing-element', [ ielem.name.location, art ], { id },
-              'Element $(ID) is missing in specified elements' );
+        info( 'query-missing-element', [ ielem.name.location, art ], {
+          '#': ielem.kind === 'enum' ? 'enum' : 'std', id,
+        }, {
+          std: 'Element $(ID) is missing in specified elements',
+          enum: 'Enum $(ID) is missing in specified enum values',
+        } );
       }
       else {
         for (const prop in selem) {
@@ -543,30 +537,28 @@ function populate( model ) {
             ielem[prop] = selem[prop];
             // required for gensrc mode of to-csn.js, otherwise the annotation
             // may be lost during recompilation.
-            // TODO: Clarify: Should gensrc add this annotation to the column or as an
-            //       annotate statement? Currently it's at the column.
             ielem[prop].$priority = 'annotate';
             wasAnnotated = true;
           }
           else if (typePropertiesFromSpecifiedElements[prop]) {
             if (!ielem.typeProps$)
-              setLink(ielem, 'typeProps$', Object.create(null));
+              setLink( ielem, 'typeProps$', Object.create( null ) );
             // Note: At this point in time, effectiveType() was likely not called on the
-            // element, yet. Setting it here, we can't compare it to it's value from _origin.
+            // element, yet. Setting it here, we can't compare it to its value from _origin.
             ielem.typeProps$[prop] = selem[prop];
           }
         }
 
         selem.$replacement = true;
         if (selem.elements)
-          setLink(ielem, 'elements$', selem.elements);
+          setLink( ielem, 'elements$', selem.elements );
         if (selem.enum)
-          setLink(ielem, 'enum$', selem.enum);
+          setLink( ielem, 'enum$', selem.enum );
       }
     }
 
     if (wasAnnotated)
-      setExpandStatusAnnotate(art, 'annotate');
+      setExpandStatusAnnotate( art, 'annotate' );
 
     // TODO: We don't check enum$, yet! We first need to fix expansion for
     //       `cast(elem as EnumType)` (see #9421)
@@ -586,8 +578,8 @@ function populate( model ) {
     for (const prop in art.typeProps$) {
       let o = art;
       if (o._effectiveType !== 0) { // cyclic
-        while (!o[prop] && getOrigin(o))
-          o = getOrigin(o);
+        while (!o[prop] && getOrigin( o ))
+          o = getOrigin( o );
       }
 
       if (typePropertiesFromSpecifiedElements[prop] === 'if-undefined') {
@@ -602,17 +594,19 @@ function populate( model ) {
 
   function populateQuery( query ) {
     if (query._combined || !query.from || !query.$tableAliases)
-      // already done or $join query or parse error
+      // already done (TODO: re-check!) or $join query or parse error
       return query;
-    setLink( query, '_combined', Object.create(null) );
+    setLink( query, '_combined', Object.create( null ) );
     query.$inlines = [];
     forEachGeneric( query, '$tableAliases', resolveTabRef );
-
     initFromColumns( query, query.columns );
     if (query.excludingDict) {
       for (const name in query.excludingDict)
         resolveExcluding( name, query._combined, query.excludingDict, query );
     }
+    // TODO: should we to set some falsy values? E.g. with $self.*, cyclic from?
+    // Yes, when element names cannot fully be determined (wrong source ref,
+    // cyclic, ...)  BTW, similar with `includes`
     return query;
 
     function resolveTabRef( alias ) {
@@ -628,7 +622,7 @@ function populate( model ) {
       forEachGeneric( { elements: alias.elements }, 'elements', ( elem, name ) => {
         if (elem.$duplicates !== true)
           dictAddArray( query._combined, name, elem, null ); // not dictAdd()
-      });
+      } );
     }
   }
 
@@ -652,10 +646,11 @@ function populate( model ) {
       return null;
     // If we allow CDL-style casts of `expand`s to associations in the future, we
     // need to ignore an explicit type, i.e. not getOrigin():
-    const assoc = resolvePath( elem.value, 'expr', elem ); // TODO: extra 'column'?
+    const assoc = resolvePath( elem.value, 'column', elem );
     if (!effectiveType( assoc )?.target)
       return initFromColumns( elem, elem.expand );
-    const { targetMax } = path[path.length - 1].cardinality || getCardinality( assoc );
+    const { targetMax } = path[path.length - 1].cardinality ||
+                          getInheritedProp( assoc, 'cardinality' ) || {};
     if (targetMax && (targetMax.val === '*' || targetMax.val > 1)) {
       elem.items = { location: elem.expand[$location] };
       setLink( elem.items, '_outer', elem );
@@ -666,18 +661,22 @@ function populate( model ) {
   // TODO: make this function shorter - make part of this (e.g. setting
   // parent/name) also be part of definer.js
   // TODO: query is actually the elemParent, where the new elements are added to
-  // top-level: just query, columns
-  // inline: + elements (TODO: remove), colParent
-  // expand: just query (which is a column/element), columns=array of expand
+  // top-level: ( query, query.columns )
+  // inline: ( queryOrColParent, col.inline, col )
+  // expand: ( col, col.expand )
   function initFromColumns( query, columns, inlineHead = undefined ) {
     const elemsParent = query.items || query;
     if (!inlineHead) {
-      elemsParent.elements = Object.create(null);
+      elemsParent.elements = Object.create( null );
       if (query._main._leadingQuery === query) // never the case for 'expand'
         query._main.elements = elemsParent.elements;
     }
 
-    for (const col of columns || [ { val: '*' } ]) {
+    if (!columns)
+      columns = [ { val: '*' } ];
+
+    for (let i = 0; i < columns.length; ++i) {
+      const col = columns[i];
       if (col.val === '*') {
         const siblings = wildcardSiblings( columns, query );
         expandWildcard( col, siblings, inlineHead, query );
@@ -689,19 +688,20 @@ function populate( model ) {
         col.kind = '$inline';
         col.name = {};
         // a name for this internal symtab entry (e.g. '.2' to avoid clashes
-        // with real elements) is only relevant for for `cdsc -R`/debugging
+        // with real elements) is only relevant for `cdsc -R`/debugging
         const q = userQuery( query );
         q.$inlines.push( col );
+        dependsOnSilent( q, col );
         // or use userQuery( query ) in the following, too?
         setMemberParent( col, `.${ q.$inlines.length }`, query );
         initFromColumns( query, col.inline, col );
       }
       else if (!col.$replacement) {
-        const id = ensureColumnName( col, query );
+        const id = ensureColumnName( col, i, query );
         col.kind = 'element';
         dictAdd( elemsParent.elements, id, col, ( name, location ) => {
           error( 'duplicate-definition', [ location, query ], { name, '#': 'element' } );
-        });
+        } );
         setMemberParent( col, id, query );
       }
     }
@@ -710,25 +710,36 @@ function populate( model ) {
   }
 
   // TODO: probably do this already in definer.js
-  function ensureColumnName( col, query ) {
+  function ensureColumnName( col, colIndex, query ) {
     if (col.name)
       return col.name.id;
     if (col.inline || col.val === '*')
       return '';
     const path = col.value &&
-        (col.value.path || !col.value.args && col.value.func && col.value.func.path);
-    if (path && path.length) {
-      const last = !path.broken && path.length && path[path.length - 1];
+        (col.value.path || !col.value.args && col.value.func?.path);
+    if (path) {
+      const last = path.length && !path.broken && path[path.length - 1];
       if (last) {
         col.name = { id: last.id || '', location: last.location, $inferred: 'as' };
         return col.name.id;
       }
     }
-    else if (col.value || col.expand) {
-      error( 'query-req-name', [ col.value && col.value.location || col.location, query ], {},
+    else if (col.expand || col.value && (col._pathHead || query._parent.kind !== 'select')) {
+      // _pathHead => 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' );
     }
-    // invent a name for code completion in expression
+    else if (col.value) {
+      col.name = {
+        // NOTE: If the alias is changed, corresponding name-clash tests must be updated as well!
+        id: `$_column_${ colIndex + 1 }`,
+        location: col.value.location || col.location,
+        $inferred: '$internal',
+      };
+      col.$inferred = '$internal';
+      return col.name.id;
+    }
+    // invent a name for code completion in expression, see also #10596
     col.name = {
       id: '',
       location: col.value && col.value.location || col.location,
@@ -763,13 +774,14 @@ function populate( model ) {
   // col ($replacement set before *)
   // false if two cols have same name
   function wildcardSiblings( columns, query ) {
-    const siblings = Object.create(null);
+    const siblings = Object.create( null );
     if (!columns)
       return siblings;
 
     let seenWildcard = null;
+    let colIndex = 0;
     for (const col of columns) {
-      const id = ensureColumnName( col, query );
+      const id = ensureColumnName( col, colIndex, query );
       if (id) {
         col.$replacement = !seenWildcard;
         siblings[id] = !(id in siblings) && col;
@@ -777,6 +789,7 @@ function populate( model ) {
       else if (col.val === '*') {
         seenWildcard = true;
       }
+      ++colIndex;
     }
     return siblings;
   }
@@ -786,12 +799,15 @@ function populate( model ) {
     const { elements } = query.items || query;
     let location = wildcard.location || query.from && query.from.location || query.location;
     const inferred = query._main.$inferred;
-    const excludingDict = (colParent || query).excludingDict || Object.create(null);
+    const excludingDict = (colParent || query).excludingDict || Object.create( null );
 
-    const envParent = wildcard._pathHead; // TODO: rename _pathHead to _pathEnv
+    const envParent = wildcard._pathHead; // TODO: rename _pathHead to _columnParent
     // console.log('S1:',location.line,location.col,
     //             envParent&&!!envParent._origin&&envParent._origin.name)
-    const env = columnEnv( envParent, query );
+    const env = wildcardColumnEnv( wildcard, query );
+    if (!env)
+      return;
+
     // if (envParent) console.log('S2:',location.line,location.col,
     //             envParent?.name,envParent?._origin?.name,
     //             Object.keys(env),Object.keys(elements))
@@ -810,15 +826,15 @@ function populate( model ) {
           dictAdd( elements, name, sibling, ( _name, loc ) => {
             // there can be a definition from a previous inline with the same name:
             error( 'duplicate-definition', [ loc, query ], { name, '#': 'element' } );
-          });
+          } );
           setMemberParent( sibling, name, query );
         }
         // else {
         //   sibling.$inferred = 'query';
         // }
       }
-      else if (Array.isArray(navElem)) {
-        const names = navElem.filter( e => !e.$duplicates)
+      else if (Array.isArray( navElem )) {
+        const names = navElem.filter( e => !e.$duplicates )
           .map( e => `${ e.name.alias }.${ e.name.element }` );
         if (names.length) {
           error( 'wildcard-ambiguous', [ location, query ], { id: name, names },
@@ -833,7 +849,7 @@ function populate( model ) {
         dictAdd( elements, name, elem, ( _name, loc ) => {
           // there can be a definition from a previous inline with the same name:
           error( 'duplicate-definition', [ loc, query ], { name, '#': 'element' } );
-        });
+        } );
         elem.$inferred = '*';
         elem.name.$inferred = '*';
         if (envParent)
@@ -851,14 +867,25 @@ function populate( model ) {
     }
   }
 
-  function columnEnv( envParent, query ) { // etc.  wildcard._pathHead;
+  function wildcardColumnEnv( wildcard, query ) { // etc.  wildcard._pathHead;
     // if (envParent) console.log( 'CE:', envParent._origin, query );
-    if (!envParent)
-      return userQuery( query )._combined;
-    const env = navigationEnv( getOrigin( envParent ) );
-    if (env === 0)
-      return 0;
-    return env?.elements || Object.create(null);
+    const colParent = wildcard._pathHead;
+    if (!colParent)
+      return userQuery( query )._combined; // see combinedSourcesOrParentElements
+
+    const head = resolvePath( colParent.value, 'column', colParent );
+    // eslint-disable-next-line no-nested-ternary
+    if (!head
+        ? !columnRefStartsWithSelf( colParent )
+        : head._main
+          ? userQuery( head ) !== userQuery( query )
+          : head._main !== query._main)
+      return nestedElements( wildcard );
+
+    error( 'def-unexpected-wildcard', [ wildcard.location, colParent ], { code: '*' },
+           'Unexpected $(CODE) (wildcard) after $self/association to self reference' );
+    model.$assert = null;       // explains cyclic dependencies
+    return null;
   }
 
   function reportReplacement( sibling, navElem, query ) {
@@ -869,7 +896,7 @@ function populate( model ) {
     if (!sibling.target || sibling.target.$inferred || // not explicit REDIRECTED TO
         path && path[path.length - 1].id !== sibling.name.id) { // or renamed
       const { id } = sibling.name;
-      if (Array.isArray(navElem)) {
+      if (Array.isArray( navElem )) {
         // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'wildcard-excluding-many', [ sibling.name.location, query ],
               { id, keyword: 'excluding' },
@@ -902,7 +929,7 @@ function populate( model ) {
   function setElementOrigin( queryElem, navElem, name, location ) {
     const sourceElem = navElem._origin;
     const alias = navElem._parent;
-    // always expand * to path with table alias (reason: columns current_date etc)
+    // always expand * to path with table alias (reason: columns $user etc)
     const path = [ { id: alias.name.id, location }, { id: name, location } ];
     queryElem.value = { path, location };
     setLink( path[0], '_navigation', alias );
@@ -931,7 +958,7 @@ function populate( model ) {
     // TODO: Custom kind?
     if (elem.$isSpecifiedElement)
       return false;
-    const assocTarget = resolvePath( assoc.target, 'target', assoc );
+    const assocTarget = assoc.target._artifact;
     let target = assocTarget;
     // console.log( info( null, [ elem.location, elem ], {target,art:assoc,name:''+assoc.target},
     //              'RED').toString())
@@ -974,6 +1001,12 @@ function populate( model ) {
 
   function redirectImplicitlyDo( elem, assoc, target, service ) {
     // console.log('ES:',elem.name.absolute,elem.name.element);
+    if (assoc._main === target && elem._main?.kind === 'entity' &&
+        elem._main?._ancestors?.includes( target )) {
+      // source and target of the model association are the same entity, and
+      // the current main artifact is a suitable auto-redirection target → return it
+      return elem._main;
+    }
     const elemScope = scopedRedirections && // null if no scoped redirections
           preferredElemScope( target, service, elem, assoc._main || assoc );
     const exposed = minimalExposure( target, service, elemScope );
@@ -983,7 +1016,7 @@ function populate( model ) {
       if (isAutoExposed( target ))
         target = createAutoExposed( origTarget, service, elemScope );
       const desc = origTarget._descendants ||
-            setLink( origTarget, '_descendants', Object.create(null) );
+            setLink( origTarget, '_descendants', Object.create( null ) );
       if (!desc[service.name.absolute]) // could be the target itself (no repeated msgs)!
         desc[service.name.absolute] = [ target ];
       else
@@ -1005,16 +1038,16 @@ function populate( model ) {
                  std: 'Replace target $(TARGET) by one of $(SORTED_ARTS); can\'t auto-redirect this association if multiple projections exist in this service',
                  // eslint-disable-next-line max-len
                  two: 'Replace target $(TARGET) by $(SORTED_ARTS) or $(SECOND); can\'t auto-redirect this association if multiple projections exist in this service',
-               });
+               } );
       // continuation semantics: no auto-redirection
     }
     else {
       // referred (and probably inferred) assoc (without a user-provided target at that place)
       // HINT: consider bin/cdsv2m.js when changing the following message text
-      // No grouped and sub messages yet (TODO v3): mention at all target places with all assocs
+      // No grouped and sub messages yet (TODO v5): mention at all target places with all assocs
       const withAnno = annotationVal( exposed[0]['@cds.redirection.target'] );
       for (const proj of exposed) {
-        // TODO: def-ambiguous-target (just v3, as the current is infamous and used in options),
+        // TODO: def-ambiguous-target (just v5, as the current is infamous and used in options),
         message( 'redirected-implicitly-ambiguous',
                  [ weakLocation( proj.name.location ), proj ],
                  {
@@ -1038,7 +1071,7 @@ function populate( model ) {
     return target;
   }
 
-  // Return projections of `target` in `service`.  Shorted by
+  // Return projections of `target` in `service`.  Sorted by
   // - first, only consider projections with @cds.redirection.target=true
   // - exclude all indirect projections, i.e. those which are projection on others in list
   //
@@ -1055,7 +1088,7 @@ function populate( model ) {
       return exposed || [];
     let min = [];
     for (const e of exposed) {
-      if (min.every( m => m._ancestors?.includes( e ))) {
+      if (min.every( m => m._ancestors?.includes( e ) )) {
         min = [ e ];
       }
       else if (min.length !== 1 || !e._ancestors?.includes( min[0] )) {
@@ -1139,9 +1172,10 @@ function populate( model ) {
   function isDirectProjection( proj, base ) {
     return proj.kind === 'entity' && // not event
       // direct proj (TODO: or should we add them to another list?)
+      // TODO: delete ENTITY._from
       proj.query && proj.query.op && proj.query.op.val === 'SELECT' &&
       proj._from && proj._from.length === 1 &&
-      base === resolvePath( proj._from[0], 'from', proj );
+      base === resolvePath( proj._from[0], 'from', proj.query );
   }
 
   // Auto-exposure -----------------------------------------------------------
@@ -1152,7 +1186,8 @@ function populate( model ) {
       return target.$autoexpose;
     const origTarget = target;
     const chain = [];
-    let source = target._from && resolvePath( target._from[0], 'from', target );
+    const alias1 = target._from?.[0]; // TODO: delete ENTITY._from ?
+    let source = alias1 && resolvePath( alias1, 'from', alias1._parent );
     // query source ref might not have been resolved yet, cycle avoided as
     // setAutoExposed() sets $autoexpose and a second call on same art would
     // return false
@@ -1160,7 +1195,8 @@ function populate( model ) {
       // stop at first ancestor with annotation or at non-query entity
       chain.push( target );
       target = source;
-      source = target._from && resolvePath( target._from[0], 'from', target );
+      const alias = target._from?.[0]; // TODO: delete ENTITY._from ?
+      source = alias && resolvePath( alias, 'from', alias._parent );
     }
     const autoexpose = target.$autoexpose;
     if (typeof autoexpose === 'boolean') {
@@ -1199,7 +1235,7 @@ function populate( model ) {
       return `${ service.name.absolute }.${ absolute }`;
     const base = definitionScope( target );
     if (base === target)
-      return `${ service.name.absolute }.${ absolute.substring( absolute.lastIndexOf('.') + 1 ) }`;
+      return `${ service.name.absolute }.${ absolute.substring( absolute.lastIndexOf( '.' ) + 1 ) }`;
     // for scoped (e.g. calculated) entities, use exposed name of base:
     const exposed = minimalExposure( base, service, elemScope );
     // console.log(exposed.map( a => a.name.absolute ));
@@ -1271,18 +1307,18 @@ function populate( model ) {
     };
     // forward target parameters to projection
     if (target.params) {
-      art.params = Object.create(null);
+      art.params = Object.create( null );
       // is art.query.from.path[0].$syntax: ':' required?
-      art.query.from.path[0].args = Object.create(null);
-      forEachGeneric(target, 'params', (p, pn) => {
-        art.params[pn] = linkToOrigin(p, pn, art, 'params', p.location);
+      art.query.from.path[0].args = Object.create( null );
+      forEachGeneric( target, 'params', (p, pn) => {
+        art.params[pn] = linkToOrigin( p, pn, art, 'params', p.location );
         art.query.from.path[0].args[pn] = {
           name: { id: p.name.id, location: p.location },
           location: p.location,
           scope: 'param',
           path: [ { id: pn, location: p.location } ],
         };
-      });
+      } );
     }
     // TODO: do we need to tag the generated entity with elemScope = 'auto'?
     if (autoexposed) {