@sap/cds-compiler 3.9.4 → 4.0.2

package/lib/compiler/resolve.js

@@ -43,6 +43,7 @@ const {
   forEachMember,
   forEachGeneric,
   forEachInOrder,
+  isDeprecatedEnabled,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
@@ -61,6 +62,7 @@ const {
   testExpr,
   targetMaxNotOne,
   traverseQueryPost,
+  traverseExpr,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
@@ -69,6 +71,10 @@ const $location = Symbol.for('cds.$location');
 
 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')
+const expWithFilter = [ 'from', 'expand', 'inline' ];
+
 // Export function of this file.  Resolve type references in augmented CSN
 // `model`.  If the model has a property argument `messages`, do not throw
 // exception in case of an error, but push the corresponding error object to
@@ -87,21 +93,21 @@ function resolve( model ) {
     resolveType,
     resolveTypeArgumentsUnchecked,
   } = model.$functions;
-  const { environment } = model.$volatileFunctions;
   Object.assign( model.$functions, {
     resolveExpr,
   } );
 
-  /** @type {any} may also be a boolean */
+  const ignoreSpecifiedElements
+    = isDeprecatedEnabled(model.options, 'ignoreSpecifiedQueryElements');
 
   return doResolve();
 
   function doResolve() {
-    // Phase 1: check paths in usings has been moved to kick-start.js Phase 2:
+    // Phase 1: check paths in `usings` has been moved to kick-start.js Phase 2:
     // calculate/init view elements & collect views in order:
     // TODO: It might be that we need to call propagateKeyProps() and
-    // addImplicitForeignKeys() in populate.js, as we might need to know the
-    // foreign keys in populate.js (foreign key access w/o JOINs).
+    //       addImplicitForeignKeys() in populate.js, as we might need to know the
+    //       foreign keys in populate.js (foreign key access w/o JOINs).
 
     // Phase 2+3: calculate keys along simple queries in collected views:
     model._entities = Object.values( model.definitions )
@@ -143,7 +149,7 @@ 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 exaclty.)
+        // better messages?  (Whatever that means exactly.)
         const nav = pathNavigation( elem.value );
         const { path } = elem.value;
         const item = path[path.length - 1];
@@ -390,9 +396,6 @@ function resolve( model ) {
       }
     }
     if (obj.target) {
-      // console.log(obj.name,obj._origin?.name,obj)
-      if (obj._origin && obj._origin.$inferred === 'REDIRECTED')
-        resolveTarget( art, obj._origin );
       // console.log(error( 'test-target', [ obj.location, obj ],
       //   { target: obj.target, kind: obj.kind }, 'Target: $(TARGET), Kind $(KIND)'));
       if (!obj.target.$inferred || obj.target.$inferred === 'aspect-composition')
@@ -406,15 +409,9 @@ function resolve( model ) {
       error( 'non-assoc-in-mixin', [ (obj.type || obj.name).location, art ], {},
              'Only unmanaged associations are allowed in mixin clauses' );
     }
-    if (art.targetElement) {    // in foreign keys
-      const target = parent && parent.target;
-      if (target && target._artifact) {
-        // we just look in target for the path
-        // TODO: also check that we do not follow associations? no args, no filter
-        resolvePath( art.targetElement, 'targetElement', art,
-                     environment( target._artifact ), target._artifact );
-      }
-    }
+    if (art.targetElement)      // in foreign keys
+      resolvePath( art.targetElement, 'targetElement', art );
+
     // Resolve projections/views
     // if (art.query)console.log( info( null, [art.query.location,art.query], 'VQ:' ).toString() );
 
@@ -436,7 +433,7 @@ function resolve( model ) {
     }
 
     resolveExpr( art.default, 'default', art );
-    resolveExpr( art.value, 'expr', art, undefined, art.expand || art.inline );
+    resolveExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'expr'), art );
     if (art.type?.$inferred === 'cast')
       inferTypePropertiesFromCast( art );
     if (art.value) {
@@ -447,13 +444,229 @@ function resolve( model ) {
     }
 
     forEachMember( art, resolveRefs, art.targetAspect );
+    // After the resolving of foreign keys (and adding implicit ones):
+    if (obj.target?.$inferred === '')
+      checkRedirectedUserTarget( art );
+
+    if (!ignoreSpecifiedElements && art.elements$ && art.elements) {
+      for (const id in art.elements$) {
+        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:
+     *  - This function has a lot of quite similar code blocks; it should be refactored to
+     *    combine them.
+     *  - Some checks are not performed because of to.sql() backend "bugs", that affect the
+     *    recompilation, such as flattening removing/not setting "key" where required.
+     *
+     * @param {XSN.Element} inferredElement
+     * @param {XSN.Element} specifiedElement
+     * @param {XSN.Element} user Only used for if specifiedElement is actually an `items`
+     */
+    function checkSpecifiedElement( inferredElement, specifiedElement, user = specifiedElement ) {
+      if (!inferredElement || !specifiedElement)
+        return;
+
+      // Check explicit types: If either side has one, so must the other.
+      const sType = specifiedElement.type?._artifact;
+      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 ], {
+          '#': !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', [
+          specifiedElement.type.location || specifiedElement.location, user,
+        ], {
+          '#': typeName,
+          name: user.name.id,
+          type: sType,
+          othertype: iType,
+        });
+        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')) {
+        // 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);
+
+        if (specifiedElement.target &&
+            specifiedElement.target._artifact !== inferredElement.target._artifact) {
+          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);
+          /** @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', [
+              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;
+          if (!specifiedElement.virtual.val !== !iVirtual) {
+            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');
+          if (!iCardinality) {
+            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").
+            const props = {
+              targetMax: 'max',
+              targetMin: 'min',
+              sourceMax: 'src',
+            };
+            for (const prop in props) {
+              if (sCardinality[prop]?.val === iCardinality[prop]?.val)
+                continue;
+              error('query-mismatched-element', [
+                sCardinality[prop]?.location || sCardinality.location || specifiedElement.location,
+                user,
+              ], {
+                // eslint-disable-next-line no-nested-ternary
+                '#': !sCardinality[prop] ? 'missing' : (iCardinality[prop] ? 'prop' : 'extra'),
+                prop: `cardinality.${ props[prop] }`,
+                name: user.name.id,
+              });
+            }
+          }
+        }
+
+        if (specifiedElement.value) {
+          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;
+          // If "key" is specified or truthy in the inferred element, the values must match.
+          if (!iKey !== !specifiedElement.key?.val) {
+            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',
+              });
+            }
+
+            // 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',
+              });
+            } */
+          });
+        }
+      }
+
+      function hasXorPropMismatch( prop ) {
+        // FIXME: `.value` check should be removed after #11183
+        //   It appears the SQL backends expand a type in cast and add an `enum` property there.
+        //   This property is directly in the `value` property, but not part of `inferredElement`
+        //   which has a `type` property, but no `enum`.
+        if (!inferredElement[prop] !== !specifiedElement[prop] &&
+          !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;
+      }
+
+      function getInferredPropFromOrigin( prop ) {
+        // Inferred property via _origin chain (0 === circular).
+        let element = inferredElement;
+        if (element._effectiveType !== 0) {
+          while (getOrigin(element) && !element[prop])
+            element = getOrigin(element);
+        }
+        return element[prop];
+      }
+    }
+
 
     // Set '@Core.Computed' in the Core Compiler to have it propagated...
     if (art.kind !== 'element' || art['@Core.Computed'])
       return;
