@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/compiler/resolver.js

@@ -45,9 +45,7 @@ const {
   dictAdd, dictAddArray,
 } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
-const {
-  makeMessageFunction, searchName, weakLocation,
-} = require('../base/messages');
+const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
 const { pushLink } = require('./utils');
 const {
@@ -84,7 +82,7 @@ function resolve( model ) {
   } = fns( model, environment );
   const {
     info, warning, error, message,
-  } = makeMessageFunction( model, model.options, 'compile' );
+  } = model.$messageFunctions;
   const {
     initArtifact,
     lateExtensions,
@@ -95,6 +93,8 @@ function resolve( model ) {
 
   // behavior depending on option `deprecated`:
   const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  // TODO: we should get rid of noElementsExpansion soon; both
+  // beta.nestedProjections and beta.universalCsn do not work with it.
   const scopedRedirections
         = enableExpandElements &&
           !isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ) &&
@@ -253,9 +253,11 @@ function resolve( model ) {
       }
       else {
         setProp( art, '_effectiveType', art );
+        if (art.expand && !art.value && !art.elements)
+          initFromColumns( art, art.expand );
         // When not blocked (by future origin = false) and not REDIRECTED TO and not MIXIN
         // try to implicitly redirect explicitly provided target:
-        if (art.target && art._origin == null && !art.value && art.kind !== 'mixin')
+        else if (art.target && art._origin == null && !art.value && art.kind !== 'mixin')
           redirectImplicitly( art, art );
       }
     }
