@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/resolve.js

@@ -62,14 +62,14 @@ const {
   testExpr,
   targetMaxNotOne,
   traverseQueryPost,
-  traverseExpr,
+  linkToOrigin,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
 
-const $location = Symbol.for('cds.$location');
+const $location = Symbol.for( 'cds.$location' );
 
-const $inferred = Symbol.for('cds.$inferred');
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 // TODO: make this part of specExpected in shared.js
 // (standard: not possible on last if !ref.$expected → ref.scope: '$exists')
@@ -87,18 +87,20 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    traverseExpr,
     createRemainingAnnotateStatements,
     effectiveType,
     getOrigin,
-    resolveType,
+    getInheritedProp,
     resolveTypeArgumentsUnchecked,
   } = model.$functions;
   Object.assign( model.$functions, {
     resolveExpr,
+    addForeignKeyNavigations,
   } );
 
   const ignoreSpecifiedElements
-    = isDeprecatedEnabled(model.options, 'ignoreSpecifiedQueryElements');
+    = isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' );
 
   return doResolve();
 
@@ -125,14 +127,21 @@ function resolve( model ) {
     // create “super” ANNOTATE statements for annotations on unknown artifacts:
     createRemainingAnnotateStatements();
     // report cyclic dependencies:
-    detectCycles( model.definitions, ( user, art, location ) => {
+    detectCycles( model.definitions, ( user, art, location, semanticLoc ) => {
       if (location) {
-        error( 'ref-cyclic', [ location, user ], { art }, {
+        model.$assert = null;
+        const msg = semanticLoc && 'target';
+        error( 'ref-cyclic', [ location, semanticLoc || user ], { art, '#': msg }, {
           std: 'Illegal circular reference to $(ART)',
           element: 'Illegal circular reference to element $(MEMBER) of $(ART)',
-        });
+          target: 'Illegal circular reference to target $(ART)',
+        } );
       }
-    });
+    } );
+    if (model.$assert) {
+      error( '$internal-expecting-cyclic', null, {},
+             'INTERNAL: the compiler should have issued an Error[ref-cyclic]' );
+    }
     return model;
   }
 
@@ -149,22 +158,52 @@ function resolve( model ) {
           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 exactly.)
+        //       better messages?  (Whatever that means exactly.)
         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) {
+
+        if (elem._pathHead?.kind === '$inline' && path.length === 1) {
+          const item = path[0];
           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 );
         }
+        else if (nav.navigation) { // not set for $self.…
+          // Path could start with table alias; get start index
+          let index = path.indexOf(nav.item);
+          if (index === -1)
+            return;
+
+          let navItem = nav.navigation;
+          if (path[index].where || path[index].args)
+            return;
+          ++index;
+          while (navItem && index < path.length) {
+            const step = path[index];
+            if (!step?.id || step.where || step.args)
+              break;
+            if (!navItem.elements?.[step.id]) {
+              const elements = navItem._origin?.elements ||
+                navItem._origin?.target?._artifact?.elements;
+              if (!elements)
+                break;
+              // Only link available path steps (navigation tree).
+              const origin = elements[step.id];
+              const member = linkToOrigin( origin, step.id, navItem, 'elements',
+                                           navItem.path?.location, true );
+              member.$inferred = 'expanded';
+              member.kind = '$navElement';
+            }
+            navItem = navItem.elements[step.id];
+            setLink( step, '_navigation', navItem );
+            ++index;
+          }
+          // Last path step, if found, is a simple projection
+          if (index === path.length && navItem)
+            pushLink( navItem, '_projections', elem );
+        }
       } );
     }
   }