-    if (art.virtual && art.virtual.val ||
+    if (art.virtual?.val ||
         art.value &&
         (!art.value._artifact || !art.value.path || // in localization view: _artifact, but no path
+          art.value.stored?.val || // calculated elements on-write are always computed
           art.value._artifact.kind === 'builtin' || art.value._artifact.kind === 'param' )) {
       art['@Core.Computed'] = {
         name: {
@@ -493,10 +706,23 @@ function resolve( model ) {
       error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
     }
     else if (effectiveType(art)?.elements) {
-      if (art.type)
-        error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
-      else
-        error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
+      // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
+      if (!art.$inferred) {
+        if (art.type)
+          error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
+        else
+          error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
+      }
+    }
+    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';
+        error( 'type-unexpected-many', [ (art.type || art.value).location, art ], {
+          '#': (!art.type && 'calc-implicit') || (isCast && 'calc-cast') || 'calc',
+          elemref: art.type ? undefined : { ref: art.value.path },
+        } );
+      }
     }
     else {
       const noTruthyAllowed = [ 'localized', 'key', 'virtual' ];
@@ -567,7 +793,7 @@ function resolve( model ) {
     } );
     // if (!query.$inlines) console.log('RQ:',query)
     for (const col of query.$inlines)
-      resolveExpr( col.value, 'expr', col, undefined, true );
+      resolveExpr( col.value, 'expr', 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
@@ -575,17 +801,17 @@ function resolve( model ) {
     if (query.from)
       resolveJoinOn( query.from );
     if (query.where)
-      resolveExpr( query.where, 'expr', query, query._combined );
+      resolveExpr( query.where, 'expr', query ); // TODO: extra 'where'?
     if (query.groupBy)
-      resolveBy( query.groupBy, 'expr' );
-    resolveExpr( query.having, 'expr', query, query._combined );
+      resolveBy( query.groupBy, 'expr', 'expr' ); // TODO: extra 'groupBy'?
+    resolveExpr( query.having, 'expr', query );   // TODO: extra 'having' or 'where'?
     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-union', query.elements, query._parent );
+      resolveBy( query.$orderBy, 'order-by-set-ref', 'order-by-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', query.elements );
+      resolveBy( query.orderBy, 'order-by-ref', 'order-by-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)
@@ -598,7 +824,7 @@ function resolve( model ) {
         for (const j of join.args)
           resolveJoinOn( j );
         if (join.on)
-          resolveExpr( join.on, 'expr', query, query._combined );
+          resolveExpr( join.on, 'joinOn', query );
           // TODO: check restrictions according to join "query"
       }
     }
@@ -609,23 +835,22 @@ function resolve( model ) {
     // 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 seem to be similar, but different in SQLite 3.22.0: ORDER BY seems
+    // 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, mode, pathDict, q ) {
+    function resolveBy( array, refMode, exprMode ) {
       for (const value of array ) {
         if (value)
-          resolveExpr( value, mode, q || query, value.path && pathDict );
+          resolveExpr( value, (value.path ? refMode : exprMode), query );
       }
     }
   }
 
   function resolveTarget( art, obj ) {
-    if (art !== obj && obj.on && obj.$inferred !== 'REDIRECTED') {
-      message( 'assoc-in-array', [ obj.on.location, art ], {},
-               // TODO: also check parameter parent, two messages?
-               'An association can\'t be used for arrays or parameters' );
+    if (art !== obj && obj.on) {
+      // Unmanaged assoc inside items.  Unmanaged assoc in param handled in resolveRefs()
+      message( 'type-invalid-items', [ obj.on.location, art ], { '#': 'assoc', prop: 'items' } );
       setArtifactLink( obj.target, undefined );
       return;
     }
@@ -653,19 +878,10 @@ function resolve( model ) {
                  });
         // TODO: also warning if inside structure
       }
-      else if (obj.$inferred !== 'REDIRECTED') {
+      else {
         // TODO: extra with $inferred (to avoid messages)?
-        // TODO: in the ON condition of an explicitly provided model entity
-        // which is going to be implicitly redirected, we can never navigate
-        // along associations, even not to the foreign keys (at least if they
-        // are renamed) - introduce extra 'expected' which inspects REDIRECTED
         resolveExpr( obj.on, art.kind === 'mixin' ? 'mixin-on' : 'on', art );
       }
-      else {
-        const elements = Object.create( art._parent.elements );
-        elements[art.name.id] = obj;
-        resolveExpr( obj.on, art.kind === 'mixin' ? 'mixin-on' : 'on', art, elements );
-      }
     }
     else if (art.kind === 'mixin') {
       error( 'assoc-in-mixin', [ obj.target.location, art ], {},
@@ -680,7 +896,7 @@ function resolve( model ) {
     }
     else if (target && !obj.foreignKeys && target.kind === 'entity') {
       // redirected or explicit type cds.Association, ...
-      if (obj.$inferred === 'REDIRECTED' || obj.type?._artifact?.internal)
+      if (obj.type?._artifact?.internal)
         addImplicitForeignKeys( art, obj, target );
     }
 
@@ -691,11 +907,89 @@ function resolve( model ) {
     }
   }
 
+
+  function checkRedirectedUserTarget( art ) {
+    const issue = { target: art.target._artifact };
+    const tgtPath = art.target.path;
+    const modelTarget = tgtPath[tgtPath.length - 1]._artifact; // Array#at comes with node-16.6
+    // Check ON condition: no renamed target element
+    traverseExpr( art.on, 'on-check', art, (expr) => {
+      const { path } = expr;
+      if (!expr?._artifact || path?.length < 2 || issue['#'])
+        return;                 // no path or with error or already found issue
+      const head = (path[0]._navigation?.kind === '$self') ? 1 : 0;
+      if (path[head]._artifact === art)
+        checkAutoRedirectedPathItem( path[head + 1], modelTarget, issue );
+    } );
+    // Check explicit+implicit foreign keys: no renamed target element
+    const implicit = art.foreignKeys?.[$inferred];
+    forEachGeneric( art, 'foreignKeys', (fkey) => {
+      const { targetElement } = fkey;
+      if (targetElement._artifact && !issue['#'])
+        checkAutoRedirectedPathItem( targetElement.path[0], modelTarget, issue, implicit );
+    } );
+    // Check implicit foreign keys: same keys in same order
+    if (implicit && !issue['#']) {
+      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['#'] = 'missing';
+      }
+      else if (!modelKeys.every( (id, index) => id === serviceKeys[index] )) {
+        issue['#'] = 'order';
+      }
+    }
+    if (issue['#']) {
+      /* eslint-disable max-len */
+      message( 'type-expecting-service-target', [ art.target.location, art ], issue, {
+        std: 'Expecting service entity $(TARGET)',
+        ref: 'Expecting service entity $(TARGET); its element $(ID) referred to at line $(LINE), column $(COL) is not from an element with the same name in the provided model target',
+        key: 'Expecting service entity $(TARGET); its key element $(ID) is not from a key element with the same name in the provided model target',
+        missing: 'Expecting service entity $(TARGET); it does not have the key element $(ID) of the provided model target',
+        order: 'Expecting service entity $(TARGET); its key elements are in a different order than those of the provided model target',
+      } );
+      /* eslint-enable max-len */
+    }
+  }
+
+  function keyElementNames( elements ) {
+    const names = [];
+    for (const name in elements) {
+      if (elements[name].key?.val)
+        names.push( name );
+    }
+    return names;
+  }
+
+  function checkAutoRedirectedPathItem( pathItem, modelTarget, issue, isKey = false ) {
+    if (!pathItem)              // $self.assoc
+      return;
+    let targetElem = pathItem._artifact;
+    while (targetElem && targetElem._main !== modelTarget)
+      targetElem = directOrigin( targetElem );
+    if (targetElem?.name.id === pathItem.id && (!isKey || targetElem.key?.val))
+      return;
+    issue.id = pathItem.id;
+    issue.line = pathItem.location.line;
+    issue.col = pathItem.location.col;
+    issue['#'] = (isKey ? 'key' : 'ref');
+  }
+
+  function directOrigin( elem ) {
+    if (!elem._main.query || !elem._origin)
+      return elem._origin;      // included element
+    const { path } = elem.value;
+    const kind = path[0]._navigation?.kind;
+    // TODO: expand/inline (also Alias.*)
+    return [ null, '$navElement', '$tableAlias' ][path.length] === (kind || true) && elem._origin;
+  }
+
   function addImplicitForeignKeys( art, obj, target ) {
     obj.foreignKeys = Object.create(null);
     forEachInOrder( target, 'elements', ( elem, name ) => {
       if (elem.key && elem.key.val) {
-        const { location } = art.target;
+        const { location } = obj.target;
         const key = {
           name: { location, id: elem.name.id, $inferred: 'keys' }, // more by setMemberParent()
           kind: 'key',
@@ -705,6 +999,7 @@ function resolve( model ) {
         };
         setMemberParent( key, name, art );
         dictAdd( obj.foreignKeys, name, key );
+        // 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) );
@@ -911,25 +1206,15 @@ function resolve( model ) {
    * If the effective type is an array or structured type, an error is emitted.
    */
   function checkTypeArguments( artWithType, typeArt ) {
-    // Note: `_effectiveType` may point to `artWithType` itself, if the type is structured.
-    //       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
+    // 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
-    const cyclic = new Set();
+    // TODO: check relationship with resolveTypeArgumentsUnchecked()
     let effectiveTypeArt = effectiveType( typeArt );
-    while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
-      cyclic.add(effectiveTypeArt);
-      const underlyingEnumType = getOrigin(effectiveTypeArt);
-      if (underlyingEnumType)
-        effectiveTypeArt = effectiveType(underlyingEnumType);
-      else
-        break;
-    }
-
+    while (effectiveTypeArt?.enum)
+      effectiveTypeArt = effectiveType( getOrigin( effectiveTypeArt ) );
     if (!effectiveTypeArt)
-      return; // e.g. illegal definition references
+      return; // e.g. illegal definition references, cycles, ...
 
     const params = effectiveTypeArt.parameters &&
       effectiveTypeArt.parameters.map(p => p.name || p) || [];
@@ -970,40 +1255,30 @@ function resolve( model ) {
     }
   }
 
-  function resolveExpr( expr, expected, user, extDict, expandOrInline ) {
-    // TODO: when we have rewritten the resolvePath functions,
-    // define a traverseExpr() in ./utils.js
-    // TODO: extra "expected" 'expand'/'inline' instead o param `expandOrInline`
-    if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
-      return;
-    if (Array.isArray(expr)) {
-      expr.forEach( e => resolveExpr( e, expected, user, extDict ) );
-      return;
-    }
+  function resolveExpr( expr, exprCtx, user ) {
+    traverseExpr( expr, exprCtx, user, (e, c, u) => resolveExprItem( e, c, u ) );
+  }
 
+  function resolveExprItem( expr, expected, user ) {
     if (expr.type) // e.g. cast( a as Integer )
-      resolveTypeExpr( expr, user );
+      resolveTypeExpr( expr, user._user || user );
 
     if (expr.path) {
       if (expr.$expected === 'exists') {
         error( 'expr-unexpected-exists', [ expr.location, user ], {},
                'An EXISTS predicate is not expected here' );
-        // We complain about the EXISTS before, as EXISTS subquery is also not
-        // supported (avoid that word if you do not want to get tickets when it
-        // will be supported), TODO: location of EXISTS
+        // We complain about the EXISTS before, as EXISTS subquery is also not supported
+        // TODO: location of EXISTS, TODO: really do this in define.js
         expr.$expected = 'approved-exists'; // only complain once
       }
-      if (expected instanceof Function) {
-        expected( expr, user, extDict );
-        return;
-      }
-      resolvePath( expr, expected, user, extDict );
+      resolvePath( expr, expected, user );
 
-      const last = !expandOrInline && expr.path[expr.path.length - 1];
+      const last = expr.$expected !== 'approved-exists' && expr.path[expr.path.length - 1];
       for (const step of expr.path) {
         if (step && (step.args || step.where || step.cardinality) &&
             step._artifact && !Array.isArray( step._artifact ) )
-          resolveParamsAndWhere( step, expected, user, extDict, step === last );
+          resolveParamsAndWhere( step, expected, user, step === last );
+        // TODO: delete 4th arg
       }
     }
     else if (expr.query) {
@@ -1016,29 +1291,27 @@ function resolve( model ) {
                'Subqueries are not supported here' );
       }
     }
-    else if (expr.op && expr.args) {
-      const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
-      args.forEach( e => e && resolveExpr( e, e.$expected || expected, user, extDict ) );
-    }
-    if (expr.suffix)
-      expr.suffix.forEach( s => s && resolveExpr( s, expected, user, extDict ) );
   }
 
-  function resolveParamsAndWhere( step, expected, user, extDict, isLast ) {
+  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;
     if (!art)
       return;
-    const entity = (art.kind === 'entity') &&
-      (!isLast || [ 'from', 'exists', 'approved-exists' ].includes( expected )) && art;
+    const entity = art.kind === 'entity' &&
+          (!isLast || user.expand || user.inline || expWithFilter.includes( expected )) &&
+          art;
     if (step.args)
-      resolveParams( step.args, art, entity, expected, user, extDict, step.location );
+      resolveParams( step.args, art, entity, expected, user, step.location );
     if (entity) {
-      if (step.where)
-        resolveExpr( step.where, 'filter', user, environment( type ) );
+      if (step.where) {
+        setLink( step, '_user', user._user || user );
+        const inCalc = (expected === 'calc' || expected === 'calc-filter');
+        resolveExpr( step.where, (inCalc ? 'calc-filter' : 'filter'), step );
+      }
     }
-    else if (step.where?.location || step.cardinality ) {
+    else if (step.where || step.cardinality ) {
       const location = combinedLocation( step.where, step.cardinality );
       let variant = alias ? 'tableAlias' : 'std';
       if (expected === 'from')
@@ -1054,7 +1327,7 @@ function resolve( model ) {
     }
   }
 
-  function resolveParams( dict, art, entity, expected, user, extDict, stepLocation ) {
+  function resolveParams( dict, art, entity, expected, user, stepLocation ) {
     if (!entity || !entity.params) {
       let first = dict[Object.keys(dict)[0]];
       if (Array.isArray(first))
@@ -1077,7 +1350,7 @@ function resolve( model ) {
       message( 'args-expected-named', [ dict[0] && dict[0].location || stepLocation, user ], {},
                'Named parameters must be provided for the entity' );
       for (const a of dict)
-        resolveExpr( a, exp, user, extDict );
+        resolveExpr( a, exp, user );
       return;
     }
     // TODO: allow to specify expected for arguments in in specExpected
@@ -1090,7 +1363,8 @@ function resolve( model ) {
           message( 'args-undefined-param', [ a.name.location, user ], { art, id: name },
                    'Entity $(ART) has no parameter $(ID)' );
         }
-        resolveExpr( a, exp, user, extDict );
+        // TODO: Also for other parameters?
+        resolveExpr( a, (expected === 'from') ? 'param-only' : exp, user );
       }
     }
   }