@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/compiler/resolver.js

@@ -45,29 +45,30 @@ 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 { kindProperties } = require('./base');
 const {
-  getDefinerFunctions,
+  pushLink,
+  setLink,
   augmentPath,
   splitIntoPath,
-} = require('./definer');
+  linkToOrigin,
+  setMemberParent,
+  withAssociation,
+  storeExtension,
+  dependsOn,
+  dependsOnSilent,
+} = require('./utils');
 
 const detectCycles = require('./cycle-detector');
 const layers = require('./moduleLayers');
 
-const {
-  kindProperties, fns, setLink, linkToOrigin, setMemberParent, withAssociation, storeExtension,
-  dependsOn, dependsOnSilent,
-} = require('./shared');
-
 const annotationPriorities = {
   define: 1, extend: 2, annotate: 2, edmx: 3,
 };
-
+const $inferred = Symbol.for('cds.$inferred');
 
 // Export function of this file.  Resolve type references in augmented CSN
 // `model`.  If the model has a property argument `messages`, do not throw
@@ -75,26 +76,28 @@ const annotationPriorities = {
 // that property (should be a vector).
 function resolve( model ) {
   const { options } = model;
-  // Get shared "resolve" functionality and the message function:
+  // Get shared functionality and the message function:
+  const {
+    info, warning, error, message,
+  } = model.$messageFunctions;
   const {
     resolvePath,
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model, environment );
-  const {
-    info, warning, error, message,
-  } = makeMessageFunction( model, model.options, 'compile' );
-  const {
     initArtifact,
     lateExtensions,
     projectionAncestor,
-  } = getDefinerFunctions(model);
+  } = model.$functions;
+  model.$volatileFunctions.environment = environment;
+
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
   // 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' ) &&
@@ -242,6 +245,7 @@ function resolve( model ) {
     const chain = [];
     while (art && !('_effectiveType' in art) &&
            (art.type || art._origin || art.value && art.value.path) &&
+           // TODO: really stop at art.enum?
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
       setProp( art, '_effectiveType', 0 ); // initial setting in case of cycles
@@ -273,13 +277,17 @@ function resolve( model ) {
       // collect the "latest" cardinality (calculate lazyly if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
+      let prev = art;
       for (const a of chain) {
         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.elements && expandElements( a, art, eType ) ||
+            art.items && expandItems( a, art, eType ))
           art = a;
+        else if (art.enum && expandEnum( a, prev ))
+          prev = a;             // do not set art - effective type is base
         setProp( a, '_effectiveType', art );
       }
     }
@@ -319,6 +327,7 @@ function resolve( model ) {
     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 || art.builtin)
@@ -326,14 +335,14 @@ function resolve( model ) {
     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 = userQuery( art ) || art._parent;
-    if (query.kind !== 'select' || !art.value.path)
+    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
@@ -404,7 +413,7 @@ function resolve( model ) {
     for (const view of resolveChain.reverse()) {
       if (view._status !== '_query' ) { // not already resolved
         setProp( view, '_status', '_query' );
-        traverseQueryPost( view.query, false, populateQuery );
+        traverseQueryPost( view.query, null, populateQuery );
         if (view.elements$)     // specified elements
           mergeSpecifiedElements( view );
         if (!view.$entity) {
@@ -424,7 +433,7 @@ 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 and doc comments for the moment
           if (prop.charAt(0) === '@' || prop === 'doc')
@@ -435,7 +444,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' );
       }
@@ -445,8 +454,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 ) {
@@ -454,6 +462,7 @@ 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 );
@@ -493,7 +502,8 @@ function resolve( model ) {
         });
       }
       forEachGeneric( { elements: alias.elements }, 'elements', ( elem, name ) => {
-        dictAddArray( query._combined, name, elem, null ); // not dictAdd()
+        if (elem.$duplicates !== true)
+          dictAddArray( query._combined, name, elem, null ); // not dictAdd()
       });
     }
   }
@@ -534,13 +544,31 @@ function resolve( model ) {
     setMemberParent( key, name, elem ); // TODO: set _block here if not present?
   }
 
+  function expandItems( art, origin, eType ) {
+    if (!enableExpandElements || art.items)
+      return false;
+    if (isInParents( art, eType )) {
+      art.items = 0;            // circular
+      return true;
+    }
+    const ref = art.type || art.value || art.name;
+    const location = ref && ref.location || art.location;
+    art.items = { $inferred: 'expand-element', location };
+    setProp( art.items, '_outer', art );
+    setProp( art.items, '_origin', origin.items );
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    return true;
+  }
+
   function expandElements( art, struct, eType ) {
     if (!enableExpandElements)
       return false;
     if (art.elements || art.kind === '$tableAlias' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
-        struct.kind !== 'type' && struct.kind !== 'element' && !struct._outer)
+        struct.kind !== 'type' && struct.kind !== 'element' && struct.kind !== 'param' &&
+        !struct._outer)
       return false;
     if (struct.elements === 0 || isInParents( art, eType )) {
       art.elements = 0;         // circular
@@ -559,8 +587,33 @@ 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-element';
+    return true;
+  }
+
+  function expandEnum( art, origin ) {
+    if (!enableExpandElements || art.enum)
+      return false;
+    const ref = art.type || art.value || art.name;
+    const location = weakLocation( ref && ref.location || art.location );
+    art.enum = Object.create(null);
+    for (const name in origin.enum) {
+      const orig = origin.enum[name];
+      linkToOrigin( orig, name, art, 'enum', location, true )
+        // or should we use orig.location? - TODO: try to find test to see message
+        .$inferred = 'expand-element';
+    }
+    // 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
+    art.enum[$inferred] = 'expand-element';
     return true;
   }
 
@@ -586,14 +639,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 inferred 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;
     }
   }
 