@@ -319,13 +358,32 @@ function resolve( model ) {
     const parent = art._parent;
     const allowedInMain = [ 'entity', 'aspect', 'event' ].includes( adHocOrMainKind( art ) );
     const isTopLevelElement = parent && (parent.kind !== 'element' || parent.targetAspect);
-    if (art.key?.val && !art.key.$inferred && !(allowedInMain && isTopLevelElement)) {
-      warning( 'unexpected-key', [ art.key.location, art ],
-               { '#': 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',
-               });
+
+    // Check KEY (TODO: make this an extra function)
+    const { key } = art;
+    if (key?.val && !key.$inferred) {
+      // With unmanaged/composition as key, we complain at the `key` keyword, not
+      // the `on` condition / the aspect, because the easiest fix would be to
+      // simply remove the keyword.  Text and message-id are accordingly.
+      // This fits nicely with exposing unmanaged/composition with explicit `key`.
+      // We do not complain about unmanaged/composition inside struct keys.
+      // (Actually, aspect compositions are not supported as sub elements anyway.)
+      if (getInheritedProp( art, 'targetAspect' )) {
+        error( 'def-invalid-key', [ key.location, art ], { '#': 'composition' } );
+        // TODO: test with managed composition exposed with explicit KEY
+      }
+      else if (art.target && getInheritedProp( art, 'on' )) {
+        error( 'def-invalid-key', [ key.location, art ], { '#': 'unmanaged' } );
+      }
+      else if (!allowedInMain || !isTopLevelElement) {
+        warning( 'def-unsupported-key', [ art.key.location, art ],
+                 { '#': 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)) {
       message( 'type-managed-composition', [ art.targetAspect.location, art ],
                { '#': allowedInMain ? 'sub' : 'std' } );
@@ -334,7 +392,7 @@ function resolve( model ) {
       for (const include of art.includes) {
         const struct = include._artifact;
         if (struct && struct.kind !== 'type' && struct.elements &&
-            Object.values( struct.elements ).some( e => e.targetAspect)) {
+            Object.values( struct.elements ).some( e => e.targetAspect )) {
           message( 'type-managed-composition', [ include.location, art ],
                    { '#': struct.kind, art: struct } );
         }
@@ -358,7 +416,7 @@ function resolve( model ) {
     }
     if (obj.items) {            // TODO: make this a while in v2 (also items proxy)
       obj = obj.items || obj; // the object which has type properties
-      effectiveType(obj);
+      effectiveType( obj );
     }
     if (obj.type) {             // TODO: && !obj.type.$inferred ?
       if (obj !== (art.returns || art)) // not already checked
@@ -385,13 +443,13 @@ function resolve( model ) {
         if (elemtype.category === 'relation' && obj.type.path.length > 0 &&
           !obj.target && !obj.targetAspect) {
           const isCsn = (obj._block && obj._block.$frontend === 'json');
-          error('type-missing-target', [ obj.type.location, obj ],
-                { '#': isCsn ? 'csn' : 'std', type: elemtype.name.absolute }, {
-                  // We don't say "use 'association to <target>" because the type could be used
-                  // in action parameters, etc. as well.
-                  std: 'The type $(TYPE) can\'t be used directly because it\'s compiler internal',
-                  csn: 'Type $(TYPE) is missing a target',
-                });
+          error( 'type-missing-target', [ obj.type.location, obj ],
+                 { '#': isCsn ? 'csn' : 'std', type: elemtype.name.absolute }, {
+                   // We don't say "use 'association to <target>" because the type could be used
+                   // in action parameters, etc. as well.
+                   std: 'The type $(TYPE) can\'t be used directly because it\'s compiler internal',
+                   csn: 'Type $(TYPE) is missing a target',
+                 } );
         }
       }
     }
@@ -426,21 +484,26 @@ function resolve( model ) {
       forEachGeneric( obj.targetAspect, 'elements', elem => dependsOnSilent( art, elem ) );
     }
     if (obj.foreignKeys) {       // silent dependencies
-      forEachGeneric( obj, 'foreignKeys', (elem) => {
-        dependsOnSilent( art, elem );
-      } );
+      // Avoid strange ref-cyclic if managed composition is key (check comes later)
+      // TODO: the following is already done by addImplicitForeignKeys()!
+      if (obj.$inferred !== 'aspect-composition') {
+        forEachGeneric( obj, 'foreignKeys', (elem) => {
+          dependsOnSilent( art, elem );
+        } );
+      }
       addForeignKeyNavigations( art );
     }
 
     resolveExpr( art.default, 'default', art );
-    resolveExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'expr'), art );
+    // TODO: distinguish not by $syntax (it is semantics), but whether in query
+    resolveExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
     if (art.type?.$inferred === 'cast')
       inferTypePropertiesFromCast( art );
     if (art.value) {
       if (art.$syntax === 'calc')
-        checkCalculatedElement(art);
+        checkCalculatedElement( art );
       else if (art.type && !art.$inferred )
-        checkStructureCast(art);
+        checkStructureCast( art );
     }
 
     forEachMember( art, resolveRefs, art.targetAspect );
@@ -450,14 +513,16 @@ function resolve( model ) {
 
     if (!ignoreSpecifiedElements && art.elements$ && art.elements) {
       for (const id in art.elements$) {
-        resolveRefs(art.elements$[id]);
-        checkSpecifiedElement(art.elements[id], art.elements$[id]);
+        resolveRefs( art.elements$[id] );
+        checkSpecifiedElement( art.elements[id], art.elements$[id] );
       }
     }
 
     /**
      * Check whether the signature of the specified element matches that of the inferred one.
      *
+     * TODO: resolveRefs() is already too long → do not add sub functions
+     *
      * TODO:
      *  - This function has a lot of quite similar code blocks; it should be refactored to
      *    combine them.
@@ -474,96 +539,97 @@ function resolve( model ) {
 
       // Check explicit types: If either side has one, so must the other.
       const sType = specifiedElement.type?._artifact;
-      const iType = getInferredPropFromOrigin('type')?._artifact || inferredElement;
+      const iType = getInferredPropFromOrigin( 'type' )?._artifact || inferredElement;
 
       // xor: could be missing a type;
       // FIXME: The coding above returns incorrect iType for expand on associations
       if (!specifiedElement.type && inferredElement.type) {
-        error('query-mismatched-element', [ specifiedElement.location, user ], {
+        error( 'query-mismatched-element', [ specifiedElement.location, user ], {
           '#': !specifiedElement.type ? 'missing' : 'extra', name: user.name.id, prop: 'type',
-        });
+        } );
         return;
       }
       // If specified type is `null`, type could not be resolved.
       else if (sType && sType !== iType) {
         const typeName = iType?.name && sType?.name ? 'typeName' : 'type';
-        error('query-mismatched-element', [
+        const othertype = typeName !== 'type' && iType || '';
+        error( 'query-mismatched-element', [
           specifiedElement.type.location || specifiedElement.location, user,
         ], {
           '#': typeName,
           name: user.name.id,
           type: sType,
-          othertype: iType,
-        });
+          othertype,
+        } );
         return;
       }
 
       // This relies on (element) expansion!  Check that both sides have the following properties.
       // On the inferred side, they are likely expanded.
-      if (!hasXorPropMismatch('elements') && !hasXorPropMismatch('items') &&
-        !hasXorPropMismatch('target') && !hasXorPropMismatch('enum')) {
+      if (!hasXorPropMismatch( 'elements' ) && !hasXorPropMismatch( 'items' ) &&
+        !hasXorPropMismatch( 'target' ) && !hasXorPropMismatch( 'enum' )) {
         // Element are already traversed via elements$ merging.
 
         // only check items, if the specified one is not expanded/inferred
         if (specifiedElement.items && !specifiedElement.items.$inferred)
-          checkSpecifiedElement(inferredElement.items, specifiedElement.items, specifiedElement);
+          checkSpecifiedElement( inferredElement.items, specifiedElement.items, specifiedElement );
 
-        if (specifiedElement.target &&
+        if (specifiedElement.target?._artifact && inferredElement.target?._artifact &&
             specifiedElement.target._artifact !== inferredElement.target._artifact) {
-          error('query-mismatched-element', [
+          error( 'query-mismatched-element', [
             specifiedElement.target.location || specifiedElement.location, user,
           ], {
             '#': 'target',
             name: user.name.id,
             target: specifiedElement.target,
             art: inferredElement.target,
-          });
+          } );
         }
 
         if (specifiedElement.foreignKeys) {
-          const sKeys = Object.keys(specifiedElement.foreignKeys);
+          const sKeys = Object.keys( specifiedElement.foreignKeys );
           /** @type {any} */
           let iKeys = inferredElement;
           if (inferredElement._effectiveType !== 0) {
             while (iKeys._origin && !iKeys.foreignKeys)
               iKeys = iKeys._origin;
           }
-          iKeys = Object.keys(iKeys.foreignKeys || {});
-          if (sKeys.length !== iKeys.length || sKeys.some(key => !iKeys.includes(key))) {
-            error('query-mismatched-element', [
+          iKeys = Object.keys( iKeys.foreignKeys || {} );
+          if (sKeys.length !== iKeys.length || sKeys.some( fkey => !iKeys.includes( fkey ) )) {
+            error( 'query-mismatched-element', [
               specifiedElement.foreignKeys.location || specifiedElement.location, user,
             ], {
               '#': 'foreignKeys',
               name: user.name.id,
               target: specifiedElement.target,
               art: inferredElement.target,
-            });
+            } );
           }
         }
 
         if (specifiedElement.virtual) {
-          const iVirtual = getInferredPropFromOrigin('virtual')?.val || false;
+          const iVirtual = getInferredPropFromOrigin( 'virtual' )?.val || false;
           if (!specifiedElement.virtual.val !== !iVirtual) {
-            error('query-mismatched-element', [
+            error( 'query-mismatched-element', [
               specifiedElement.virtual.location || specifiedElement.location, user,
             ], {
               '#': 'prop', prop: 'virtual', name: user.name.id,
-            });
+            } );
           }
         }
 
         // If cardinality is not specified, the compiler uses the inferred one.
         if (specifiedElement.cardinality) {
           const sCardinality = specifiedElement.cardinality;
-          const iCardinality = getInferredPropFromOrigin('cardinality');
+          const iCardinality = getInferredPropFromOrigin( 'cardinality' );
           if (!iCardinality) {
-            error('query-mismatched-element', [
+            error( 'query-mismatched-element', [
               sCardinality.location || specifiedElement.location, user,
             ], {
               '#': 'extra',
               prop: 'cardinality',
               name: user.name.id,
-            });
+            } );
           }
           else {
             // Note: Cardinality does not have sourceMin (CSN "srcmin").
@@ -575,7 +641,7 @@ function resolve( model ) {
             for (const prop in props) {
               if (sCardinality[prop]?.val === iCardinality[prop]?.val)
                 continue;
-              error('query-mismatched-element', [
+              error( 'query-mismatched-element', [
                 sCardinality[prop]?.location || sCardinality.location || specifiedElement.location,
                 user,
               ], {
@@ -583,53 +649,59 @@ function resolve( model ) {
                 '#': !sCardinality[prop] ? 'missing' : (iCardinality[prop] ? 'prop' : 'extra'),
                 prop: `cardinality.${ props[prop] }`,
                 name: user.name.id,
-              });
+              } );
             }
           }
         }
 
         if (specifiedElement.value) {
-          error('query-unexpected-property', [
+          error( 'query-unexpected-property', [
             specifiedElement.value.location || specifiedElement.location, user,
           ], {
             '#': 'calculatedElement', prop: 'value', name: user.name.id,
-          });
+          } );
         }
 
         if (specifiedElement.key) { // TODO: `|| inferredElement.key?.val`, once to.sql is fixed
           // TODO: Do not use _origin chain for key; has been propagated in propagateKeyProps().
-          const iKey = getInferredPropFromOrigin('key')?.val;
+          const iKey = getInferredPropFromOrigin( 'key' )?.val;
           // If "key" is specified or truthy in the inferred element, the values must match.
           if (!iKey !== !specifiedElement.key?.val) {
-            error('query-mismatched-element', [
+            error( 'query-mismatched-element', [
               specifiedElement.key?.location || specifiedElement.location, user,
             ], {
               '#': specifiedElement.key ? 'prop' : 'missing', prop: 'key', name: user.name.id,
-            });
+            } );
           }
         }
 
-        if (specifiedElement.enum) {
-          const iEnum = inferredElement.enum || inferredElement.value?.enum;
-          forEachGeneric(specifiedElement, 'enum', (sVal, name) => {
-            const iVal = iEnum[name];
-            if (!iVal) {
-              error('query-mismatched-element', [ specifiedElement.location, user ], {
-                '#': 'std',
-                name: user.name.id,
-                prop: 'enum',
-              });
+        if (specifiedElement.enum && !specifiedElement.$expand) {
+          // TODO: ".value" is necessary due to recompilation: The compiler does not copy
+          //       "enum" out of ".value", i.e. casts, only "type", changing the _effectiveType.
+          const iEnumValues = inferredElement.enum || inferredElement.value?.enum;
+          const sEnumValues = specifiedElement.enum;
+          for (const name in specifiedElement.enum) {
+            // TODO: See TODO above; issue is cast()
+            const sEnumEntry = sEnumValues[name];
+            const iEnumEntry = iEnumValues[name]?._effectiveType || iEnumValues[name];
+            if (!iEnumEntry) {
+              error( 'query-mismatched-element', [ specifiedElement.location, user ], {
+                '#': 'enumExtra', name: user.name.id, id: name,
+              } );
+              break;
             }
-
-            // TODO: Get $expanded enum values
-            /* if (iVal.value?.val !== sVal.value?.val || iVal.value?.['#'] !== sVal.value?.['#']) {
-              error('query-mismatched-element', [ specifiedElement.location, user ], {
-                '#': 'std',
-                name: user.name.id,
-                prop: 'enum',
-              });
-            } */
-          });
+            else {
+              // We allow implicit `val: "<name>"`.
+              const iVal = iEnumEntry.value?.val || iEnumEntry.value?.['#'] || name;
+              const sVal = sEnumEntry.value?.val || sEnumEntry.value?.['#'] || name;
+              if (iVal !== sVal) {
+                error( 'query-mismatched-element', [ specifiedElement.location, user ], {
+                  '#': 'enumVal', name: user.name.id, id: name,
+                } );
+                break;
+              }
+            }
+          }
         }
       }
 
@@ -642,7 +714,7 @@ function resolve( model ) {
           !inferredElement.value?.[prop] !== !specifiedElement[prop]) {
           error( 'query-mismatched-element', [ specifiedElement.location, specifiedElement ], {
             '#': specifiedElement[prop] ? 'extra' : 'missing', name: user.name.id, prop,
-          });
+          } );
           return true;
         }
         return false;
@@ -652,8 +724,8 @@ function resolve( model ) {
         // Inferred property via _origin chain (0 === circular).
         let element = inferredElement;
         if (element._effectiveType !== 0) {
-          while (getOrigin(element) && !element[prop])
-            element = getOrigin(element);
+          while (getOrigin( element ) && !element[prop])
+            element = getOrigin( element );
         }
         return element[prop];
       }
@@ -691,21 +763,21 @@ function resolve( model ) {
     while (parent.kind === 'element')
       parent = parent._parent;
 
-    if (!allowedInKind.includes(art._main.kind)) {
+    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 });
+        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 } );
       }
       else {
         error( 'def-invalid-calc-elem', loc, { '#': art._main.kind } );
       }
     }
-    else if (!allowedInKind.includes(parent.kind)) {
+    else if (!allowedInKind.includes( parent.kind )) {
       error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
     }
-    else if (effectiveType(art)?.elements) {
+    else if (effectiveType( art )?.elements) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
       if (!art.$inferred) {
         if (art.type)
@@ -714,7 +786,7 @@ function resolve( model ) {
           error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
       }
     }
-    else if (effectiveType(art)?.items) {
+    else if (effectiveType( art )?.items) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
       if (!art.$inferred) {
         const isCast = art.type?.$inferred === 'cast';
@@ -730,7 +802,7 @@ function resolve( model ) {
         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 });
+          error( 'def-invalid-calc-elem', loc, { '#': prop } );
           return; // one error is enough
         }
       }
@@ -742,22 +814,19 @@ function resolve( model ) {
       ? 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');
-      }
-      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');
-      }
+      if (art.type._artifact?.elements)
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'to-structure' } );
+      else if (elem.elements) // TODO: calc elements
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-structure' } );
     }
   }
 
