@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/compiler/resolve.js

@@ -46,30 +46,24 @@ const {
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
-const { searchName, weakLocation } = require('../base/messages');
+const { weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
 const { typeParameters } = require('./builtins');
 
-const { kindProperties } = require('./base');
 const {
+  pushLink,
   setLink,
   setArtifactLink,
-  annotationHasEllipsis,
-  pathName,
-  linkToOrigin,
   setMemberParent,
   withAssociation,
-  storeExtension,
   dependsOn,
   dependsOnSilent,
-  setExpandStatusAnnotate,
   testExpr,
   targetMaxNotOne,
   traverseQueryPost,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
-const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for('cds.$location');
 
@@ -87,19 +81,11 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
-    checkAnnotate,
-    initAnnotations,
-    copyAnnotationsForExtensions,
-    attachAndEmitValidNames,
     lateExtensions,
-    applyTypeExtensions,
     effectiveType,
-    directType,
+    getOrigin,
     resolveType,
     resolveTypeArgumentsUnchecked,
-    populateQuery,
-    layeredAssignments,
-    assignmentsOfHighestLayers,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
   Object.assign( model.$functions, {
@@ -117,7 +103,11 @@ function resolve( model ) {
     // addImplicitForeignKeys() in populate.js, as we might need to know the
     // foreign keys in populate.js (foreign key access w/o JOINs).
 
-    // Phase 3: calculate keys along simple queries in collected views:
+    // Phase 2+3: calculate keys along simple queries in collected views:
+    model._entities = Object.values( model.definitions )
+      .filter( art => art.$effectiveSeqNo )
+      .sort( (x, y) => x.$effectiveSeqNo - y.$effectiveSeqNo );
+    model._entities.forEach( setNavigationProjections );
     model._entities.forEach( propagateKeyProps );
     // While most dependencies leading have been added at this point, new
     // cycles could be added later (e.g. via assocs in where conditions),
@@ -126,14 +116,9 @@ function resolve( model ) {
     // Phase 4: resolve all artifacts:
     forEachDefinition( model, resolveRefs );
     forEachGeneric( model, 'vocabularies', resolveRefs );
-    // for builtin types
-    forEachGeneric( model.definitions.cds, '_subArtifacts', chooseAnnotationsInArtifact);
-    forEachGeneric( model.definitions['cds.hana'], '_subArtifacts', chooseAnnotationsInArtifact);
-    // Phase 6: apply ANNOTATE on auto-exposed entities and unknown artifacts:
-    lateExtensions( annotateMembers );
-    if (model.extensions)
-      model.extensions.map( annotateUnknown );
-    // Phase 7: report cyclic dependencies:
+    // create “super” ANNOTATE statements for annotations on unknown artifacts:
+    lateExtensions();
+    // report cyclic dependencies:
     detectCycles( model.definitions, ( user, art, location ) => {
       if (location) {
         error( 'ref-cyclic', [ location, user ], { art }, {
@@ -146,9 +131,38 @@ function resolve( model ) {
   }
 
   //--------------------------------------------------------------------------
-  // Phase 3: calculate propagated KEYs
+  // Phase 2+3: calculate propagated KEYs
   //--------------------------------------------------------------------------
 
+  function setNavigationProjections( view ) {
+    if (!view.$queries)
+      return;
+    for (const query of view.$queries) {
+      forEachGeneric( query, 'elements', ( elem ) => {
+        if (!elem._origin || elem.expand || !elem.value)
+          return;
+        // TODO: what about elements where _origin is set without value?
+        // TODO: or should we push elems with `expand` sibling to extra list for
+        // better messages?  (Whatever that means exaclty.)
+        const nav = pathNavigation( elem.value );
+        const { path } = elem.value;
+        const item = path[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' && 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 );
+        }
+      } );
+    }
+  }
+
   function propagateKeyProps( view ) {
     // Second argument true ensure that `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
@@ -293,16 +307,17 @@ function resolve( model ) {
   function resolveRefs( art ) {
     if (art.builtin)
       return;
-    // console.log(message( null, art.location, art, {}, 'Info','REFS').toString())
-    // console.log(message( null, art.location, art, {target:art.target}, 'Info','RR').toString())
+    // console.log(info( null, [ art.location, art ], {}, 'REFS').toString());
+    // console.log(info( null, [ art.location, art ], { art: art.target || 'none' },
+    //   'RR: $(ART)').toString());
     const parent = art._parent;
     const allowedInMain = [ 'entity', 'aspect', 'event' ].includes( adHocOrMainKind( art ) );
     const isTopLevelElement = parent && (parent.kind !== 'element' || parent.targetAspect);
-    if (art.key && art.key.val && !art.key.$inferred && !(allowedInMain && isTopLevelElement)) {
+    if (art.key?.val && !art.key.$inferred && !(allowedInMain && isTopLevelElement)) {
       warning( 'unexpected-key', [ art.key.location, art ],
-               { '#': allowedInMain ? 'sub' : 'std' }, {
-                 std: 'KEY is only supported for elements in an entity or an aspect',
-                 sub: 'KEY is only supported for top-level elements',
+               { '#': allowedInMain ? 'sub' : 'std', keyword: 'key' }, {
+                 std: '$(KEYWORD) is only supported for elements in an entity or an aspect',
+                 sub: '$(KEYWORD) is only supported for top-level elements',
                });
     }
     if (art.targetAspect && !(allowedInMain && isTopLevelElement)) {
@@ -348,7 +363,7 @@ function resolve( model ) {
       if (elemtype && effectiveType( elemtype )) {
         const assocType = getAssocSpec( elemtype ) || {};
         if (assocType.on && !obj.on)
-          obj.on = { $inferred: 'rewrite' };
+          obj.on = { $inferred: 'rewrite' }; // TODO: no extra rewrite here
         if (assocType.targetAspect) {
           error( 'composition-as-type-of', [ obj.type.location, art ], {},
                  'A managed aspect composition element can\'t be used as type' );
@@ -406,9 +421,7 @@ function resolve( model ) {
     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
-
+    // TODO: or should we set silent dependencies in init()?
     if (obj.elements) {           // silent dependencies
       forEachGeneric( obj, 'elements', elem => dependsOnSilent( art, elem ) );
     }
@@ -424,14 +437,14 @@ function resolve( model ) {
 
     resolveExpr( art.default, 'default', art );
     resolveExpr( art.value, 'expr', art, undefined, art.expand || art.inline );
-    if (art.value && !art.type && !art.target && !art.elements)
-      inferTypeFromCast( art );
-
-    if (art.kind === 'element' || art.kind === 'mixin')
-      effectiveType( art );
-
-    annotateMembers( art );     // TODO recheck - recursively, but also forEachMember below
-    chooseAnnotationsInArtifact( art );
+    if (art.type?.$inferred === 'cast')
+      inferTypePropertiesFromCast( art );
+    if (art.value) {
+      if (art.$syntax === 'calc')
+        checkCalculatedElement(art);
+      else if (art.type && !art.$inferred )
+        checkStructureCast(art);
+    }
 
     forEachMember( art, resolveRefs, art.targetAspect );
 
@@ -452,435 +465,98 @@ function resolve( model ) {
     }
   }
 
-  // Return type containing the assoc spec (keys, on); note that no
-  // propagation/rewrite has been done yet, cyclic dependency must have been
-  // checked before!
-  function getAssocSpec( type ) {
-    const cyclic = new Set(); // TODO(#8942): May not be necessary if effectiveType() is adapted.
-    // only to be called without cycles
-    while (type && !cyclic.has(type)) {
-      cyclic.add(type);
-      if (type.on || type.foreignKeys || type.targetAspect)
-        return type;
-      type = directType( type );
-    }
-    return null;
-  }
-
-  function inferTypeFromCast( elem ) {
-    // TODO: think about CAST checks in checks.js
-    const { op, type } = elem.value;
-    if (op && op.val === 'cast' && type && type._artifact) {
-      // op.val is also correctly set with CSN input
-      elem.type = { ...type, $inferred: 'cast' };
-      setArtifactLink( elem.type, type._artifact );
-      for (const prop of typeParameters.list) {
-        if (elem.value[prop])
-          elem[prop] = { ...elem.value[prop], $inferred: 'cast' };
+  function checkCalculatedElement( art ) {
+    const loc = [ art.value.location, art ];
+    if (art._parent.kind === 'element') {
+      // TODO: Support calculated elements in structures.
+      //       The checks below are already aware of those.
+      message( 'def-unsupported-calc-elem', loc, { '#': 'nested' } );
+    }
+
+    const allowedInKind = [ 'entity', 'aspect', 'element' ];
+    let parent = art._parent;
+    while (parent.kind === 'element')
+      parent = parent._parent;
+
+    if (!allowedInKind.includes(art._main.kind)) {
+      if (art.$inferred === 'include') {
+        // even for include-chains, we find the correct ref due to element-expansion.
+        const include = art._main.includes.find(i => i._artifact === art._origin._main);
+        error('ref-invalid-calc-elem', [ include.location || art.value.location, art ],
+              { '#': art._main.kind });
       }
-    }
-  }
-
-  // Phase 4 - annotations ---------------------------------------------------
-
-  function annotateUnknown( ext ) {
-    // extensions may have annotations for elements/actions/... which may
-    // themselves may be unknown
-    forEachMember(ext, annotateUnknown);
-
-    if (ext.$extension) // extension for known artifact -> already applied
-      return;
-    annotateMembers( ext );
-    chooseAnnotationsInArtifact( ext );
-  }
-
-  /**
-   * @param {XSN.Artifact} art
-   * @param {XSN.Extension[]} [extensions]
-   * @param {string} [prop]
-   * @param {string} [name]
-   * @param {object} [parent]
-   * @param {string} [kind]
-   */
-  function annotateMembers( art, extensions, prop, name, parent, kind ) {
-    const showMsg = !art && parent && parent.kind !== 'annotate';
-    if (!art && extensions && extensions.length) {
-      if (Array.isArray( parent ))
-        return;
-      const parentExt = extensionFor(parent);
-      art = parentExt[prop] && parentExt[prop][name];
-      if (!art) {
-        art = {
-          kind,                 // for setMemberParent()
-          name: { id: name, location: extensions[0].name.location },
-          location: extensions[0].location,
-        };
-        setMemberParent( art, name, parentExt, prop );
-        art.kind = 'annotate';  // after setMemberParent()!
-      }
-    }
-
-    for (const ext of extensions || []) {
-      if ('_artifact' in ext.name) // already applied
-        continue;
-      setArtifactLink( ext.name, art );
-
-      if (art) {
-        checkAnnotate( ext, art );
-        initAnnotations( ext, ext._block, ext.kind ); // TODO: do in define.js
-        copyAnnotationsForExtensions( ext, art );
-        // eslint-disable-next-line no-shadow
-        forEachMember( ext, ( elem, name, prop ) => {
-          storeExtension( elem, name, prop, art, ext._block );
-        });
-      }
-      if (showMsg) {
-        // somehow similar to checkDefinitions():
-        const feature = kindProperties[parent.kind][prop];
-        if (prop === 'elements' || prop === 'enum') {
-          if (!feature) {
-            warning( 'anno-unexpected-elements', [ ext.name.location, art ], {},
-                     'Elements only exist in entities, types or typed constructs' );
-          }
-          else {
-            const isEntity = (parent.returns?.type || parent.type)?._artifact?.kind === 'entity';
-            let variant = parent.enum ? 'enum' : 'element';
-            if (isEntity)
-              variant = 'entity-element';
-            else if (parent.returns)
-              variant = 'returns';
-            notFound( 'anno-undefined-element', ext.name.location, art,
-                      { '#': variant, art: parent, name },
-                      parent.elements || parent.enum );
-          }
-        }
-        else if (prop === 'actions') {
-          if (!feature) {
-            warning( 'anno-unexpected-actions', [ ext.name.location, art._parent || art ], {},
-                     'Actions and functions only exist top-level and for entities' );
-          }
-          else {
-            notFound( 'anno-undefined-action', ext.name.location, art,
-                      { art: searchName( parent, name, 'action' ) },
-                      parent.actions );
-          }
-        }
-        else if (!feature) {
-          warning( 'anno-unexpected-params', [ ext.name.location, art ], {},
-                   'Parameters only exist for actions or functions' );
-        } // TODO: entities betaMod
-        else {
-          notFound( 'anno-undefined-param', ext.name.location, art,
-                    { art: searchName( parent, name, 'param' ) },
-                    parent.params );
-        }
-      }
-    }
-    if (art?._annotate) {
-      if (art.kind === 'action' || art.kind === 'function') {
-        expandParameters( art );
-        if (art.returns)
-          effectiveType( art.returns );
+      else {
+        error( 'def-invalid-calc-elem', loc, { '#': art._main.kind } );
       }
-      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) // explicit $expand on aor needed
-        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' );
-      // }
-    }
-
-    if (art?._extendType) {
-      // Only works because annotateMembers is called in resolveRefs() _after_ `.type` was resolved.
-      // TODO: If we allow extending included elements, we may need custom $expand,
-      //       similar to annotate above.
-      art._extendType.forEach(resolveRefs);
-      applyTypeExtensions(art);
-    }
-
-    return;
-
-    function notFound( msgId, location, address, args, validDict ) {
-      // TODO: probably move this to shared.js and use for EXTEND, too
-      const msg = message( msgId, [ location, address ], args );
-      attachAndEmitValidNames(msg, validDict);
-    }
-
-    // eslint-disable-next-line no-shadow
-    function annotate( obj, kind, prop, altProp, parent = obj ) {
-      const dict = art._annotate[prop];
-      if (dict && art._annotate[prop])
-        setExpandStatusAnnotate( art, 'annotate' );
-      const env = obj[prop] || altProp && obj[altProp] || null;
-      for (const n in dict)
-        annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
-    }
-  }
-
-  function expandParameters( action ) {
-    // see also expandElements()
-    if (!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 = 'expanded';
-        }
-      }
-      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: 'expanded',
-        };
-        setLink( art.returns, '_parent', art );
-        setLink( art.returns, '_main', art._main || art );
-        setLink( art.returns, '_origin', origin.returns );
-      }
+    else if (!allowedInKind.includes(parent.kind)) {
+      error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
     }
-  }
-
-  function extensionFor( art ) {
-    if (art.kind === 'annotate')
-      return art;
-    if (art._extension)
-      return art._extension;
-
-    // $extension means: already applied
-    const ext = {
-      kind: art.kind,           // set kind for setMemberParent()
-      $extension: 'exists',
-      location: art.location,    // location( extension to existing art ) = location(art)
-    };
-    const { location } = art.name;
-    if (!art._main) {
-      ext.name = {
-        path: [ { id: art.name.absolute, location } ],
-        location,
-        absolute: art.name.absolute,
-      };
-      if (model.extensions)
-        model.extensions.push(ext);
+    else if (effectiveType(art)?.elements) {
+      if (art.type)
+        error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
       else
-        model.extensions = [ ext ];
+        error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
     }
     else {
-      ext.name = { id: art.name.id, location };
-      const parent = extensionFor( art._parent );
-      const kind = kindProperties[art.kind].normalized || art.kind;
-      // enums would be first in elements
-      if ( parent[kindProperties[kind].dict] &&
-           parent[kindProperties[kind].dict][art.name.id] )
-        throw new CompilerAssertion(art.name.id);
-      setMemberParent( ext, art.name.id, parent, kindProperties[kind].dict );
-    }
-    ext.kind = 'annotate';    // after setMemberParent()!
-    setLink( art, '_extension', ext );
-    setArtifactLink( ext.name, art );
-    if (art.returns)
-      ext.$syntax = 'returns';
-    return ext;
-  }
-
-  /**
-   * Goes through all (applied) annotations in the given artifact and chooses one
-   * if multiple exist according to the module layer.
-   *
-   * @param {XSN.Artifact} art
-   */
-  function chooseAnnotationsInArtifact( art ) {
-    for (const prop in art) {
-      if (prop.charAt(0) === '@')
-        chooseAssignment( prop, art );
-    }
-    if (art.doc)
-      chooseAssignment( 'doc', art );
-  }
-
-  function chooseAssignment( annoName, art ) {
-    let anno = art[annoName];
-    if (!Array.isArray( anno )) { // just one assignment -> use it
-      if (!annotationHasEllipsis( anno ))
-        return;
-      anno = [ anno ];
-    }
-    // console.log('ASSIGN:',art.name.absolute,annoName)
-    const scheduledAssignments = [];
-    // sort assignment according to layer (define is bottom layer):
-    const layeredAnnos = layeredAssignments( anno );
-    let cont = true;
-    while (cont) {
-      const { assignments, issue } = assignmentsOfHighestLayers( layeredAnnos );
-      let index = assignments.length;
-      cont = !!index;           // safety
-      while (--index >= 0) {
-        const a = assignments[index];
-        scheduledAssignments.push( a );
-        if (!annotationHasEllipsis( a )) {
-          cont = false;
-          break;
+      const noTruthyAllowed = [ 'localized', 'key', 'virtual' ];
+      for (const prop of noTruthyAllowed) {
+        if (art[prop]?.val) {
+          // probably better than a parse error (which is good for DEFAULT vs calc),
+          // also appears with parse-cdl:
+          error('def-invalid-calc-elem', loc, { '#': prop });
+          return; // one error is enough
         }
       }
-      if (issue) {
-        // eslint-disable-next-line no-nested-ternary
-        const msg = (issue === true)
-          ? 'anno-duplicate'
-          : (index >= 0) ? 'anno-duplicate-unrelated-layer' : 'anno-unstable-array';
-        const variant = annoName === 'doc' ? 'doc' : 'std';
-        for (const a of assignments) {
-          if (!a.$errorReported) {
-            message( msg, [ a.name?.location || a.location, art ],
-                     { '#': variant, anno: annoName } );
-          }
-        }
-      }
-      // else if (index > 0)  -- if we allow multiple assignments in one file - the last wins
     }
-    // Now apply the assignments - all but the first have a '...'
-    let result = null;
-    scheduledAssignments.reverse();
-    for (const a of scheduledAssignments)
-      result = applyAssignment( result, a, art, annoName );
-    art[annoName] = result.name ? result
-      : Object.assign( {}, scheduledAssignments[scheduledAssignments.length - 1], result );
   }
 
-  function applyAssignment( previousAnno, anno, art, annoName ) {
-    const hasBase = previousAnno?.literal === 'array';
-    if (!previousAnno) {
-      const firstEllipsis = annotationHasEllipsis( anno );
-      if (!firstEllipsis)
-        return anno;
-      if (anno.$priority) {   // already complained about with Define
-        const loc = firstEllipsis.location || anno.name.location;
-        message( 'anno-unexpected-ellipsis-layers', [ loc, art ], { code: '...' } );
+  function checkStructureCast( art ) {
+    const elem = (art.value.op?.val === 'cast')
+      ? art.value.args[0]?._artifact
+      : art.value._artifact;
+    if (elem && art.type) { // has explicit type
+      if (art.type._artifact?.elements) {
+        error('type-cast-to-structured', [ art.type.location, art ], {},
+              'Can\'t cast to structured element');
       }
-      previousAnno = { val: [] };
-    }
-    else if (previousAnno.literal !== 'array') {
-      // TODO: If we introduce sub-messages, point to the non-array base value.
-      error( 'anno-mismatched-ellipsis', [ anno.name.location, art ], { code: '...' } );
-      previousAnno = { val: [] };
-    }
-    const previousValue = previousAnno.val;
-    let prevPos = 0;
-    const result = [];
-    for (const item of anno.val) {
-      const ell = item && item.literal === 'token' && item.val === '...';
-      if (!ell) {
-        result.push( item );
-      }
-      else {
-        let upToSpec = item.upTo && checkUpToSpec( item.upTo, art, annoName, true );
-        while (prevPos < previousValue.length) {
-          const prevItem = previousValue[prevPos++];
-          result.push( prevItem );
-          if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
-            upToSpec = false;
-            break;
-          }
-        }
-        if (upToSpec && hasBase) {
-          // non-matched UP TO; if there is no base to apply to, there is already an error.
-          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
-                   'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
-        }
+      else if (elem.elements) { // TODO: calc elements
+        error('type-cast-structured', [ art.type.location, art ], {},
+              'Structured elements can\'t be cast to a different type');
       }
     }
-    // console.log('TP:',previousValue.map(se),anno.val.map(se),'->',result.map(se))
-    return { val: result, literal: 'array' };
   }
-  // function se(a) { return a.upTo ? [a.val,a.upTo.val] : a.val ; }
 
-  function checkUpToSpec( upToSpec, art, annoName, isFullUpTo ) {
-    const { literal } = upToSpec;
-    if (!isFullUpTo) {          // inside struct of UP TO
-      if (literal !== 'struct' && literal !== 'array' )
-        return true;
-    }
-    else if (literal === 'struct') {
-      return Object.values( upToSpec.struct ).every( v => checkUpToSpec( v, art, annoName ) );
-    }
-    else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
-      return true;
+  // Return type containing the assoc spec (keys, on); note that no
+  // propagation/rewrite has been done yet, cyclic dependency must have been
+  // checked before!
+  function getAssocSpec( type ) {
+    // only to be called without cycles
+    let unmanaged = null;
+    while (type) {
+      if (type.on)              // if unmanaged, continue trying to find targetAspect
+        unmanaged = type;
+      else if (type.foreignKeys || type.targetAspect)
+        return type;
+      type = getOrigin( type );
     }
-    error( null, [ upToSpec.location, art ],
-           { anno: annoName, code: '... up to', '#': literal },
-           {
-             std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
-             array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
-             // eslint-disable-next-line max-len
-             struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
-             boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
-             null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
-           } );
-    return false;
+    return unmanaged;
   }
 
-  function equalUpTo( previousItem, upToSpec ) {
-    if (!previousItem)
-      return false;
-    if ('val' in upToSpec) {
-      if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
-        return true;
-      const typeUpTo = typeof upToSpec.val;
-      const typePrev = typeof previousItem.val;
-      if (typeUpTo === 'number')
-        return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
-      if (typePrev === 'number')
-        return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
-    }
-    else if (upToSpec.path) {
-      return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
-    }
-    else if (upToSpec.sym) {
-      return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
+  function inferTypePropertiesFromCast( elem ) {
+    for (const prop of typeParameters.list) {
+      if (elem.value[prop])
+        elem[prop] = { ...elem.value[prop], $inferred: 'cast' };
     }
-    else if (upToSpec.struct && previousItem.struct) {
-      return Object.entries( upToSpec.struct )
-        .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
-    }
-    return false;
-  }
-
-  function normalizeRef( node ) { // see to-csn.js
-    const ref = pathName( node.path );
-    return node.variant ? `${ ref }#${ node.variant.id }` : ref;
   }
 
   // Phase 4 - queries and associations --------------------------------------
 
   function resolveQuery( query ) {
-    if (!query._main)           // parse error
+    if (!query._main || !query._effectiveType) // parse error
       return;
-    traverseQueryPost( query, null, populateQuery ); // TODO: still necessary?
+    // TODO: or set silent dependencies in init?
+    forEachGeneric( query, 'elements', elem => dependsOnSilent( query, elem ) );
     forEachGeneric( query, '$tableAliases', ( alias ) => {
       // console.log( info( null, [alias.location,alias], 'SQA:' ).toString() );
       if (alias.kind === 'mixin')
@@ -889,6 +565,7 @@ function resolve( model ) {
         // pure path has been resolved, resolve args and filter now:
         resolveExpr( alias, 'from', query._parent );
     } );
+    // if (!query.$inlines) console.log('RQ:',query)
     for (const col of query.$inlines)
       resolveExpr( col.value, 'expr', col, undefined, true );
     // for (const col of query.$inlines)
@@ -1002,13 +679,9 @@ function resolve( model ) {
       return; // avoid subsequent errors
     }
     else if (target && !obj.foreignKeys && target.kind === 'entity') {
-      if (obj.$inferred === 'REDIRECTED') {
+      // redirected or explicit type cds.Association, ...
+      if (obj.$inferred === 'REDIRECTED' || obj.type?._artifact?.internal)
         addImplicitForeignKeys( art, obj, target );
-      }
-      else if (obj.type && obj.type._artifact && obj.type._artifact.internal) {
-        // cds.Association, ...
-        addImplicitForeignKeys( art, obj, target );
-      }
     }
 
     if (target && !target.$inferred) {
@@ -1072,8 +745,10 @@ function resolve( model ) {
   // TODO: add this somehow to tweak-assocs.js ?
   function resolveRedirected( elem, target ) {
     setLink( elem, '_redirected', null ); // null = do not touch path steps after assoc
-    const assoc = directType( elem );
+    const assoc = getOrigin( elem );
     const origType = assoc && effectiveType( assoc );
+    if (origType === 0)
+      return;
     if (!origType || !origType.target) {
       const path = (elem.value && elem.value.path);
       const loc = (path && path[path.length - 1] || elem.value || elem).location;
@@ -1240,11 +915,13 @@ function resolve( model ) {
     //       Also: For enums, it points to the enum type, which is why this trick is needed.
     // TODO(#8942): May not be necessary if effectiveType() is adapted.  Furthermore, the enum
     //              trick may be removed if effectiveType() does not stop at enums.
+    // TODO: this is wrong - we must check typeArt.enum, not its effectiveType
+    // TODO: this function is not complete(!): parallel `elements` and `length`, … - rework function
     const cyclic = new Set();
     let effectiveTypeArt = effectiveType( typeArt );
     while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
       cyclic.add(effectiveTypeArt);
-      const underlyingEnumType = directType(effectiveTypeArt);
+      const underlyingEnumType = getOrigin(effectiveTypeArt);
       if (underlyingEnumType)
         effectiveTypeArt = effectiveType(underlyingEnumType);
       else
@@ -1261,7 +938,7 @@ function resolve( model ) {
       if (artWithType[param] !== undefined) {
         if (!params.includes(param)) {
           // Whether the type ref itself is a builtin or a custom type with a builtin as base.
-          const type = directType(artWithType);
+          const type = getOrigin(artWithType);
 
           let variant;
           if (type.builtin)
@@ -1274,6 +951,7 @@ function resolve( model ) {
             // effectiveType is not a builtin -> array or structured
             variant = 'non-scalar';
 
+          // console.log(typeArt.name,artWithType.name,effectiveTypeArt.name)
           error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
             '#': variant, prop: param, art: artWithType.type, type: effectiveTypeArt,
           });
@@ -1347,7 +1025,7 @@ function resolve( model ) {
   }
 
   function resolveParamsAndWhere( step, expected, user, extDict, isLast ) {
-    const alias = step._navigation && step._navigation.kind === '$tableAlias' && step._navigation;
+    const alias = (step._navigation?.kind === '$tableAlias') ? step._navigation : null;
     const type = alias || effectiveType( step._artifact );
     const art = (type && type.target) ? type.target._artifact : type;
     if (!art)
@@ -1360,14 +1038,19 @@ function resolve( model ) {
       if (step.where)
         resolveExpr( step.where, 'filter', user, environment( type ) );
     }
-    else if (step.where && step.where.location || step.cardinality ) {
+    else if (step.where?.location || step.cardinality ) {
       const location = combinedLocation( step.where, step.cardinality );
+      let variant = alias ? 'tableAlias' : 'std';
+      if (expected === 'from')
+        variant = 'from';
       // XSN TODO: filter$location including […]
-      message( 'expr-no-filter', [ location, user ], { '#': expected },
-               {
-                 std: 'A filter can only be provided when navigating along associations',
-                 from: 'A filter can only be provided for the source entity or associations',
-               } );
+      message( 'expr-no-filter', [ location, user ], { '#': variant }, {
+        std: 'A filter can only be provided when navigating along associations',
+        // to help users for `… from E:toF { toF[…].x }`
+        // eslint-disable-next-line max-len
+        tableAlias: 'A filter can only be provided when navigating along associations, but found table alias',
+        from: 'A filter can only be provided for the source entity or associations',
+      } );
     }
   }