@@ -268,8 +270,13 @@ function resolve( model ) {
       let eType = art;
       if (eType._outer)
         eType = effectiveType( eType._outer );
+      // collect the "latest" cardinality (calculate lazyly if necessary)
+      let cardinality = art.cardinality ||
+          art._effectiveType && (() => getCardinality( art._effectiveType ));
       for (const a of chain) {
-        if (a.expand && initFromColumns( a, a.expand, a ) || // before redirectImplicitly()!
+        if (a.cardinality)
+          cardinality = a.cardinality;
+        if (a.expand && expandFromColumns( a, art, cardinality ) ||
             art.target && redirectImplicitly( a, art ) ||
             art.elements && expandElements( a, art, eType ))
           art = a;
@@ -279,21 +286,55 @@ function resolve( model ) {
     return art;
   }
 
+  function expandFromColumns( elem, assoc, cardinality ) {
+    const path = elem.value && elem.value.path;
+    if (!path || path.broken)
+      return null;
+    if (!assoc.target)
+      return initFromColumns( elem, elem.expand );
+    const { targetMax } = path[path.length - 1].cardinality ||
+          (cardinality instanceof Function ? cardinality() : cardinality);
+    if (targetMax && (targetMax.val === '*' || targetMax.val > 1))
+      elem.items = { location: dictLocation( elem.expand ) };
+    return initFromColumns( elem, elem.expand );
+  }
+
+  function getCardinality( type ) {
+    // only to be called without cycles
+    while (type) {
+      if (type.cardinality)
+        return type.cardinality;
+      type = directType( type );
+    }
+    return {};
+  }
+
+  function userQuery( user ) {
+    // TODO: we need _query links set by the definer
+    while (user._main) {
+      if (user.kind === 'select' || user.kind === '$join')
+        return user;
+      user = user._parent;
+    }
+    return null;
+  }
+
+  // TODO: test it in combination with top-level CAST function
   function directType( art ) {
     // Be careful when using it with art.target or art.enum or art.elements
-    if (art._origin)
+    if (art._origin || art.builtin)
       return art._origin;
     if (art.type)
       return resolveType( art.type, art );
     // console.log( 'EXPR-IN', art.kind, refString(art.name) )
-    if (!art._main)
+    if (!art._main || !art.value || !art.value.path)
       return undefined;
     if (art._pathHead && art.value) {
       setProp( art, '_origin', resolvePath( art.value, 'expr', art, null ) );
       return art._origin;
     }
-    const query = art._parent._leadingQuery || art._parent; // TODO: re-check leading
-    if (query.kind !== 'select' || !art.value.path)
+    const query = userQuery( art ) || art._parent;
+    if (query.kind !== 'select')
       return undefined;
     // Reached an element in a query which is a simple ref -> return referred artifact
     // TODO: remember that we still have to resolve path arguments and filters
@@ -384,10 +425,10 @@ function resolve( model ) {
         info( 'query-missing-element', [ ielem.name.location, view ], { id },
               'Element $(ID) is missing in specified elements' );
       }
-      else if (!Array.isArray( ielem ) && !Array.isArray( selem )) {
+      else {
         for (const prop in selem) {
-          // just annotation assignments for the moment
-          if (prop.charAt(0) === '@')
+          // just annotation assignments and doc comments for the moment
+          if (prop.charAt(0) === '@' || prop === 'doc')
             ielem[prop] = selem[prop];
         }
         selem.$replacement = true;
@@ -395,7 +436,7 @@ function resolve( model ) {
     }
     for (const id in view.elements$) {
       const selem = view.elements$[id]; // specified element
-      if (!Array.isArray( selem ) && !selem.$replacement) {
+      if (!selem.$replacement) {
         error( 'query-unspecified-element', [ selem.name.location, selem ], { id },
                'Element $(ID) does not result from the query' );
       }
@@ -405,8 +446,7 @@ function resolve( model ) {
   function traverseElementEnvironments( art ) {
     populateView( art );
     environment( art );
-    // TODO: but we have no proxy copy of sub elements yet - no redirection in ValueHelpList.cds
-    forEachGeneric( art, 'elements', traverseElementEnvironments );
+    forEachMember( art, traverseElementEnvironments );
   }
 
   function populateQuery( query ) {
@@ -414,14 +454,16 @@ function resolve( model ) {
       // already done or $join query or parse error
       return;
     setProp( query, '_combined', Object.create(null) );
+    query.$inlines = [];
     forEachGeneric( query, '$tableAliases', resolveTabRef );
 
     initFromColumns( query, query.columns );
+    // TODO: already in definer: complain about EXCLUDING with no wildcard
+    // (would have been automatically with a good CDL syntax: `* without (...)`)
     if (query.excludingDict) {
       for (const name in query.excludingDict)
-        resolveExcluding( name );
+        resolveExcluding( name, query._combined, query.excludingDict, query );
     }
-    forEachGeneric( query, 'elements', initElem );
     return;
 
     function resolveTabRef( alias ) {
@@ -455,46 +497,36 @@ function resolve( model ) {
         dictAddArray( query._combined, name, elem, null ); // not dictAdd()
       });
     }
+  }
 
-    function resolveExcluding( name ) {
-      if (query._combined[name])
-        return;
-      /** @type {object} */
-      const compileMessageRef = info(
-        'ref-undefined-excluding', [ query.excludingDict[name].location, query ], { name },
-        'Element $(NAME) has not been found'
-      );
-      attachAndEmitValidNames(compileMessageRef, query._combined);
-    }
-
-    function initElem( elem ) {
-      if (elem.type && !elem.type.$inferred)
-        return;                 // explicit type -> enough or directType()
-      if (elem.$inferred) {
-        // redirectImplicitly( elem, elem._origin );
-        return;
-      }
-      if (!elem.value || !elem.value.path) // TODO: test $inferred
-        return;                 // no value ref or $inferred
-      // TODO: what about SELECT from E { $projection.a as a1, a } !!!!!!
-
-      const origin = setProp( elem, '_origin',
-                              resolvePath( elem.value, 'expr', elem, query._combined ) );
-      // console.log( message( null, elem.location, elem, {art:query}, 'Info','RED').toString(),
-      //              elem.value)
-      // TODO: make this resolvePath() also part of directType() ?!
-      if (!origin)
-        return;
+  function initElem( elem, query ) {
+    if (elem.type && !elem.type.$inferred)
+      return;                 // explicit type -> enough or directType()
+    if (elem.$inferred) {
+      // redirectImplicitly( elem, elem._origin );
+      return;
+    }
+    if (!elem.value || !elem.value.path) // TODO: test $inferred
+      return;                 // no value ref or $inferred
+    // TODO: what about SELECT from E { $projection.a as a1, a } !!!!!!
+
+    const env = columnEnv( elem._pathHead, query );
+    const origin = setProp( elem, '_origin',
+                            resolvePath( elem.value, 'expr', elem, env ) );
+    // console.log( message( null, elem.location, elem, {art:query}, 'Info','RED').toString(),
+    //              elem.value)
+    // TODO: make this resolvePath() also part of directType() ?!
+    if (!origin)
+      return;
+    if (elem.foreignKeys) {   // REDIRECTED with explicit foreign keys
+      forEachGeneric( elem, 'foreignKeys', (key, name) => initKey( key, name, elem ) );
+    }
 
-      // now set things which are necessary for later sub phases:
-      const nav = pathNavigation( elem.value );
-      if (nav.navigation && nav.item === elem.value.path[elem.value.path.length - 1]) {
-        // redirectImplicitly( elem, origin );
-        pushLink( nav.navigation, '_projections', elem );
-      }
-      if (elem.foreignKeys) {   // REDIRECTED with explicit foreign keys
-        forEachGeneric( elem, 'foreignKeys', (key, name) => initKey( key, name, elem ) );
-      }
+    // now set things which are necessary for later sub phases:
+    const nav = pathNavigation( elem.value );
+    if (nav.navigation && nav.item === elem.value.path[elem.value.path.length - 1]) {
+      // redirectImplicitly( elem, origin );
+      pushLink( nav.navigation, '_projections', elem );
     }
   }
 
@@ -528,8 +560,12 @@ function resolve( model ) {
         // or should we use orig.location? - TODO: try to find test to see message
         .$inferred = 'expand-element';
     }
-    art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    // TODO: should we also set 'virtual' here?
+    // Set elements expansion status (the if condition is always true, as no
+    // elements expansion will take place on artifact with existing other
+    // member property):
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    // TODO: have some art.elements[SYM.$inferred] = 'expand-elements';
     return true;
   }
 
@@ -555,14 +591,45 @@ function resolve( model ) {
     return false;
   }
 
-  function setExpandStatus( elem ) {
+  // About Helper property $expand for faster the XSN-to-CSN transformation
+  // - null/undefined: artifact, member, items does not contain expanded members
+  // - 'origin': all expanded (sub) elements have no new target/on and no new annotations
+  //             that value is only on elements, types, and params -> no other members
+  //             when set, only on elem/art with expanded elements
+  // - 'target': all expanded (sub) elements might only have new target/on, but
+  //             no indivual annotations on any (sub) member
+  //             when set, traverse all parents where the value has been 'origin' before
+  // - 'annotate': at least one inferred (sub) member has an individual annotation,
+  //               not counting propagated ones; set up to the definition (main artifact)
+  //               (only set with anno on $inferred elem)
+  // Usage according to CSN flavor:
+  // - gensrc: do not render enferred elements (including expanded elements),
+  //           collect annotate statements with value 'annotate'
+  // - client: do not render expanded sub elements if artifact/member is no type, has a type,
+  //           has $expand = 'origin', and all its _origin also have $expand = 'origin'
+  //           (might sometimes render the elements unnecessarily, which is not wrong)
+  // - universal: do not render expanded sub elements if $expand = 'origin'
+  function setExpandStatus( elem, status ) {
+    // set on element
     while (elem._main) {
       elem = elem._parent;
-      if (!elem.$expand)
+      if (elem.$expand !== 'origin')
         return;
-      elem.$expand = 'target';  // meaning: expanded, containing assocs
+      elem.$expand = status;    // meaning: expanded, containing assocs
       for (let line = elem.items; line; line = line.items)
-        line.$expand = 'target'; // to-csn just uses the innermost $expand
+        line.$expand = status; // to-csn just uses the innermost $expand
+    }
+  }
+  function setExpandStatusAnnotate( elem, status ) {
+    for (;;) {
+      if (elem.$expand === status)
+        return;                 // already set
+      elem.$expand = status;    // meaning: expanded, containing annos
+      for (let line = elem.items; line; line = line.items)
+        line.$expand = status; // to-csn just uses the innermost $expand
+      if (!elem._main)
+        return;
+      elem = elem._parent;
     }
   }
 
@@ -574,7 +641,7 @@ function resolve( model ) {
     // PRE: elem has no target, assoc has target prop
     if (elem.kind === '$tableAlias')
       return false;
-    setExpandStatus( elem );
+    setExpandStatus( elem, 'target' );
     let target = resolvePath( assoc.target, 'target', assoc );
     // console.log( info( null, [ elem.location, elem ], {target,art:assoc,name:''+assoc.target},
     //              'RED').toString())
@@ -635,7 +702,8 @@ function resolve( model ) {
       setLink( elem, origin, '_origin' );
       setLink( origin, elem._parent, '_parent' );
       if (elem._main)           // remark: the param `elem` can also be a type
-        setLink( origin, elem._main, '_parent', '_main' );
+        setLink( origin, elem._main, '_main' );
+      setLink( origin, origin, '_effectiveType' );
       setLink( origin, elem._block, '_block' );
       if (elem.foreignKeys) {
         origin.foreignKeys = elem.foreignKeys;
@@ -686,6 +754,7 @@ function resolve( model ) {
     const nullScope = {
       kind: 'namespace', name: { absolute: autoScopeName, location }, location,
     };
+    model.definitions[autoScopeName] = nullScope;
     initArtifact( nullScope );
     return nullScope;
   }
@@ -894,146 +963,215 @@ function resolve( model ) {
     return art;
   }
 
+  // TODO: probably do this already in definer.js
+  function ensureColumnName( col, 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) {
+      const last = !path.broken && path.length && 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 ], {},
+             'Alias name is required for this select item' );
+    }
+    // invent a name for code completion in expression
+    col.name = {
+      id: '',
+      location: col.value && col.value.location || col.location,
+      $inferred: 'none',
+    };
+    return '';
+  }
+
   // 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
-  function initFromColumns( query, columns, colParent = undefined, elements = undefined ) {
-    if (!elements) {
-      elements = Object.create(null);
-      query.elements = Object.create(null);
+  // 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
+  function initFromColumns( query, columns, inlineHead = undefined ) {
+    const elemsParent = query.items || query;
+    if (!inlineHead) {
+      elemsParent.elements = Object.create(null);
       if (query._main._leadingQuery === query) // never the case for 'expand'
-        query._main.elements = query.elements;
+        query._main.elements = elemsParent.elements;
     }
-    let wildcard = false;
-    let inline = 0;
 
     for (const col of columns || [ { val: '*' } ]) {
       if (col.val === '*') {
-        wildcard = col.location || query.from && query.from.location || query.location;
-        continue;
+        const siblings = wildcardSiblings( columns, query );
+        expandWildcard( col, siblings, inlineHead, query );
       }
-      col.kind = 'element';
       if ((col.expand || col.inline) && !isBetaEnabled( options, 'nestedProjections' )) {
         error( null, [ col.location, query ], { prop: (col.expand ? 'expand' : 'inline') },
                'Unsupported nested $(PROP)' );
       }
-      if (!col.value)
+      if (!col.value && !col.expand)
         continue;             // error should have been reported by parser
       if (col.inline) {
         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
-        setMemberParent( col, `.${ ++inline }`, query );
-        initFromColumns( query, col.inline, col, elements );
+        const q = userQuery( query );
+        q.$inlines.push( col );
+        // or use userQuery( query ) in the following, too?
+        setMemberParent( col, `.${ q.$inlines.length }`, query );
+        initFromColumns( query, col.inline, col );
         continue;
       }
-      if (!col.name) {
-        const path = col.value.path || !col.value.args && col.value.func && col.value.func.path;
-        if (!path) {
-          error( 'query-req-name', [ col.value.location || col.location, query ], {},
-                 'Alias name is required for this select item' );
-        }
-        else if (path.length && !path.broken) {
-          const last = path[path.length - 1];
-          if (last)
-            col.name = { id: last.id, location: last.location, $inferred: 'as' };
-        }
-        if (!col.name) {
-          // invent a name for code completion in expression
-          col.name = { id: '', location: col.value.location, $inferred: 'none' };
-        }
-      }
-      const { id } = col.name;
-      dictAdd( elements, id, col, ( name, location ) => {
-        error( 'duplicate-definition', [ location, query ], { name, '#': 'element' } );
-      });
-      setMemberParent( col, id, query );
-      if (!wildcard) {
-        if (col.$duplicates !== true)
-          dictAdd( query.elements, id, col );
-        col.$replacement = true;
+      else if (!col.$replacement) {
+        const id = ensureColumnName( col, query );
+        col.kind = 'element';
+        dictAdd( elemsParent.elements, id, col, ( name, location ) => {
+          error( 'duplicate-definition', [ location, query ], { name, '#': 'element' } );
+        });
+        setMemberParent( col, id, query );
       }
     }
-    if (wildcard)
-      expandWildcard( elements, wildcard );
+    forEachGeneric( query, 'elements', e => initElem( e, query ) );
     return true;
+  }
 
-    // TODO: make this function shorter, probably outside initFromColumns
-    // `elements` are the element explicitly provided via `columns`
-    // eslint-disable-next-line no-shadow
-    function expandWildcard( elements, location ) {
-      const inferred = query._main.$inferred;
-      const excludingDict = query.excludingDict || Object.create(null);
-      const env = colParent
-        ? environment( colParent._origin || colParent )
-        : query._combined;
-      // TODO: paths in excludingDict? - Did I mention it? EXCLUDING is ill-defined...
-      for (const name in env) {
-        const navElem = env[name];
-        // TODO: if it is an array, filter out those with masked
-        if (excludingDict[name] || navElem.masked && navElem.masked.val)
-          continue;
-        const selElem = elements[name];
-        if (selElem) {          // is explicitly provided
-          if (!selElem.name)    // no name with parse error or repeated def
-            continue;
-          const path = selElem.value && selElem.value.path;
-          // TODO: to bring the message below for ParentElem.Assoc, we should move this
-          // check to resolveElem for elems with $replacement, by comparing the
-          // name with the name.element of the _origin.
-          // We cannot check path.length === 1, as we want to allow Alias.Elem.
-
-          // TODO: bring this less often (only if shadowed elem does not appear
-          // in expr and if not projected as other name)
-          if (!inferred && (
-              selElem.$replacement !== 'silent' && (!selElem.target || selElem.target.$inferred ) ||
-              path && path[path.length - 1].id !== selElem.name.id)) {
-            if (Array.isArray(navElem)) {
-              info( 'wildcard-excluding-many', [ selElem.name.location, query ], { id: name },
-                    'This select item replaces $(ID) from two or more sources' );
-            }
-            else {
-              info( 'wildcard-excluding-one', [ selElem.name.location, query ],
-                    { id: name, alias: navElem._parent.name.id },
-                    'This select item replaces $(ID) from table alias $(ALIAS)' );
-            }
-          }
-          if (!selElem.$replacement || selElem.$replacement === 'silent') {
-            selElem.$replacement = true;
-            dictAdd( query.elements, name, selElem );
-          }
-          else {
-            selElem.$inferred = 'query';
-          }
+  // col ($replacement set before *)
+  // false if two cols have same name
+  function wildcardSiblings( columns, query ) {
+    const siblings = Object.create(null);
+    if (!columns)
+      return siblings;
+
+    let seenWildcard = null;
+    for (const col of columns) {
+      const id = ensureColumnName( col, query );
+      if (id) {
+        col.$replacement = !seenWildcard;
+        siblings[id] = !(id in siblings) && col;
+      }
+      else if (col.val === '*') {
+        seenWildcard = true;
+      }
+    }
+    return siblings;
+  }
+
+  // TODO: make struct.* are to be added at place, not sub-wildcards first,
+  // see test3/Queries/ExpandInlineCreate/Excluding.cds
+  // TODO: disallow $self.elem.* and $self.*, toSelf.* (circular dependency)
+  function expandWildcard( wildcard, siblingElements, colParent, query ) {
+    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 envParent = wildcard._pathHead; // TODO: rename _pathHead to _pathEnv
+    // console.log('S1:',location.line,location.col,
+    //             envParent&&!!envParent._origin&&envParent._origin.name)
+    const env = columnEnv( envParent, query );
+    // console.log('S2:',location.line,location.col,
+    //             envParent&&!!envParent._origin&&envParent._origin.name,
+    //             Object.keys(env),Object.keys(elements))
+    for (const name in env) {
+      const navElem = env[name];
+      // TODO: if it is an array, filter out those with masked
+      if (excludingDict[name] || navElem.masked && navElem.masked.val)
+        continue;
+      const sibling = siblingElements[name];
+      if (sibling) {          // is explicitly provided (without duplicate)
+        if (!inferred && !envParent) // not yet for expand/inline
+          reportReplacement( sibling, navElem, query );
+        if (!sibling.$replacement) {
+          sibling.$replacement = true;
+          sibling.kind = 'element';
+          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 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 },
-                   'Ambiguous wildcard, select $(ID) explicitly with $(NAMES)' );
-          }
-        }
-        else {
-          location = weakLocation( location );
-          const origin = colParent ? navElem : navElem._origin;
-          const elem = linkToOrigin( origin, name, query, 'elements', location );
-          elem.$inferred = '*';
-          elem.name.$inferred = '*';
-          if (colParent)
-            setWildcardExpandInline( elem, colParent, origin, name, location );
-          else
-            setElementOrigin( elem, navElem, name, location );
+        // else {
+        //   sibling.$inferred = 'query';
+        // }
+      }
+      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 },
+                 'Ambiguous wildcard, select $(ID) explicitly with $(NAMES)' );
         }
       }
-      forEachInOrder( { elements }, 'elements', (elem, name) => {
-        if (!elem.$replacement)
-          dictAdd( query.elements, name, elem );
-      });
+      else {
+        location = weakLocation( location );
+        const origin = envParent ? navElem : navElem._origin;
+        const elem = linkToOrigin( origin, name, query, null, location );
+        // TODO: check assocToMany { * }
+        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)
+          setWildcardExpandInline( elem, envParent, origin, name, location );
+        else
+          setElementOrigin( elem, navElem, name, location );
+      }
+    }
+    if (envParent || query.kind !== 'select') {
+      // already done in populateQuery (TODO: change that and check whether
+      // `*` is allowed at all in definer)
+      const user = colParent || query;
+      for (const name in user.excludingDict)
+        resolveExcluding( name, env, excludingDict, query );
     }
   }
 
+  function reportReplacement( sibling, navElem, query ) {
+    // TODO: bring this much less often = only if shadowed elem does not appear
+    // in expr and if not projected as other name.
+    // Probably needs to be reported at a later phase
+    const path = sibling.value && sibling.value.path;
+    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)) {
+        info( 'wildcard-excluding-many', [ sibling.name.location, query ], { id },
+              'This select item replaces $(ID) from two or more sources' );
+      }
+      else {
+        info( 'wildcard-excluding-one', [ sibling.name.location, query ],
+              { id, alias: navElem._parent.name.id },
+              'This select item replaces $(ID) from table alias $(ALIAS)' );
+      }
+    }
+  }
+
+  function columnEnv( envParent, query ) { // etc.  wildcard._pathHead;
+    return (envParent)
+      ? environment( directType( envParent ) || envParent )
+      : userQuery( query )._combined;
+  }
+
+  function resolveExcluding( name, env, excludingDict, user ) {
+    if (env[name])
+      return;
+    /** @type {object} */
+    // console.log(name,Object.keys(env),Object.keys(excludingDict))
+    const compileMessageRef = info(
+      'ref-undefined-excluding', [ excludingDict[name].location, user ], { name },
+      'Element $(NAME) has not been found'
+    );
+    attachAndEmitValidNames( compileMessageRef, env );
+  }
+
   function setElementOrigin( queryElem, navElem, name, location ) {
     const sourceElem = navElem._origin;
     const alias = navElem._parent;
@@ -1276,6 +1414,7 @@ function resolve( model ) {
       }
     }
     if (obj.target) {
+      // console.log(obj.name,obj._origin.name)
       if (obj._origin && obj._origin.$inferred === 'REDIRECTED')
         resolveTarget( art, obj._origin );
       // console.log(message( null, obj.location, obj, {target:obj.target}, 'Info','TARGET')
@@ -1301,6 +1440,7 @@ function resolve( model ) {
     }
     // Resolve projections/views
     // if (art.query)console.log( info( null, [art.query.location,art.query], 'VQ:' ).toString() );
+    // TODO: here, any order should be ok, i.e. just loop over $queries
     traverseQueryPost( art.query, false, resolveQuery );
 
     if (obj.type || obj._origin || obj.value && obj.value.path || obj.elements) // typed artifacts
@@ -1320,7 +1460,7 @@ function resolve( model ) {
     }
 
     resolveExpr( art.default, 'default', art );
-    resolveExpr( art.value, 'expr', art );
+    resolveExpr( art.value, 'expr', art, undefined, art.expand || art.inline );
     if (art.value && !art.type && !art.target && !art.elements)
       inferTypeFromCast( art );
 
@@ -1446,14 +1586,23 @@ function resolve( model ) {
       }
     }
     if (art && art._annotate) {
-      if (art.$expand && art._annotate.elements)
-        art.$expand = 'annotate'; // do not omit expanded elements when they are annotated
-      // TODO: returns
-      let obj = art.returns || art; // why the extra `returns` for actions?
-      obj = obj.items || obj;
+      const aor = art.returns || art;
+      const obj = aor.items || aor.targetAspect || aor;
+      // Currently(?), effectiveType() does not calculate the effective type of
+      // its line item:
+      effectiveType( obj );
+      if (art._annotate.elements)
+        setExpandStatusAnnotate( aor, 'annotate' );
       annotate( obj, 'element', 'elements', 'enum', art );
       annotate( art, 'action', 'actions' );
       annotate( art, 'param', 'params' );
+      // const { returns } = art._annotate;
+      // if (returns) {
+      //   const dict = returns.elements;
+      //   const env = obj.returns && obj.returns.elements || null;
+      //   for (const n in dict)
+      //     annotateMembers( env && env[n], dict[n], 'elements', n, parent, 'element' );
+      // }
     }
     return;
 
@@ -1509,6 +1658,8 @@ function resolve( model ) {
     ext.kind = 'annotate';    // after setMemberParent()!
     setProp( art, '_extension', ext );
     setProp( ext.name, '_artifact', art );
+    if (art.returns)
+      ext.$syntax = 'returns';
     return ext;
   }
 
@@ -1528,8 +1679,13 @@ function resolve( model ) {
   function chooseAssignment( annoName, art ) {
     // TODO: getPath an all names
     const anno = art[annoName];
-    if (!Array.isArray(anno)) // just one assignment -> use it
+    if (!Array.isArray(anno)) { // just one assignment -> use it
+      if (removeEllipsis( anno )) {
+        error( 'anno-unexpected-ellipsis',
+               [ anno.name.location, art ], { code: '...' } );
+      }
       return;
+    }
     // sort assignment according to layer
     const layerAnnos = Object.create(null);
     for (const a of anno) {
@@ -1541,33 +1697,107 @@ function resolve( model ) {
       else
         layerAnnos[name] = { layer, annos: [ a ] };
     }
+    mergeArrayInSCCs();
+    art[annoName] = mergeLayeredArrays( findLayerCandidate( ) );
+    return;
+
+    function mergeArrayInSCCs( ) {
+      let pos = 0;
+      Object.values( layerAnnos ).forEach( (layer) => {
+        const mergeSource
+        = layer.annos.find(v => (v.$priority === undefined ||
+           annotationPriorities[v.$priority] === annotationPriorities.define));
+        if (mergeSource) {
+          if (removeEllipsis( mergeSource )) {
+            error( 'anno-unexpected-ellipsis',
+                   [ mergeSource.name.location, art ], { code: '...' } );
+          }
+          // merge source into elipsis array annotates
+          layer.annos.forEach( (mergeTarget) => {
+            if (mergeTarget.$priority &&
+                annotationPriorities[mergeTarget.$priority] > annotationPriorities.define) {
+              pos = findEllipsis( mergeTarget );
+              if (pos > -1) {
+                if (mergeSource.literal !== 'array') {
+                  error( 'anno-mismatched-ellipsis',
+                         [ mergeSource.name.location, art ], { code: '...' } );
+                  return;
+                }
+                mergeTarget.val.splice(pos, 1, ...mergeSource.val);
+              }
+            }
+          });
+        }
+      });
+    }
+
+    function mergeLayeredArrays( mergeTarget ) {
+      if (mergeTarget.literal === 'array') {
+        let layer = layers.layer( mergeTarget._block );
+        delete layerAnnos[(layer) ? layer.realname : ''];
+        let pos = findEllipsis( mergeTarget );
+        while (pos > -1 && Object.keys( layerAnnos ).length ) {
+          const mergeSource = findLayerCandidate();
+          if (mergeSource.literal !== 'array') {
+            error( 'anno-mismatched-ellipsis',
+                   [ mergeSource.name.location, art ], { code: '...' } );
+            return mergeTarget;
+          }
+          mergeTarget.val.splice(pos, 1, ...mergeSource.val);
+          layer = layers.layer( mergeSource._block );
+          delete layerAnnos[(layer) ? layer.realname : ''];
+          pos = findEllipsis( mergeTarget );
+        }
+        // remove excess ellipsis
+        removeEllipsis( mergeTarget, pos );
+      }
+      return mergeTarget;
+    }
+
+    function removeEllipsis(a, pos = findEllipsis( a )) {
+      let count = 0;
+      while (a.literal === 'array' && pos > -1) {
+        count++;
+        a.val.splice(pos, 1);
+        pos = findEllipsis( a );
+      }
+      return count;
+    }
+
+    function findEllipsis(a) {
+      return (a.literal === 'array' && a.val)
+        ? a.val.findIndex(v => v.literal === 'token' && v.val === '...') : -1;
+    }
+
+    function findLayerCandidate() {
     // collect assignments of upper layers (are in no _layerExtends)
-    const exts = Object.keys( layerAnnos ).map( layerExtends );
-    const allExtends = Object.assign( Object.create(null), ...exts );
-    const collected = [];
-    for (const name in layerAnnos) {
-      if (!(name in allExtends))
-        collected.push( prioritizedAnnos( layerAnnos[name].annos ) );
-    }
-    // inspect collected assignments - choose the one or signal error
-    const justOnePerLayer = collected.every( annos => annos.length === 1);
-    if (!justOnePerLayer || collected.length > 1) {
-      for (const annos of collected) {
-        for (const a of annos ) {
+      const exts = Object.keys( layerAnnos ).map( layerExtends );
+      const allExtends = Object.assign( Object.create(null), ...exts );
+      const collected = [];
+      for (const name in layerAnnos) {
+        if (!(name in allExtends))
+          collected.push( prioritizedAnnos( layerAnnos[name].annos ) );
+      }
+      // inspect collected assignments - choose the one or signal error
+      const justOnePerLayer = collected.every( annos => annos.length === 1);
+      if (!justOnePerLayer || collected.length > 1) {
+        for (const annos of collected) {
+          for (const a of annos ) {
           // Only the message ID is different.
-          if (justOnePerLayer) {
-            message( 'anno-duplicate-unrelated-layer', [ a.name.location, art ], { anno: annoName },
-                     'Duplicate assignment with $(ANNO)' );
-          }
-          else {
-            message( 'anno-duplicate', [ a.name.location, art ], { anno: annoName },
-                     'Duplicate assignment with $(ANNO)' );
+            if (justOnePerLayer) {
+              message( 'anno-duplicate-unrelated-layer',
+                       [ a.name.location, art ], { anno: annoName },
+                       'Duplicate assignment with $(ANNO)' );
+            }
+            else {
+              message( 'anno-duplicate', [ a.name.location, art ], { anno: annoName },
+                       'Duplicate assignment with $(ANNO)' );
+            }
           }
         }
       }
+      return collected[0][0];  // just choose any one with error
     }
-    art[annoName] = collected[0][0]; // just choose any one with error
-    return;
 
     function layerExtends( name ) {
       const { layer } = layerAnnos[name];
@@ -1605,8 +1835,11 @@ function resolve( model ) {
         // pure path has been resolved, resolve args and filter now:
         resolveExpr( alias, 'from', query._parent );
     } );
+    for (const col of query.$inlines)
+      resolveExpr( col.value, 'expr', col, undefined, true );
+    // for (const col of query.$inlines)
+    //   if (!col.value.path) throw Error(col.name.element)
     if (query !== query._main._leadingQuery) // will be done later
-      // TODO: rethink elements(view) === elements(view._leadingQuery)
       forEachGeneric( query, 'elements', resolveRefs );
     if (query.from)
       resolveJoinOn( query.from );
@@ -1630,7 +1863,7 @@ function resolve( model ) {
     return;
 
     function resolveJoinOn( join ) {
-      if (join.args) {             // JOIN
+      if (join && join.args) {  // JOIN
         for (const j of join.args)
           resolveJoinOn( j );
         if (join.on)
@@ -1667,7 +1900,10 @@ function resolve( model ) {
     }
     const target = resolvePath( obj.target, 'target', art );
     if (obj.on) {
-      if (!art._main || !art._parent.elements && !art._parent.items) {
+      if (!art._main || !art._parent.elements && !art._parent.items && !art._parent.targetAspect) {
+        // TODO: test of .items a bit unclear - we should somehow restrict the
+        // use of unmanaged assocs in MANY, at least with $self
+        // TODO: $self usage in anonymous aspects to be corrected in Core Compiler
         const isComposition = obj.type && obj.type.path && obj.type.path[0] &&
                               obj.type.path[0].id === 'cds.Composition';
         message( 'assoc-as-type', [ obj.on.location, art ],
@@ -2108,6 +2344,9 @@ function resolve( model ) {
 
   // TODO: there is no need to rewrite the on condition of non-leading queries,
   // i.e. we could just have on = {…}
+  // TODO: re-check $self rewrite (with managed composition of aspects),
+  // and actually also $self inside anonymous aspect definitions
+  // (not entirely urgent as we do not analyse it further, at least sole "$self")
   function rewriteCondition( elem, assoc ) {
     if (enableExpandElements && elem._parent && elem._parent.kind === 'element') {
       // managed association as sub element not supported yet
@@ -2311,7 +2550,8 @@ function resolve( model ) {
       resolveTypeArguments( art, typeArt, user );
   }
 
-  function resolveExpr( expr, expected, user, extDict) {
+  function resolveExpr( expr, expected, user, extDict, expandOrInline) {
+    // TODO: extra "expected" 'expand'/'inline' instead o param `expandOrInline`
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
       return;
     if (Array.isArray(expr)) {
@@ -2337,7 +2577,7 @@ function resolve( model ) {
       }
       resolvePath( expr, expected, user, extDict );
 
-      const last = expr.path[expr.path.length - 1];
+      const last = !expandOrInline && expr.path[expr.path.length - 1];
       for (const step of expr.path) {
         if (step && (step.args || step.where || step.cardinality) &&
             step._artifact && !Array.isArray( step._artifact ) )
@@ -2358,12 +2598,18 @@ function resolve( model ) {
       const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
       args.forEach( e => e && resolveExpr( e, e.$expected || expected, user, extDict ) );
     }
+    if (expr.suffix && !isBetaEnabled( options, 'windowFunctions' )) {
+      const { location } = expr.suffix[0] || expr;
+      error( null, [ location, user ], 'Window functions are not supported' );
+    }
+    if (expr.suffix)
+      expr.suffix.forEach( s => s && resolveExpr( s, expected, user, extDict ) );
   }
 
   function resolveParamsAndWhere( step, expected, user, extDict, isLast ) {
     const alias = step._navigation && step._navigation.kind === '$tableAlias' && step._navigation;
     const type = alias || effectiveType( step._artifact );
-    const art = type && type.target && type.target._artifact || type;
+    const art = (type && type.target) ? type.target._artifact : type;
     if (!art)
       return;
     const entity = (art.kind === 'entity') &&
@@ -2374,7 +2620,7 @@ function resolve( model ) {
       if (step.where)
         resolveExpr( step.where, 'filter', user, environment( type ) );
     }
-    else if (step.where || step.cardinality) {
+    else if (step.where && step.where.location || step.cardinality ) {
       const location = combinedLocation( step.where, step.cardinality );
       // XSN TODO: filter$location including […]
       message( 'expr-no-filter', [ location, user ], { '#': expected },