-  // Return type containing the assoc spec (keys, on); note that no
-  // propagation/rewrite has been done yet, cyclic dependency must have been
-  // checked before!
+  /**
+   * 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
@@ -793,7 +862,7 @@ function resolve( model ) {
     } );
     // if (!query.$inlines) console.log('RQ:',query)
     for (const col of query.$inlines)
-      resolveExpr( col.value, 'expr', col );
+      resolveExpr( col.value, 'column', col );
     // for (const col of query.$inlines)
     //   if (!col.value.path) throw new CompilerAssertion(col.name.element)
     if (query !== query._main._leadingQuery) // will be done later
@@ -801,22 +870,27 @@ function resolve( model ) {
     if (query.from)
       resolveJoinOn( query.from );
     if (query.where)
-      resolveExpr( query.where, 'expr', query ); // TODO: extra 'where'?
+      resolveExpr( query.where, 'where', query );
     if (query.groupBy)
-      resolveBy( query.groupBy, 'expr', 'expr' ); // TODO: extra 'groupBy'?
-    resolveExpr( query.having, 'expr', query );   // TODO: extra 'having' or 'where'?
+      resolveBy( query.groupBy, 'groupBy', 'groupBy' );
+    resolveExpr( query.having, 'having', query );
     if (query.$orderBy)       // ORDER BY from UNION:
       // TODO clarify: can I access the tab alias of outer queries?  If not:
       // 4th arg query._main instead query._parent.
-      resolveBy( query.$orderBy, 'order-by-set-ref', 'order-by-set-expr' );
+      resolveBy( query.$orderBy, 'orderBy-set-ref', 'orderBy-set-expr' );
     if (query.orderBy) {       // ORDER BY
     // search in `query.elements` after having checked table aliases of the current query
-      resolveBy( query.orderBy, 'order-by-ref', 'order-by-expr' );
+      resolveBy( query.orderBy, 'orderBy-ref', 'orderBy-expr' );
       // TODO: disallow resulting element ref if in expression!
       // Necessary to check it in the compiler as it might work with other semantics on DB!
       // (we could downgrade it to a warning if name is equal to unique source element name)
       // TODO: Some helping text mentioning an alias name would be useful
     }
+    for (const limit of query.$limit || []) // LIMIT from UNION:
+      resolveLimit( limit );
+    if (query.limit)
+      resolveLimit( query.limit );
+
     return;
 
     function resolveJoinOn( join ) {
@@ -824,27 +898,35 @@ function resolve( model ) {
         for (const j of join.args)
           resolveJoinOn( j );
         if (join.on)
-          resolveExpr( join.on, 'joinOn', query );
-          // TODO: check restrictions according to join "query"
+          resolveExpr( join.on, 'join-on', join );
       }
     }
 
-    // Note the strange name resolution (dynamic part) for ORDER BY: the same
-    // as for select items if it is an expression, but first look at select
-    // item alias (i.e. like `$projection.NAME` if it is a path.  If it is an
-    // ORDER BY of an UNION, do not allow any dynamic path in an expression,
-    // and only allow the elements of the leading query if it is a path.
-    //
-    // This seems to be similar, but different in SQLite 3.22.0: ORDER BY seems
-    // to bind stronger than UNION (see <SQLite>/src/parse.y), and the name
-    // resolution seems to use select item aliases from all SELECTs of the
-    // UNION (see <SQLite>/test/tkt2822.test).
+    /**
+     * Note the strange name resolution (dynamic part) for ORDER BY: the same
+     * as for select items if it is an expression, but first look at select
+     * item alias (i.e. like `$projection.NAME` if it is a path.  If it is an
+     * ORDER BY of an UNION, do not allow any dynamic path in an expression,
+     * and only allow the elements of the leading query if it is a path.
+     *
+     * This seems to be similar, but different in SQLite 3.22.0: ORDER BY seems
+     * to bind stronger than UNION (see <SQLite>/src/parse.y), and the name
+     * resolution seems to use select item aliases from all SELECTs of the
+     * UNION (see <SQLite>/test/tkt2822.test).
+     */
     function resolveBy( array, refMode, exprMode ) {
       for (const value of array ) {
         if (value)
           resolveExpr( value, (value.path ? refMode : exprMode), query );
       }
     }