@@ -605,7 +689,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())
@@ -718,6 +802,7 @@ function resolve( model ) {
     const nullScope = {
       kind: 'namespace', name: { absolute: autoScopeName, location }, location,
     };
+    model.definitions[autoScopeName] = nullScope;
     initArtifact( nullScope );
     return nullScope;
   }
@@ -926,26 +1011,53 @@ 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, where the new elements are added to
-  function initFromColumns( query, columns, elements = undefined, colParent = undefined ) {
+  // 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 (!elements) {
-      elements = Object.create(null); // explicitly prov
+    if (!inlineHead) {
       elemsParent.elements = Object.create(null);
       if (query._main._leadingQuery === query) // never the case for 'expand'
         query._main.elements = elemsParent.elements;
     }
-    let wildcard = false;
-    let inline = 0;
 
     for (const col of columns || [ { val: '*' } ]) {
       if (col.val === '*') {
-        wildcard = col;
-        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)' );
@@ -957,137 +1069,135 @@ function resolve( model ) {
         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
-        // TODO: user better scheme with _outer (for messages /column:…/inline:2),
-        // use depth-first numbering
-        setMemberParent( col, `.${ ++inline }`, query );
-        initFromColumns( query, col.inline, elements, col );
+        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 &&
-          (col.value.path || !col.value.args && col.value.func && col.value.func.path);
-        if (!path) {
-          error( 'query-req-name', [ col.value && 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 && col.value.location || col.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( elemsParent.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`
-    // 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)
-    // eslint-disable-next-line no-shadow
-    function expandWildcard( elements, wildcard ) {
-      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 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)
-          // TODO: in general - re-think and implement
-          if (!inferred && (
-              selElem.$replacement !== 'silent' && !envParent &&
-              (!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( elemsParent.elements, name, selElem );
-          }
-          else {
-            selElem.$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)' );
-          }
+  // 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 {
-          location = weakLocation( location );
-          const origin = envParent ? navElem : navElem._origin;
-          const elem = linkToOrigin( origin, name, query, 'elements', location );
-          elem.$inferred = '*';
-          elem.name.$inferred = '*';
-          if (envParent)
-            setWildcardExpandInline( elem, envParent, 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( elemsParent.elements, name, elem );
-      });
-      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 );
+      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)' );
       }
     }
   }
@@ -1378,7 +1488,9 @@ function resolve( model ) {
     }
     // Resolve projections/views
     // if (art.query)console.log( info( null, [art.query.location,art.query], 'VQ:' ).toString() );
-    traverseQueryPost( art.query, false, resolveQuery );
+
+    if (art.$queries)
+      art.$queries.forEach( resolveQuery );
 
     if (obj.type || obj._origin || obj.value && obj.value.path || obj.elements) // typed artifacts
       effectiveType(obj);  // set _effectiveType if appropriate, (future?): copy elems if extended
@@ -1523,14 +1635,28 @@ 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;
+      if (art.kind === 'action' || art.kind === 'function') {
+        expandParameters( art );
+        if (art.returns)
+          effectiveType( art.returns );
+      }
+      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;
 
@@ -1548,6 +1674,44 @@ function resolve( model ) {
         annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
     }
   }
+  function expandParameters( action ) {
+    // see also expandElements()
+    if (!enableExpandElements || !effectiveType( action ))
+      return;
+    const chain = [];
+    // Should we be able to consider params and returns separately?
+    // Probably not, let to-csn omit unchanged params/returns.
+    while (action._origin && !action.params) {
+      chain.push( action );
+      action = action._origin;
+    }
+    chain.reverse();
+    for (const art of chain) {
+      const origin = art._origin;
+      if (!art.params && origin.params) {
+        for (const name in origin.params) {
+          // TODO: we could check _annotate here to decide whether we really
+          // not to create proxies
+          const orig = origin.params[name];
+          linkToOrigin( orig, name, art, 'params', weakLocation( orig.location ), true )
+            .$inferred = 'expand-param';
+        }
+      }
+      if (!art.returns && origin.returns) {
+        // TODO: make linkToOrigin() work for returns, kind/name?
+        const location = weakLocation( origin.returns.location );
+        art.returns = {
+          name: Object.assign( {}, art.name, { id: '', param: '', location } ),
+          kind: 'param',
+          location,
+          $inferred: 'expand-param',
+        };
+        setProp( art.returns, '_parent', art );
+        setProp( art.returns, '_main', art._main || art );
+        setProp( art.returns, '_origin', origin.returns );
+      }
+    }
+  }
 
   function extensionFor( art ) {
     if (art.kind === 'annotate')
@@ -1586,6 +1750,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;
   }
 
@@ -1752,7 +1918,7 @@ function resolve( model ) {
   function resolveQuery( query ) {
     if (!query._main)           // parse error
       return;
-    populateQuery( query );
+    traverseQueryPost( query, null, populateQuery );
     forEachGeneric( query, '$tableAliases', ( alias ) => {
       // console.log( info( null, [alias.location,alias], 'SQA:' ).toString() );
       if (alias.kind === 'mixin')
@@ -1761,8 +1927,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 );
@@ -1786,7 +1955,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)
@@ -1823,7 +1992,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 ],
@@ -2264,6 +2436,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
@@ -2468,6 +2643,8 @@ function resolve( model ) {
   }
 
   function resolveExpr( expr, expected, user, extDict, expandOrInline) {
+    // TODO: when we have rewritten the resolvePath functions,
+    // define a traverseExpr() in ./utils.js
     // TODO: extra "expected" 'expand'/'inline' instead o param `expandOrInline`
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
       return;
@@ -2504,7 +2681,7 @@ function resolve( model ) {
     else if (expr.query) {
       const { query } = expr;
       if (query.kind || query._leadingQuery) { // UNION has _leadingQuery
-        traverseQueryPost( query, false, resolveQuery );
+        // traverseQueryPost( query, false, resolveQuery );
       }
       else {
         error( 'expr-no-subquery', [ expr.location, user ], {},
@@ -2515,12 +2692,19 @@ 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 && isDeprecatedEnabled( options )) {
+      const { location } = expr.suffix[0] || expr;
+      error( null, [ location, user ], { prop: 'deprecated' },
+             'Window functions are not supported if $(PROP) options are set' );
+    }
+    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') &&
@@ -2531,7 +2715,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 },
@@ -2699,8 +2883,6 @@ function navProjection( navigation, preferred ) {
 // Query tree post-order traversal - called for everything which makes a query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
 function traverseQueryPost( query, simpleOnly, callback ) {
-  while (Array.isArray(query)) // query in parentheses, TODO: remove
-    query = query[0];
   if (!query)                   // parser error
     return;
   if (!query.op) {              // in FROM (not JOIN)
@@ -2720,11 +2902,19 @@ function traverseQueryPost( query, simpleOnly, callback ) {
     // console.log('FE:')
   }
   else if (query.args) {             // JOIN, UNION, INTERSECT
-    for (const q of query.args)
-      traverseQueryPost( q, simpleOnly, callback );
-    // The ON condition has to be traversed extra, because it must be evaluated
-    // after the complete FROM has been traversed.  It is also not necessary to
-    // evaluate it in populateQuery().
+    if (!query.join && simpleOnly == null) {
+      // enough for elements: traverse only first args for UNION/INTERSECT
+      // TODO: we might use this also when we do not rewrite associations
+      // in non-referred sub queries
+      traverseQueryPost( query.args[0], simpleOnly, callback );
+    }
+    else {
+      for (const q of query.args)
+        traverseQueryPost( q, simpleOnly, callback );
+      // The ON condition has to be traversed extra, because it must be evaluated
+      // after the complete FROM has been traversed.  It is also not necessary to
+      // evaluate it in populateQuery().
+    }
   }
   // else: with parse error (`select from <EOF>`, `select distinct from;`)
 }