@sap/cds-compiler 3.6.2 → 3.7.2

package/lib/compiler/populate.js

@@ -24,7 +24,7 @@ const {
   forEachGeneric,
 } = require('../base/model');
 const {
-  dictAdd, dictAddArray,
+  dictAdd, dictAddArray, dictFirst, dictForEach,
 } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
 const { weakLocation } = require('../base/messages');
@@ -32,7 +32,6 @@ const { CompilerAssertion } = require('../base/error');
 
 const { kindProperties } = require('./base');
 const {
-  pushLink,
   setLink,
   setArtifactLink,
   annotationVal,
@@ -42,8 +41,8 @@ const {
   splitIntoPath,
   linkToOrigin,
   setMemberParent,
+  proxyCopyMembers,
   dependsOn,
-  traverseQueryPost,
   setExpandStatus,
   setExpandStatusAnnotate,
 } = require('./utils');
@@ -66,12 +65,12 @@ function populate( model ) {
   model.$volatileFunctions.environment = environment;
   Object.assign( model.$functions, {
     effectiveType,
-    directType,
+    getOrigin,
     resolveType,
-    populateQuery,
   } );
+  // let depth = 100;
 
-
+  let effectiveSeqNo = 0;   // artifact number set after having set _effectiveType
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
@@ -96,146 +95,243 @@ function populate( model ) {
   newAutoExposed = true;      // internal error if auto-expose after here
   return;
 
+  function traverseElementEnvironments( art ) {
+    navigationEnv( art );
+    if (art.$queries)
+      art.$queries.forEach( traverseElementEnvironments );
+    if (art.mixin)
+      dictForEach( art.mixin, navigationEnv );
+    if (art !== art._main?._leadingQuery) // already done
+      forEachMember( art, traverseElementEnvironments );
+  }
+
 
   //--------------------------------------------------------------------------
   // The central functions for path resolution - must work on-demand
   //--------------------------------------------------------------------------
-  // Phase 2: call populateView(), which also works on-demand
-
-  function traverseElementEnvironments( art ) {
-    populateView( art );
-    environment( art );
-    if (art.elements$ || art.enum$)
-      mergeSpecifiedElementsOrEnum(art);
-    forEachMember( art, traverseElementEnvironments );
-  }
+  // Phase 2: call effectiveType() on-demand, which also calculates view elems
 
   // Return effective search environment provided by artifact `art`, i.e. the
   // `artifacts` or `elements` dictionary.  For the latter, follow the `type`
   // chain and resolve the association `target`.  View elements are calculated
   // on demand.
   function environment( art, location, user, assocSpec ) {
-    if (!art)
-      return Object.create(null);
     const env = navigationEnv( art, location, user, assocSpec );
+    if (env === 0)
+      return 0;
     return env && env.elements || Object.create(null);
   }
 
   function navigationEnv( art, location, user, assocSpec ) {
-    let type = effectiveType(art) || art;
-    // console.log( info(null, [ art.location, art ], { art, type }, 'ENV')
-    //              .toString(), art.elements && Object.keys(art.elements))
-    if (type.target) {
-      type = resolvePath( type.target, 'target', type );
-      if (!type) {
-        if (type === 0 && location)
-          dependsOn( art, art, (art.target || art.type).location );
-        return type;
-      }
+    // = 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)
+      return type;
+
+    if (assocSpec === false) {
       // TODO: combine this with setTargetReferenceKey&Co in getPathItem?
-      else if (assocSpec === false) { // TODO: else warning for assoc usage
-        error( null, [ location, user ], {},
-               'Following an association is not allowed in an association key definition' );
-      }
-      else if (assocSpec && user) {
-        dependsOn( user, type, location );
-      }
-    }
-    populateView( type );
-    return type;
+      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;
   }
 
-  // Follow the `type` chain, i.e. derived types and TYPE OF, stop just before
-  // built-in types (otherwise, we would loose type parameters).  Return that
-  // type and set it as property `_effectiveType` on all artifacts on the chain.
-  // TODO: clarify for (query) elements without type: self, not undefined - also for entities!
-  // TODO: directly "propagate" (with implicit redirection the targets), also
-  // "proxy-copy" elements
-
-  // In v2, the name-resolution relevant properties (elements,items,target) are
-  // proxy-copied, i.e. the effectiveType of an artifact is always the artifact
-  // itself.  Except for the situation with recursive element expansions; then
-  // we have element: 0, and use original final type.
+  /**
+   * Return the artifact having properties which are relevant for further name
+   * resolution on `art`: `target`, `elements`, `items`, also `enum`.  Make sure
+   * that these properties actually exist, are complete and auto-corrected.  Cache
+   * the result in property `_effectiveType`.
+   *
+   * - actions, functions: returns `art`, might have expanded `params`/`returns`
+   * - artifacts with direct or inherited `target`, `elements`, `items`, `enum`:
+   *   returns `art`, these properties might have been auto-redirected / expanded
+   * - artifacts with direct or inherited scalar type: the built-in type
+   * - other artifacts: the last artifact in the origin-chain, i.e. the one which
+   *   has neither a type nor some value path.
+   * - returns 0 with cyclic dependencies (with recursive element expansions, we
+   *   have `elements: 0` instead).
+   * - returns null if a relevant reference points to nothing or is corrupted
+   * - returns false if a relevant reference points to a duplicate definition
+   *
+   * This function also infers type relevant properties:
+   *
+   * - views and queries: returns `art` with inferred query `elements`
+   * - column with `expand`: returns `art`, usually with inferred `elements`/`items`
+   * - more to come
+   *
+   * At the moment, it is assumed that includes, expansions, and localized has
+   * been applied earlier.
+   *
+   * Properties which are (usually) not relevant for the name resolution, like
+   * `length` and `cardinality`, cannot be simply accessed on the effective
+   * artifact.  The effective artifact alone is not enough to check whether an
+   * 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.
+   */
   function effectiveType( art ) {
+    if (!art)
+      return art;
+    // if (--depth) throw Error(`ET: ${ Object.keys(art) }`)
     if ('_effectiveType' in art)
       return art._effectiveType;
 
     // console.log(message( null, art.location, art, {}, 'Info','FT').toString())
     const chain = [];
-    while (art && !('_effectiveType' in art) &&
-           (art.type || art._origin || art.value?.path || art.value?.type) &&
-           !art.target && !art.enum && !art.elements && !art.items) {
-      chain.push( art );
+    // console.log( 'ET-START:', art.kind, art.name )
+    while (art && !('_effectiveType' in art)) {
       setLink( art, '_effectiveType', 0 ); // initial setting in case of cycles
-      art = directType( art );
-    }
-    if (art) {
-      if ('_effectiveType' in art) { // is the case for builtins
-        art = art._effectiveType;
-      }
-      else {
-        setLink( 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:
-        else if (art.target && art._origin == null && !art.value && art.kind !== 'mixin')
-          redirectImplicitly( art, art );
-      }
+      chain.push( art );
+      art = getOrigin( art );
+      // console.log( 'ET-GO:', art?.name )
     }
+    if (art)
+      art = art._effectiveType;
+    if (art === 0)
+      return art;
+
     chain.reverse();
-    if (!art) {
-      for (const a of chain)
-        setLink( a, '_effectiveType', art );
+    for (const a of chain) {
+      // console.log( 'ET-DO:', a.name, art?.kind )
+      // Without type, value.path or _origin at beginning, link to itself:
+      art = populateArtifact( a, art ) || a;
+      if (a.elements$ || a.enum$)
+        mergeSpecifiedElementsOrEnum( a );
+      setLink( a, '_effectiveType', art );
+      a.$effectiveSeqNo = ++effectiveSeqNo;
     }
-    else {
-      // collect the "latest" cardinality (calculate lazily if necessary)
-      let cardinality = art.cardinality ||
-          art._effectiveType && (() => getCardinality( art._effectiveType ));
-      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 ) ||
-            art.items && expandItems( a, art ) ||
-            art.enum && expandEnum( a, art ))
-          art = a;
-        setLink( a, '_effectiveType', art );
+    // console.log( 'ET-END:', art?.kind, art?.name )
+    return art;
+  }
+
+  function populateArtifact( art, origEffective ) {
+    // 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)
+    if (art.elements != null || art.enum != null || art.items != null)
+      return art;
+    if (art.target) {
+      // try to implicitly redirect explicitly provided target:
+      if (!origEffective?.target && art.kind !== 'mixin')
+        redirectImplicitly( art, art );
+      if (!art.expand)
+        return art;
+    }
+
+    // With properties to be calculated: ----------------------------------------
+    if (art.query && art.kind !== '$tableAlias') { // query entity
+      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)
+      populateQuery( leading );
+      setLink( leading, '_effectiveType', leading );
+      leading.$effectiveSeqNo = ++effectiveSeqNo;
+      return art;
+    }
+    if (art.from)
+      return populateQuery( art );
+
+    if (art.expand) {
+      // TODO: test that there is no CDL-style cast with expand
+      // (we could allow that later: then some basic structural check is needed)
+      if (!art.value) {
+        initFromColumns( art, art.expand );
+        if (origEffective?.target) // consider `{ … } as x: AssocType
+          redirectImplicitly( art, origEffective );
       }
+      else if (art.value.path) {
+        expandFromColumns( art );
+      }
+      // TODO: if we allow CDL-style cast with expand in the future, we need to
+      // redirectImplicitly when casting to assoc type
+      return art;
     }
-    return art;
+    if (!origEffective || origEffective.builtin) // TODO: builtin test needed?
+      return origEffective;
+
+    // With inherited auto-corrected name-resolution-relevant properties: -------
+    if (origEffective.target)
+      return redirectImplicitly( art, origEffective ) ? art : origEffective;
+    if (origEffective.elements)
+      return expandElements( art, origEffective ) ? art : origEffective;
+    if (origEffective.enum)
+      return expandEnum( art, origEffective ) ? art : origEffective;
+    if (origEffective.items)
+      return expandItems( art, origEffective ) ? art : origEffective;
+    if (origEffective.params || origEffective.returns)
+      return expandParams( art, origEffective );
+    return origEffective;
   }
 
   // TODO: test it in combination with top-level CAST function
-  function directType( art ) {
+  // TODO: we could probably "extend" this function to all other cases where we
+  // set an _origin in Universal CSN
+
+  // TODO: add 2nd arg `considerSecondary` used in effectiveType(): prefers a
+  // predecessor without _effectiveType (includes, joins)
+  function getOrigin( art ) {
     // Be careful when using it with art.target or art.enum or art.elements
-    if (art._origin || art.builtin)
+    if (!art)
+      return undefined;         // TODO: null?
+    // if (--depth) throw Error(`GOR: ${ Object.keys(art) }`)
+    if ('_origin' in art)
       return art._origin;
-    if (art.type)
+    if (art.type)               // not stored in _origin
       return resolveType( art.type, art );
-    if (art.value?.type)
-      return resolveType( art.value.type, art );
-    // console.log( 'EXPR-IN', art.kind, refString(art.name) )
-    if (!art._main || !art.value || !art.value.path)
-      return undefined;
-    if (art.value.path) {
-      setLink( art, '_origin', resolvePath( art.value, 'expr', art, null ) );
-      return art._origin;
+    return setLink( art, '_origin', getOriginRaw( art ) );
+  }
+
+  function getOriginRaw( art ) {
+    if (!art._main) {
+      if (art.query)
+        return getOrigin( art.$queries?.[0] );
     }
-    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
-    return setLink( art, '_origin',
-                    resolvePath( art.value, 'expr', art, query._combined ) );
-    // console.log( 'EXPR-OUT', art.value._artifact.kind, refString(art.val ue._artifact.name) );
+    else {
+      if (art.value?.path)
+        return resolvePath( art.value, 'expr', art, null );
+      if (art.kind === 'select')
+        return getOrigin( dictFirst( art.$tableAliases ) );
+      // 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 would have a deeper callstack
+        const source = resolvePath( art, 'from', art._parent );
+        if (!source?._main)
+          return source;        // direct entity (or undefined)
+        // Before having done the resolvePath cleanup, do not rely on resolvePath
+        // to call effectiveType() on the last assoc of a from ref:
+        const assoc = effectiveType( source );
+        return resolvePath( assoc?.target, 'target', assoc );
+      }
+    }
+    return '';
   }
 
   function resolveType( ref, user ) {
     if ('_artifact' in ref)
       return ref._artifact;
+    while (user._outer)         // in items
+      user = user._outer;
     if (ref.scope === 'typeOf') {
       let struct = user;
       while (struct.kind === 'element')
@@ -255,8 +351,6 @@ function populate( model ) {
       }
       return resolvePath( ref, 'typeOf', user );
     }
-    while (user._outer)         // in items
-      user = user._outer;
     if (user.kind === 'event')
       return resolvePath( ref, 'eventType', user );
     if (user.kind === 'param' && user._parent &&
@@ -265,18 +359,18 @@ function populate( model ) {
     return resolvePath( ref, 'type', user );
   }
 
-  function getCardinality( type ) {
-    // only to be called without cycles
-    while (type) {
-      if (type.cardinality)
-        return type.cardinality;
-      type = directType( type );
+  function getCardinality( assoc ) {
+    while (assoc?._effectiveType) {
+      // if (--depth) throw Error(`GCARD: ${ Object.keys(art) }`)
+      if (assoc.cardinality)
+        return assoc.cardinality;
+      assoc = getOrigin( assoc );
     }
     return {};
   }
 
   function userQuery( user ) {
-    // TODO: we need _query links set by the definer
+    // TODO: should we set _query links in define.js?
     while (user._main) {
       if (user.kind === 'select' || user.kind === '$join')
         return user;
@@ -285,7 +379,7 @@ function populate( model ) {
     return null;
   }
 
-  // Expansiosn --------------------------------------------------------------
+  // Expansions --------------------------------------------------------------
 
 
   function expandItems( art, origin ) {
@@ -307,6 +401,10 @@ function populate( model ) {
   }
 
   function expandElements( art, struct ) {
+    if (art.kind === '$tableAlias') {
+      proxyCopyMembers( art, 'elements', struct.elements, art.path?.location, '$navElement' );
+      return true;
+    }
     if (art.elements || art.kind === '$tableAlias' || art.kind === '$inline' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
@@ -321,15 +419,7 @@ 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))
-    for (const name in struct.elements) {
-      const orig = struct.elements[name];
-      // const orig = elem.kind === '$navElement'
-      if (Array.isArray( orig )) // redefinitions
-        continue;
-      linkToOrigin( orig, name, art, 'elements', weakLocation( location ), true )
-        // or should we use orig.location? - TODO: try to find test to see message
-        .$inferred = 'expanded';
-    }
+    proxyCopyMembers( art, 'elements', struct.elements, weakLocation( location ) );
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
@@ -344,13 +434,7 @@ function populate( model ) {
       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 = 'expanded';
-    }
+    proxyCopyMembers( art, 'enum', origin.enum, weakLocation( location ) );
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
@@ -360,6 +444,30 @@ function populate( model ) {
     return true;
   }
 
+  function expandParams( art, origin ) {
+    if (!origin._main)
+      return origin;            // not with entity (should not happen)
+    if (origin.params)
+      proxyCopyMembers( art, 'params', origin.params, null );
+
+    if (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: 'expanded',
+      };
+      setLink( art.returns, '_parent', art );
+      setLink( art.returns, '_main', art._main || art );
+      setLink( art.returns, '_origin', origin.returns );
+    }
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    return art;
+  }
+
   /**
    * Return true iff `art` is from a recursive expansion, i.e.  if any of its
    * expanded parents (including _outer) has the same non-expansion-origin.
@@ -403,48 +511,9 @@ function populate( model ) {
   // Views
   //--------------------------------------------------------------------------
 
-  // Make a view to have elements (remember: wildcard), and prepare that their
-  // final type can be resolved, i.e. we know how to resolve select item refs.
-  // We do so by first populate views in the FROM clause, then the view query.
-  function populateView( art ) {
-    if (!art._from || art._status === '_query')
-      return;
-    const resolveChain = [];
-    const fromChain = [ art ];
-    while (fromChain.length) {
-      const view = fromChain.pop();
-      if (view._status === '_query') // already fully resolved (status at def)
-        continue;
-      resolveChain.push( view );
-      for (const from of view._from) {
-        if (from._status)       // status at the ref -> illegal recursion -> stop
-          continue;
-        setLink( from, '_status', '_query' );
-        // setLink before resolvePath - Cycle: view V as select from V.toV
-        let source = resolvePath( from, 'from', view ); // filter and args in resolveQuery
-        // console.log('ST:',msgName(source),from._status)
-        if (source && source._main) { // element -> should be assoc
-          const type = effectiveType( source );
-          source = type && type.target;
-        }
-        if (source && source._from && source._status !== '_query')
-          fromChain.push( source );
-      }
-    }
-    // console.log( resolveChain.map( v => msgName(v)+v._status ) );
-    resolveChain.reverse();
-    for (const view of resolveChain) {
-      if (view._status !== '_query' ) { // not already resolved
-        setLink( view, '_status', '_query' );
-        // must be run in order “sub query in FROM first”:
-        traverseQueryPost( view.query, null, populateQuery );
-        if (!view.$entity) {
-          model._entities.push( view );
-          view.$entity = ++model.$entity;
-        }
-      }
-    }
-  }
+  // TODO: delete XSN._entities
+  // TODO: delete ENTITY._from
+  // TODO (after on-demand ext): delete XSN.$entity
 
   /**
    * Merge _specified_ elements with _inferred_ elements in the given view/element,
@@ -499,6 +568,7 @@ function populate( model ) {
     for (const id in art.elements$) {
       const selem = art.elements$[id]; // specified element
       if (!selem.$replacement) {
+        // console.log( 'QED:', art.name, art.kind, art.elements )
         error( 'query-unspecified-element', [ selem.name.location, selem ], { id },
                'Element $(ID) does not result from the query' );
       }
@@ -508,7 +578,7 @@ function populate( model ) {
   function populateQuery( query ) {
     if (query._combined || !query.from || !query.$tableAliases)
       // already done or $join query or parse error
-      return;
+      return query;
     setLink( query, '_combined', Object.create(null) );
     query.$inlines = [];
     forEachGeneric( query, '$tableAliases', resolveTabRef );
@@ -518,35 +588,18 @@ function populate( model ) {
       for (const name in query.excludingDict)
         resolveExcluding( name, query._combined, query.excludingDict, query );
     }
-    return;
+    return query;
 
     function resolveTabRef( alias ) {
+      // effectiveType() must not be called on $self, is unnecessary for mixins:
+      // TODO: have a test for `select from E { a, $self.a as b, $self.{ b as c } }`
+      // TODO: have a negative test for `select from E { $self.*, assoc.* }`
+      // (we might have those already)
       if (alias.kind === 'mixin' || alias.kind === '$self')
         return;
-      if (!alias.elements) { // could be false in hierarchical JOIN
-        // if (main._block.$frontend!=='json') console.log('TABREF:',alias.name,main,main._block)
-        // const tab = alias.path && resolvePath( alias, 'from', query );
-        // // if (tab) setLink( alias, '_effectiveType', alias );
-        // const elements = alias.query ? alias.query.elements : environment( tab );
-        if (!('_origin' in alias) && alias.path) {
-          const tab = resolvePath( alias, 'from', query );
-          setLink( alias, '_origin', tab && navigationEnv( tab ) );
-        }
-        alias.elements = Object.create(null); // Set explicitly, as...
-        // ...with circular dep to source, no elements can be found.
-        const location = alias.path && alias.path.location;
-        const qtab = alias._origin;
-        if (!qtab || !qtab.elements)
-          return;
-        forEachGeneric( qtab, 'elements', ( origin, name ) => {
-          const elem = linkToOrigin( origin, name, alias, 'elements',
-                                     location || origin.name.location );
-          elem.kind = '$navElement';
-          // elem.name.select = query.name.select;
-          if (origin.masked)
-            elem.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
-        });
-      }
+      if (!alias.elements) // could be false in hierarchical JOIN - TODO: necessary?
+        effectiveType( alias ); // element → $navElement expansion for $tableAlias
+
       forEachGeneric( { elements: alias.elements }, 'elements', ( elem, name ) => {
         if (elem.$duplicates !== true)
           dictAddArray( query._combined, name, elem, null ); // not dictAdd()
@@ -568,14 +621,16 @@ function populate( model ) {
 
   // query columns -----------------------------------------------------------
 
-  function expandFromColumns( elem, assoc, cardinality ) {
-    const path = elem.value && elem.value.path;
+  function expandFromColumns( elem ) {
+    const path = elem.value?.path;
     if (!path || path.broken)
       return null;
-    if (!assoc.target)
+    // 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, null );
+    if (!effectiveType( assoc )?.target)
       return initFromColumns( elem, elem.expand );
-    const { targetMax } = path[path.length - 1].cardinality ||
-          (cardinality instanceof Function ? cardinality() : cardinality);
+    const { targetMax } = path[path.length - 1].cardinality || getCardinality( assoc );
     if (targetMax && (targetMax.val === '*' || targetMax.val > 1))
       elem.items = { location: dictLocation( elem.expand ) }; // TODO: array location
     return initFromColumns( elem, elem.expand );
@@ -623,7 +678,7 @@ function populate( model ) {
         setMemberParent( col, id, query );
       }
     }
-    forEachGeneric( query, 'elements', e => initElem( e, query ) );
+    forEachGeneric( query, 'elements', initElem );
     return true;
   }
 
@@ -655,45 +710,20 @@ function populate( model ) {
     return '';
   }
 
-  function initElem( elem, query ) {
+  function initElem( elem ) {
+    // TODO: we could share code with initMembers/init() in define.js
     if (elem.type && !elem.type.$inferred)
-      return;                 // explicit type -> enough or directType()
+      return;                 // explicit type -> enough or getOrigin()
     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 = setLink( 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 || elem.expand)
-      return;
-    // TODO: or should we push elems with `expand` sibling to extra list for better messages?
-    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 );
-    const item = elem.value.path[elem.value.path.length - 1];
-    if (nav.navigation && nav.item === item) {
-      // sourceElem, alias.sourceElem, mixin:
-      // redirectImplicitly( elem, origin );
-      pushLink( nav.navigation, '_projections', elem );
-    }
-    else if (elem._pathHead?.kind === '$inline' && elem.value.path.length === 1) {
-      const hpath = elem._pathHead.value?.path;
-      const head = hpath?.length === 1 && hpath[0]._navigation;
-      // Alias .{ elem } - but not with Alias.{ $magic }: consider for ON-rewrite
-      if (head?.kind === '$tableAlias' && item.id.charAt(0) !== '$')
-        pushLink( head.elements[item.id], '_projections', elem );
+    if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
+      if (!elem.target)   // TODO: we might issue an error if there is a target
+        elem.type = { ...elem.value.type, $inferred: 'cast' };
     }
+    if (elem.foreignKeys)       // REDIRECTED with explicit foreign keys
+      forEachGeneric( elem, 'foreignKeys', (key, name) => initKey( key, name, elem ) );
   }
 
   function initKey( key, name, elem ) {
@@ -733,8 +763,8 @@ function populate( model ) {
     // 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,
+    // if (envParent) console.log('S2:',location.line,location.col,
+    //             envParent?.name,envParent?._origin?.name,
     //             Object.keys(env),Object.keys(elements))
     for (const name in env) {
       const navElem = env[name];
@@ -793,8 +823,9 @@ function populate( model ) {
   }
 
   function columnEnv( envParent, query ) { // etc.  wildcard._pathHead;
+    // if (envParent) console.log( 'CE:', envParent._origin, query );
     return (envParent)
-      ? environment( directType( envParent ) || envParent )
+      ? environment( getOrigin( envParent ) ) // not the col with expand, but the referred
       : userQuery( query )._combined;
   }
 
@@ -830,9 +861,9 @@ function populate( model ) {
     setArtifactLink( path[0], origin );
     setLink( queryElem, '_origin', origin );
     // set _projections when inline with table alias:
-    const alias = pathHead?.value?.path?.[0]?._navigation;
-    if (alias?.kind === '$tableAlias')
-      pushLink( alias.elements[name], '_projections', queryElem );
+    // const alias = pathHead?.value?.path?.[0]?._navigation;
+    // if (alias?.kind === '$tableAlias')
+    //   pushLink( alias.elements[name], '_projections', queryElem );
   }
 
   // called by expandWildcard():
@@ -847,7 +878,7 @@ function populate( model ) {
     setArtifactLink( path[1], sourceElem );
     // TODO: or should we set the _artifact/_effectiveType directly to the target?
     setArtifactLink( queryElem.value, sourceElem );
-    pushLink( navElem, '_projections', queryElem );
+    // pushLink( navElem, '_projections', queryElem );
     // TODO: _effectiveType?
   }
 
@@ -1013,18 +1044,20 @@ function populate( model ) {
     const exposed = preferred.length ? preferred : descendants;
     if (exposed.length < 2)
       return exposed || [];
-    let min = null;
+    let min = [];
     for (const e of exposed) {
-      if (!min || min._ancestors && min._ancestors.includes(e)) {
-        min = e;
+      if (min.every( m => m._ancestors?.includes( e ))) {
+        min = [ e ];
       }
-      else if (!e._ancestors || !e._ancestors.includes( min )) {
+      else if (min.length !== 1 || !e._ancestors?.includes( min[0] )) {
+        if (elemScope === '' && options.testMode)
+          throw new CompilerAssertion( `Scope for ${ target } in service ${ service } is empty`);
         if (elemScope === '')
           return [];
-        return exposed;
+        min.push( e );
       }
     }
-    return [ min ];
+    return min;
   }
 
   // Scoped redirections -----------------------------------------------------
@@ -1253,48 +1286,11 @@ function populate( model ) {
     setLink( art, '_service', service );
     setLink( art, '_block', model.$internal );
     initArtifact( art, !!autoexposed );
-    // populate view (phase 2 of resolver has to be repeated as the view was created afterwards)
-    populateView( art );
+    effectiveType( art );    // TODO: necessary? see traverseElementEnvironments()
     // TODO: try to set locations of elements locations of orig target elements
     newAutoExposed.push( art );
     return art;
   }
 }
 
-// Return condensed info about reference in select item
-// - tableAlias.elem       -> { navigation: navElem, item: path[1], tableAlias }
-// - sourceElem (in query) -> { navigation: navElem, item: path[0], tableAlias }
-// - mixinElem             -> { navigation: mixinElement, item: path[0] }
-// - $projection.elem      -> also $self.item -> { item: path[1], tableAlias: $self }
-// - $self                 -> { item: undefined, tableAlias: $self }
-// - $parameters.P, :P     -> {}
-// - $now, current_date    -> {}
-// - undef, redef          -> {}
-// With 'navigation': store that navigation._artifact is projected
-// With 'navigation': rewrite its ON condition
-// With navigation: Do KEY propagation
-//
-// TODO: copy of fn in resolve.js; used just once here - do it differently here
-// and then delete the function here
-function pathNavigation( ref ) {
-  // currently, indirectly projectable elements are not included - we might
-  // keep it this way!  If we want them to be included - be aware: cycles
-  if (!ref._artifact)
-    return {};
-  let item = ref.path && ref.path[0];
-  const root = item && item._navigation;
-  if (!root)
-    return {};
-  if (root.kind === '$navElement')
-    return { navigation: root, item, tableAlias: root._parent };
-  if (root.kind === 'mixin')
-    return { navigation: root, item };
-  item = ref.path[1];
-  if (root.kind === '$self')
-    return { item, tableAlias: root };
-  if (root.kind !== '$tableAlias' || ref.path.length < 2)
-    return {};                // should not happen
-  return { navigation: root.elements[item.id], item, tableAlias: root };
-}
-
 module.exports = populate;