+
+    function resolveLimit( limit ) {
+      if (limit.rows)
+        resolveExpr( limit.rows, 'limit-rows', query );
+      if (limit.offset)
+        resolveExpr( limit.offset, 'limit-offset', query );
+    }
   }
 
   function resolveTarget( art, obj ) {
@@ -875,7 +957,7 @@ function resolve( model ) {
                  { '#': isComposition ? 'comp' : 'std' }, {
                    std: 'An unmanaged association can\'t be defined as type',
                    comp: 'An unmanaged composition can\'t be defined as type',
-                 });
+                 } );
         // TODO: also warning if inside structure
       }
       else {
@@ -933,7 +1015,7 @@ function resolve( model ) {
       const serviceKeys = keyElementNames( issue.target.elements );
       const modelKeys = keyElementNames( modelTarget.elements );
       if (modelKeys.length !== serviceKeys.length) {
-        issue.id = modelKeys.find( id => !serviceKeys.includes( id ));
+        issue.id = modelKeys.find( id => !serviceKeys.includes( id ) );
         issue['#'] = 'missing';
       }
       else if (!modelKeys.every( (id, index) => id === serviceKeys[index] )) {
@@ -986,7 +1068,7 @@ function resolve( model ) {
   }
 
   function addImplicitForeignKeys( art, obj, target ) {
-    obj.foreignKeys = Object.create(null);
+    obj.foreignKeys = Object.create( null );
     forEachInOrder( target, 'elements', ( elem, name ) => {
       if (elem.key && elem.key.val) {
         const { location } = obj.target;
@@ -1002,22 +1084,59 @@ function resolve( model ) {
         // the following should be done automatically, since we run resolveRefs after that
         setArtifactLink( key.targetElement, elem );
         setArtifactLink( key.targetElement.path[0], elem );
-        setLink( key, '_effectiveType', effectiveType(elem) );
-        dependsOn(key, elem, location);
-        dependsOnSilent(art, key);
+        setLink( key, '_effectiveType', effectiveType( elem ) );
+        dependsOn( key, elem, location );
+        // TODO TMP: instead, make managed composition of aspects and unmanaged
+        // assocs not depend on their `on` condition (empty `_deps` after resolve)
+        if (art.$inferred !== 'aspect-composition')
+          dependsOnSilent( art, key );
       }
-    });
+    } );
     obj.foreignKeys[$inferred] = 'keys';
   }
 
-  function addForeignKeyNavigations( art ) {
-    art.$keysNavigation = Object.create(null);
+  /**
+   * Add reference tree from foreign key reference back to foreign key of association.
+   *
+   * For `type T: Association to Target { foo as bar, elem.sub }`, this function adds:
+   *
+   *   '$keysNavigation': {
+   *     foo: { _artifact: 'type:“T”/key:“bar”' },
+   *     elem: {
+   *       '$keysNavigation': { sub: { _artifact: 'type:“T”/key:“sub”' } }
+   *     }
+   *
+   * This function complains if two foreign keys point to the same target element
+   * (`Association to Target { foo as bar, foo }`) or overlapping target elements
+   * (`Association to Target { elem.sub, elem }`).  In `resolvePath`, the compiler
+   * already forbids to follow associations in foreign key refs.
+   *
+   * This ref tree could also be used in a core-compiler check which is now part
+   * of to.sql: refs in the `on` condition of unmanaged associations cannot follow
+   * associations other to foreign key refs.
+   *
+   * This ref tree is only created for originally defined managed associations
+   * (including those created by the compiler, like the `up_` association), not
+   * for derived association like for `type DerivedT: T`, or exposed ones.
+   */
+  function addForeignKeyNavigations( art, silent = false ) {
+    art.$keysNavigation = Object.create( null );
+    const keys = [];
+    // Basically sort foreign keys according to length of target element ref.
+    // This way, we complain about ref to sub element (`elem.sub`) even if it
+    // comes earlier than the ref to structure element (`elem`).
     forEachGeneric( art, 'foreignKeys', ( key ) => {
-      if (!key.targetElement || !key.targetElement.path)
-        return;
+      const path = key.targetElement?.path;
+      if (path) {
+        const arr = keys[path.length] || (keys[path.length] = []);
+        arr.push( key );
+      }
+    } );
+    for (const key of keys.flat()) {
       let dict = art.$keysNavigation;
-      const last = key.targetElement.path[key.targetElement.path.length - 1];
-      for (const item of key.targetElement.path) {
+      const { path } = key.targetElement;
+      const last = path[path.length - 1];
+      for (const item of path) {
         let nav = dict[item.id];
         if (!nav) {
           nav = {};
@@ -1025,16 +1144,24 @@ function resolve( model ) {
           if (item === last)
             setArtifactLink( nav, key );
           else
-            nav.$keysNavigation = Object.create(null);
+            nav.$keysNavigation = Object.create( null );
         }
         else if (item === last || nav._artifact) {
-          error( 'duplicate-key-ref', [ item.location, key ], {},
-                 'The same target reference has already been used in a key definition' );
-          return;
+          if (silent)
+            break;
+          const name = nav._artifact?.name.id;
+          const text = (item !== last) ? 'sub' : 'std';
+          error( 'duplicate-key-ref', [ item.location, key ], { '#': text, name }, {
+            std: 'Foreign key $(NAME) already refers to the same target element',
+            // eslint-disable-next-line max-len
+            sub: 'Foreign key $(NAME) already refers to the target element whose sub element is again referred to here',
+            // TODO: please add ideas for a better text, e.g. to (closed) PR #11325
+          } );
+          break;
         }
         dict = nav.$keysNavigation;
       }
-    } );
+    }
   }
 
   // TODO: add this somehow to tweak-assocs.js ?
@@ -1067,6 +1194,8 @@ function resolve( model ) {
       }
     }
     const origTarget = origType.target._artifact;
+    // console.log(require('../model/revealInternalProperties').ref(elem),
+    //             !!origTarget,!!origType._effectiveType,!!origType.target)
     if (!origTarget || !target)
       return;
 
@@ -1100,7 +1229,7 @@ function resolve( model ) {
                 target: 'The redirected target $(ART) is a complex view',
                 // eslint-disable-next-line max-len
                 targetOp: 'The redirected target $(ART) is a complex view with $(KEYWORD)',
-              });
+              } );
         break;
       }
       target = from._artifact;
@@ -1116,7 +1245,7 @@ function resolve( model ) {
     let redirected = null;
     chain.reverse();
     let news = [ { chain, sources: [ target ] } ];
-    const dict = Object.create(null);
+    const dict = Object.create( null );
     while (news.length) {
       const outer = news;
       news = [];
@@ -1194,65 +1323,9 @@ function resolve( model ) {
 
   // Resolve the type and its arguments if applicable.
   function resolveTypeExpr( art, user ) {
-    const typeArt = resolveType( art.type, user );
-    if (typeArt) {
+    const typeArt = resolvePath( art.type, 'type', user );
+    if (typeArt)
       resolveTypeArgumentsUnchecked( art, typeArt, user );
-      checkTypeArguments( art, typeArt );
-    }
-  }
-
-  /**
-   * Check the type arguments on `artWithType`.
-   * If the effective type is an array or structured type, an error is emitted.
-   */
-  function checkTypeArguments( artWithType, typeArt ) {
-    // Note: `_effectiveType` point to `artWithType` itself, if it is an enum type,
-    //       descend to the origin in this case.
-    // TODO: this function is not complete(!): parallel `elements` and `length`, … - rework function
-    // TODO: check relationship with resolveTypeArgumentsUnchecked()
-    let effectiveTypeArt = effectiveType( typeArt );
-    while (effectiveTypeArt?.enum)
-      effectiveTypeArt = effectiveType( getOrigin( effectiveTypeArt ) );
-    if (!effectiveTypeArt)
-      return; // e.g. illegal definition references, cycles, ...
-
-    const params = effectiveTypeArt.parameters &&
-      effectiveTypeArt.parameters.map(p => p.name || p) || [];
-
-    for (const param of typeParameters.list) {
-      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 = getOrigin(artWithType);
-
-          let variant;
-          if (type.builtin)
-            // `.type` is already a builtin: use a nicer message.
-            variant = 'builtin';
-          else if (effectiveTypeArt.builtin)
-            // base type is a builtin, i.e. a scalar
-            variant = 'type';
-          else
-            // 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,
-          });
-          break; // Avoid spam: Only emit the first error.
-        }
-        else if (!typeParameters.expectedLiteralsFor[param].includes(artWithType[param].literal)) {
-          error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
-            '#': 'incorrect-type',
-            prop: param,
-            code: artWithType[param].literal,
-            names: typeParameters.expectedLiteralsFor[param],
-          });
-          break; // Avoid spam: Only emit the first error.
-        }
-      }
-    }
   }
 
   function resolveExpr( expr, exprCtx, user ) {
@@ -1264,6 +1337,7 @@ function resolve( model ) {
       resolveTypeExpr( expr, user._user || user );
 
     if (expr.path) {
+      // TODO: re-think this $expected: 'exists' thing
       if (expr.$expected === 'exists') {
         error( 'expr-unexpected-exists', [ expr.location, user ], {},
                'An EXISTS predicate is not expected here' );
@@ -1296,7 +1370,7 @@ function resolve( model ) {
   function resolveParamsAndWhere( step, expected, user, isLast ) {
     const alias = (step._navigation?.kind === '$tableAlias') ? step._navigation : null;
     const type = alias || effectiveType( step._artifact );
-    const art = (type && type.target) ? type.target._artifact : type;
+    const art = type?.target ? type.target._artifact : type;
     if (!art)
       return;
     const entity = art.kind === 'entity' &&
@@ -1317,7 +1391,7 @@ function resolve( model ) {
       if (expected === 'from')
         variant = 'from';
       // XSN TODO: filter$location including […]
-      message( 'expr-no-filter', [ location, user ], { '#': variant }, {
+      message( 'expr-unexpected-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
@@ -1329,26 +1403,26 @@ function resolve( model ) {
 
   function resolveParams( dict, art, entity, expected, user, stepLocation ) {
     if (!entity || !entity.params) {
-      let first = dict[Object.keys(dict)[0]];
-      if (Array.isArray(first))
+      let first = dict[Object.keys( dict )[0]];
+      if (Array.isArray( first ))
         first = first[0];
-      message( 'args-no-params',
-               [ dict[$location] ||
-                 dictLocation( dict, first && first.name && first.name.location || stepLocation),
+      error( 'expr-unexpected-argument',
+             [ dict[$location] || dictLocation( dict, first?.name?.location || stepLocation ),
                user ],
-               { art, '#': (entity ? 'entity' : expected ) },
-               {
-                 std: 'Parameters can only be provided when navigating along associations',
-                 from: 'Parameters can only be provided for the source entity or associations',
-                 // or extra message id for entity?
-                 entity: 'Entity $(ART) has no parameters',
-               } );
+             { art, '#': (entity ? 'entity' : expected ) },
+             {
+               std: 'Parameters can only be provided when navigating along associations',
+               from: 'Parameters can only be provided for the source entity or associations',
+               // or extra message id for entity?
+               entity: 'Unexpected arguments for entity $(ART) without parameters',
+             } );
       return;
     }
-    const exp = (expected === 'from') ? 'expr' : expected;
-    if (Array.isArray(dict)) {
-      message( 'args-expected-named', [ dict[0] && dict[0].location || stepLocation, user ], {},
-               'Named parameters must be provided for the entity' );
+    const exp = (expected === 'from') ? 'from-args' : expected;
+    if (Array.isArray( dict )) {
+      const loc = [ dict[0] && dict[0].location || stepLocation, user ];
+      error( 'expr-expected-named-argument', loc, {},
+             'Expected named parameters for the entity' );
       for (const a of dict)
         resolveExpr( a, exp, user );
       return;
@@ -1357,33 +1431,34 @@ function resolve( model ) {
     for (const name in dict) {
       const param = art.params[name];
       const arg = dict[name];
-      for (const a of Array.isArray(arg) ? arg : [ arg ]) {
+      for (const a of Array.isArray( arg ) ? arg : [ arg ]) {
         setArtifactLink( a.name, param );
         if (!param) {
-          message( 'args-undefined-param', [ a.name.location, user ], { art, id: name },
-                   'Entity $(ART) has no parameter $(ID)' );
+          error( 'expr-undefined-param', [ a.name.location, user ], { art, id: name },
+                 'Entity $(ART) has no parameter $(ID)' );
         }
-        // TODO: Also for other parameters?
-        resolveExpr( a, (expected === 'from') ? 'param-only' : exp, user );
+        resolveExpr( a, exp, user );
       }
     }
   }
 }
 
-// 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: re-think this function, copied in populate.js and tweak-assocs.js
+/**
+ * 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: re-think this function, copied in populate.js and tweak-assocs.js
+ */
 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