@sap/cds-compiler 6.4.2 → 6.5.0

package/lib/compiler/resolve.js

@@ -75,7 +75,6 @@ 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
@@ -1557,16 +1556,6 @@ function resolve( model ) {
   }
 
   function resolveExprPath( expr, expected, user ) {
-    // TODO: re-think this $expected: 'exists' thing
-    if (expr.$expected === 'exists') {
-      if (expected !== 'annotation') { // `exists e[…]` allowed in annotation expressions
-        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
-      // TODO: location of EXISTS, TODO: really do this in define.js
-      expr.$expected = 'approved-exists'; // only complain once
-    }
     const ref = resolvePath( expr, expected, user );
 
     if (expected === 'annotation') {
@@ -1588,9 +1577,10 @@ function resolve( model ) {
         last._navigation?.kind === '$tableAlias') // error already reported
       return ref;
 
-    if (expr.$expected === 'approved-exists') {
+    if (expr.$syntax === 'after-exists') {
       if (last.where?.args?.length === 0) {
         // at the moment, empty filter is not allowed on last path step
+        // TODO: allow it at some places
         reportUnexpectedArgsAndFilter( last, expected, user, null, 'last-empty-filter' );
       }
       return ref;

package/lib/compiler/shared.js

@@ -49,6 +49,13 @@ function fns( model ) {
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
     },
+    // scope:'global': for cds.Association and auto-redirected targets
+    $global: {
+      isMainRef: 'all',
+      lexical: null,
+      dynamic: modelDefinitions,
+      notFound: undefinedDefinition,
+    },
     // only used for the main annotate/extend statements, not inner ones:
     annotate: {
       isMainRef: 'all',
@@ -57,6 +64,17 @@ function fns( model ) {
       notFound: undefinedForAnnotate,
       accept: extendableArtifact,
     },
+    'annotate-sec': {
+      isMainRef: 'all',
+      lexical: userBlock,
+      dynamic: modelDefinitions,
+      notFound: undefinedDefinition,
+      messageMap: {
+        'ref-undefined-art': 'ext-undefined-art-sec',
+        'ref-undefined-def': 'ext-undefined-def-sec',
+      },
+      accept: extendableArtifact,
+    },
     extend: {
       isMainRef: 'no-generated',
       lexical: userBlock,
@@ -85,7 +103,7 @@ function fns( model ) {
       accept: acceptEntity,
       noDep: true,
       // special `scope`s for auto-redirections:
-      global: () => ({ isMainRef: 'all', dynamic: modelDefinitions }),
+      global: () => '$global',
     },
     targetAspect: {
       isMainRef: 'no-autoexposed',
@@ -102,6 +120,7 @@ function fns( model ) {
       notFound: undefinedDefinition,
       accept: acceptQuerySource,
       noDep: '',                // dependency special for from
+      args: () => 'from-args',
     },
     type: {
       isMainRef: 'no-autoexposed',
@@ -112,11 +131,11 @@ function fns( model ) {
       accept: acceptTypeOrElement,
       // special `scope`s for CDL parser - TYPE OF (TODO generated?), cds.Association:
       typeOf: typeOfSemantics,
-      global: () => ({
-        isMainRef: 'no-autoexposed',
-        dynamic: modelDefinitions,
-        navigation: staticTarget, // TODO: Object.assign() with main
-      }),
+      global: () => '$global',  // TODO: do we need `navigation: staticTarget`?
+    },
+    $typeOf: {
+      dynamic: typeOfParentDict,
+      navigation: staticTarget,
     },
     // element references without lexical scope (except $self/$projection): -----
     targetElement: {
@@ -125,22 +144,24 @@ function fns( model ) {
       dynamic: targetElements,
       navigation: targetNavigation,
       notFound: undefinedTargetElement,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     filter: {
       lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       notFound: undefinedTargetElement,
-      param: paramSemantics,
+      param: () => '$scopePar',
+      nestedColumn: () => 'filter',
     },
-    'calc-filter': {
+    'calc-filter': {            // TODO: what is so special about this?
       lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       navigation: calcElemNavigation,
       notFound: undefinedTargetElement,
       param: paramUnsupported,
+      filter: () => 'calc-filter',
     },
     default: {
       lexical: null,
@@ -154,7 +175,7 @@ function fns( model ) {
       dollar: true,
       dynamic: () => Object.create( null ),
       notFound: undefinedVariable,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'limit-offset': 'limit-rows',
     // general element / variable references --------------------------------------
@@ -164,7 +185,7 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     having: 'where',
     groupBy: 'where',
@@ -174,22 +195,15 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
       check: checkColumnRef,
-      param: paramSemantics,
-      nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: nestedElements,
-        notFound: undefinedNestedElement,
-        check: checkColumnRef,
-        param: paramSemantics,
-      }),
+      param: () => '$scopePar',
+      nestedColumn: () => '$srcRefInNestedColumn',
     },
     'from-args': {
       lexical: null,
       dollar: true,
       dynamic: () => Object.create( null ),
       notFound: undefinedVariable,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     calc: {
       lexical: justDollarAliases,
@@ -198,6 +212,7 @@ function fns( model ) {
       navigation: calcElemNavigation,
       notFound: undefinedParentElement,
       param: paramUnsupported,
+      filter: () => 'calc-filter',
     },
     'join-on': {
       lexical: tableAliasesAndSelf,
@@ -205,7 +220,7 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       rejectRoot: rejectOwnExceptVisibleAliases,
       notFound: undefinedSourceElement,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     on: {     // unmanaged assoc: outside query, redirected or new assoc in column
       lexical: justDollarAliases,
@@ -216,15 +231,8 @@ function fns( model ) {
       accept: acceptElemOrVarOrSelf,
       check: checkAssocOn,
       param: paramUnsupported,
-      nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: parentElements,
-        navigation: assocOnNavigation,
-        notFound: undefinedParentElement,
-        rewriteProjectionToSelf: true,
-      }),
       rewriteProjectionToSelf: true,
+      nestedColumn: () => '$projRefInNestedColumn',
     },
     'mixin-on': {
       lexical: tableAliasesAndSelf,
@@ -234,15 +242,16 @@ function fns( model ) {
       notFound: undefinedSourceElement,
       accept: acceptElemOrVarOrSelf,
       check: checkAssocOn,
-      param: paramSemantics, // TODO: check that assocs containing param in ON is not published
+      param: () => '$scopePar', // TODO: check that assocs containing param in ON is not published
     },
+    'rewrite-on': {},           // only for traversal when rewriting on condition
     'orderBy-ref': {
       lexical: tableAliasesAndSelf,
       dollar: true,
       dynamic: parentElements,
       notFound: undefinedOrderByElement,
       check: checkOrderByRef,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'orderBy-expr': {
       lexical: tableAliasesAndSelf,
@@ -250,7 +259,7 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'orderBy-set-ref': {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
@@ -259,7 +268,7 @@ function fns( model ) {
       rejectRoot: rejectOwnAliasesAndMixins,
       notFound: undefinedParentElement,
       check: checkOrderByRef,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'orderBy-set-expr': {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
@@ -268,7 +277,7 @@ function fns( model ) {
       rejectRoot: rejectAllOwn,
       notFound: undefinedVariable,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     annotation: { // annotation assignments
       lexical: justDollarAliases,
@@ -277,19 +286,14 @@ function fns( model ) {
       navigation: assocOnNavigation,
       noDep: true,
       notFound: undefinedParentElement,
+      accept: acceptElemOrAnyVar,
+      variableFilter: (dict => dict),
       messageMap: {
         'ref-undefined-element': 'anno-undefined-element',
         'ref-undefined-param': 'anno-undefined-param',
       },
-      param: paramSemantics,
-      nestedColumn: () => ({
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: parentElements,
-        navigation: assocOnNavigation,
-        notFound: undefinedParentElement,
-        rewriteProjectionToSelf: true,
-      }),
+      param: () => '$annotationScopePar',
+      nestedColumn: () => '$projRefInNestedColumn',
     },
     // TODO: introduce some kind of inheritance
     // used by xpr-rewrite.js to resolve rewritten path roots.
@@ -300,17 +304,36 @@ function fns( model ) {
       navigation: assocOnNavigation,
       noDep: true,
       notFound: null,           // no error, just falsy links
-      param: paramSemantics,
-      nestedColumn: () => ({
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: parentElements,
-        navigation: assocOnNavigation,
-        notFound: undefinedParentElement,
-        rewriteProjectionToSelf: true,
-      }),
+      accept: acceptElemOrAnyVar,
+      param: () => '$scopePar',
+      nestedColumn: () => '$projRefInNestedColumn',
+    },
+    $scopePar: {
+      dynamic: artifactParams,
+      notFound: undefinedParam,
+    },
+    $annotationScopePar: {
+      messageMap: {
+        'ref-undefined-element': 'anno-undefined-element',
+        'ref-undefined-param': 'anno-undefined-param',
+      },
+      dynamic: artifactParams,
+      notFound: undefinedParam,
+    },
+    // for `nestedColumn`, these two will be merged with base semantics:
+    $projRefInNestedColumn: {       // for assoc-`on` and annotations
+      lexical: justDollarAliases,
+      dynamic: parentElements,
+      navigation: assocOnNavigation, // like std `environment`, but no dependency
+      rewriteProjectionToSelf: true,
+    },
+    $srcRefInNestedColumn: {       // for column refs
+      lexical: justDollarAliases,
+      dollar: true,
+      dynamic: nestedElements,
+      navigation: environment,
+      notFound: undefinedNestedElement,
     },
-    //
   };
 
   Object.assign( model.$functions, {
@@ -371,7 +394,7 @@ function fns( model ) {
     }
     if (expr.args) {
       const args = Array.isArray( expr.args ) ? expr.args : Object.values( expr.args );
-      for (const arg of args ) {
+      for (const arg of args) {
         if (traverseExpr( arg, exprCtx, user, callback ) === traverseExpr.STOP)
           return traverseExpr.STOP;
       }
@@ -389,16 +412,13 @@ function fns( model ) {
     const exit = callback( step, exprCtx, user );
     if (exit === traverseExpr.STOP)
       return true;
-    if (step.where && exit !== traverseExpr.SKIP &&
-        traverseExpr( step.where,
-                      // TODO: use property in fn dictionary above
-                      ( exprCtx === 'calc' || exprCtx === 'calc-filter'
-                        ? 'calc-filter'
-                        : 'filter' ),
-                      step, callback ) === traverseExpr.STOP)
-      return true;
+    if (step.where && exit !== traverseExpr.SKIP) {
+      const ctx = referenceSemantics[exprCtx].filter?.() || 'filter';
+      if (traverseExpr( step.where, ctx, step, callback ) === traverseExpr.STOP)
+        return true;
+    }
     if (step.args) {
-      const ctx = (exprCtx === 'from') ? 'from-args' : exprCtx;
+      const ctx = referenceSemantics[exprCtx].args?.() || exprCtx;
       const args = Array.isArray( step.args ) ? step.args : Object.values( step.args );
       // TODO: there should be no array `args` on path item
       for (const arg of args) {
@@ -412,7 +432,7 @@ function fns( model ) {
   // Special expression traversal function for `resolveExpr`.  Let's see
   // later whether we can use this version as the general one.
   // If we continue to have separate ones, remove the STOP stuff – it is not
-  // needed for `resolveExpr`.
+  // needed for `resolveExpr`; SKIP is used, though.
 
   function traverseTypedExpr( expr, exprCtx, user, type, callback ) {
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
@@ -565,16 +585,13 @@ function fns( model ) {
     const exit = callback( step, exprCtx, user, null );
     if (exit === traverseExpr.STOP)
       return true;
-    if (step.where && exit !== traverseExpr.SKIP &&
-        traverseTypedExpr( step.where,
-                           // TODO: use property in fn dictionary above
-                           ( exprCtx === 'calc' || exprCtx === 'calc-filter'
-                             ? 'calc-filter'
-                             : 'filter' ),
-                           step, null, callback ) === traverseExpr.STOP)
-      return true;
+    if (step.where && exit !== traverseExpr.SKIP) {
+      const ctx = referenceSemantics[exprCtx].filter?.() || 'filter';
+      if (traverseTypedExpr( step.where, ctx, step, null, callback ) === traverseExpr.STOP)
+        return true;
+    }
     if (step.args) {
-      const ctx = (exprCtx === 'from') ? 'from-args' : exprCtx;
+      const ctx = referenceSemantics[exprCtx].args?.() || exprCtx;
       const args = Array.isArray( step.args ) ? step.args : Object.values( step.args );
       // TODO: there should be no array `args` on path item
       for (const arg of args) {
@@ -637,7 +654,6 @@ function fns( model ) {
 
     const s = referenceSemantics[expected];
     const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
-    semantics.name = expected;
 
     const r = getPathRoot( ref, semantics, origUser );
     const root = r && acceptPathRoot( r, ref, semantics, origUser );
@@ -778,19 +794,26 @@ function fns( model ) {
         ruser = ruser._outer._outer;
     }
 
-    // Handle expand/inline, `type of`, :param, global (internally for CDL):
+    // Handle expand/inline before `type of`, :param, global (internally for CDL):
     if (user._columnParent && !semantics.isMainRef) { // in expand/inline
-      const { name } = semantics;
-      semantics = semantics.nestedColumn();
-      semantics.name = name;
+      const func = semantics.nestedColumn;
+      if (!func)
+        throw new CompilerAssertion( 'Unexpected ref context in nested column' );
+      const ctx = func();
+      semantics = (typeof ctx === 'string')
+        ? ({ ...semantics, ...referenceSemantics[ctx] })
+        : ctx;
     }
     if (typeof scope === 'string') { // typeOf, param, global
-      semantics = semantics?.[scope] && semantics[scope]( ruser, path, location, semantics );
-      if (!semantics) {
-        if (semantics == null)
-          throw new CompilerAssertion( `Scope ${ scope } is not expected here` );
+      const func = semantics[scope] || scope === 'param' && paramUnsupported;
+      // 'param' is a user scope → useful default (error msg ref-unexpected-param)
+      // 'global' and 'typeOf' are internal scopes of the compiler → dump if not provided
+      if (!func)
+        throw new CompilerAssertion( `Unexpected scope ${ scope }, no handler defined in context` );
+      const ctx = func( ruser, path, location, semantics );
+      semantics = (typeof ctx === 'string') ? referenceSemantics[ctx] : ctx;
+      if (!semantics)
         return setArtifactLink( head, null );
-      }
     }
     const valid = [];
 
@@ -825,7 +848,8 @@ function fns( model ) {
       valid.push( dynamicDict );
     }
     else {
-      valid.push( removeInvalidMagicVariables( model.$magicVariables.elements, semantics ),
+      const filterFn = semantics.variableFilter || removeRestrictedVariables;
+      valid.push( filterFn( model.$magicVariables.elements ),
                   removeDollarNames( dynamicDict ) );
     }
     // TODO: streamline function arguments (probably: user, path, semantics )
@@ -1020,11 +1044,17 @@ function fns( model ) {
         return art;
       }
       case 'builtin': {
+        // TODO: use properties in builtins
         if (art.name.id === '$at') {
           message( 'ref-deprecated-variable', [ head.location, user ],
                    { code: '$at', newcode: '$valid' },
                    '$(CODE) is deprecated; use $(NEWCODE) instead' );
         }
+        else if (art.$restricted && semantics.accept !== acceptElemOrAnyVar) {
+          error( 'ref-unexpected-var', [ head.location, user ],
+                 { '#': 'annotation', name: head.id } );
+          return null;         // no further error on `unknown` for $draft.unknown
+        }
         return art;
       }
       default:
@@ -1059,20 +1089,12 @@ function fns( model ) {
     while (struct.kind === 'element')
       struct = struct._parent;
     if (struct === user._main && struct.kind !== 'annotation')
-      return { dynamic: typeOfParentDict, navigation: staticTarget };
+      return '$typeOf';
     error( 'type-unexpected-typeof', [ head.location, user ],
            { keyword: 'type of', '#': struct.kind } );
     return false;
   }
 
-  function paramSemantics( _user, _path, _loction, semantics ) {
-    return {
-      messageMap: semantics.messageMap,
-      dynamic: artifactParams,
-      notFound: undefinedParam,
-    };
-  }
-
   function paramUnsupported( user, _path, location ) {
     error( 'ref-unexpected-scope', [ location, user ], // TODO: ref-unexpected-param
            // why an extra text for calculated elements? or separate for all?
@@ -1273,11 +1295,11 @@ function fns( model ) {
 
   // Functions called via semantics.notFound: -----------------------------------
 
-  function undefinedDefinition( user, item, valid, _dict, prev ) {
+  function undefinedDefinition( user, item, valid, _dict, prev, _path, semantics ) {
     // in a CSN source or for `using`, only one env was tested (valid.length 1) :
     const art = (!prev) ? item.id : searchName( prev, item.id, 'absolute' );
     signalNotFound( (valid.length > 1 ? 'ref-undefined-art' : 'ref-undefined-def'),
-                    [ item.location, user ], valid, { art } );
+                    [ item.location, user ], valid, { art }, semantics );
     // TODO: improve text, use text variant for: "or builtin" or "definitions" or none
   }
 
@@ -1430,8 +1452,7 @@ function fns( model ) {
       while ((head = head?._parent) && head.kind === 'builtin')
         id = `${ head.name.id }.${ id }`;
       const msgId = (art.$uncheckedElements) ? 'ref-unknown-var' : 'ref-undefined-var';
-      signalNotFound( msgId, [ item.location, user ],
-                      removeInvalidMagicVariables( valid, semantics ), { id }, semantics );
+      signalNotFound( msgId, [ item.location, user ], valid, { id }, semantics );
     }
     else if (art.kind === 'aspect' && !art.name) { // anonymous target aspect - TODO: still?
       signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
@@ -1513,16 +1534,17 @@ function fns( model ) {
       : acceptElemOrVar( art, user, ref );
   }
 
-  function acceptElemOrVar( art, user, ref, semantics ) {
+  function acceptElemOrVar( art, user, ref ) {
+    if (art.kind !== 'builtin' || !art.$restricted)
+      return acceptElemOrAnyVar( art, user, ref );
+    error( 'ref-unexpected-var', [ ref.location, user ],
+           { '#': 'annotation', name: pathName( ref.path ) } );
+    return null;
+  }
+
+  function acceptElemOrAnyVar( art, user, ref ) {
     const { path } = ref;
     if (art.kind === 'builtin') {
-      if (art.$onlyInExprCtx && !art.$onlyInExprCtx.includes(semantics.name)) {
-        error( 'ref-unexpected-var', [ ref.location, user ], {
-          '#': art.$onlyInExprCtx[0], name: pathName( path ),
-        });
-        return null;
-      }
-
       if (user.expand || user.inline) {
         const location = (user.expand || user.inline)[$location];
         const code = (user.expand) ? '{ ‹expand› }' : '.{ ‹inline› }';
@@ -1866,8 +1888,9 @@ function fns( model ) {
     }
     const index = userTargetElementPathIndex( user, path );
     checkOnlyForeignKeyNavigation( user, path, index );
+    // TODO: did we check for no filter/args, no `exists` etc?
     const last = path[path.length - 1];
-    if (!last.where && ref._artifact?.on) { // filter already complained about
+    if (!last.where && ref._artifact?.on) { // filter already complained about - TODO: where?
       const target = index > 0 && index < path.length && ref._artifact?.target;
       const msg = (target?._artifact === user._main) ? 'self' : 'unmanaged';
       error( 'ref-unexpected-assoc', [ last.location, user ],
@@ -2006,7 +2029,7 @@ function fns( model ) {
   }
 
   function checkNoUnmanaged( ref, user, self, messageVariant = 'unmanaged' ) {
-    if (ref._artifact?.on && !ref.$expected) {
+    if (ref._artifact?.on && ref.$syntax !== 'after-exists') {
       const { path } = ref;
       const last = path[path.length - 1];
       if (self && last.where)   // already complained about filter
@@ -2035,7 +2058,8 @@ function fns( model ) {
     const err = message( semantics?.messageMap?.[msgId] || msgId, location, textParams );
     if (valid) {
       const user = Array.isArray( location ) && location[1];
-      err.validNames = (user && definedViaCdl( user )); // viaCdl -> '.'?
+      // TODO: see TODO missing param `viaCdl` in attachAndEmitValidNames:
+      err.validNames = (user && definedViaCdl( user ));
       valid.reverse();
       attachAndEmitValidNames( err, ...valid );
     }
@@ -2076,6 +2100,8 @@ function fns( model ) {
     const valid = Object.assign( Object.create( null ), ...validDicts );
     msg.validNames = Object.create( null );
     for (const name of Object.keys( valid )) {
+      if (!name)
+        continue;
       const art = valid[name];
       // ignore internal types such as cds.Association, ignore names with dot for
       // CDL references to main artifacts:
@@ -2100,14 +2126,19 @@ function fns( model ) {
   }
 }
 
-function removeInvalidMagicVariables( variables, semantics ) {
-  if (Array.isArray(variables))
-    return variables.map(variable => removeInvalidMagicVariables( variable, semantics ));
-
+/**
+ * Filter out restricted variables from a dictionary of variables.
+ * Variables with the `$restricted` property set to true are excluded.
+ *
+ * @param {object} variables - Dictionary of variable objects
+ * @returns {object} New dictionary with restricted variables removed
+ */
+function removeRestrictedVariables( variables ) {
+  // TODO: we could also do something with `deprecated`, $requiresBetaFlag, …
   const valid = Object.create(null);
   for (const name in variables) {
     const variable = variables[name];
-    if (!variable.$onlyInExprCtx || variable.$onlyInExprCtx.includes( semantics.name ))
+    if (!variable.$restricted)
       valid[name] = variable;
   }
   return valid;

package/lib/compiler/tweak-assocs.js

@@ -5,7 +5,6 @@
 const {
   forEachGeneric,
   forEachInOrder,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
@@ -138,10 +137,10 @@ function tweakAssocs( model ) {
 
   function handleQueryElements( column ) {
     rewriteAssociationCheck( column );
-    if (!isBetaEnabled( model.options, '$calcForDraft' ))
-      return;
+    if (model.options.noDollarCalc || column._columnParent)
+      return;                   // no $calc supported with inline
     const { value } = column;  // `value` = column expression
-    if (!value || !value.args && !value.suffix)
+    if (!value || value.path)  // not with references
       return;
     // TODO: what about non-simple refs (assocs, even with filter/args)?
 
@@ -457,7 +456,7 @@ function tweakAssocs( model ) {
       return;
 
     if (elem._parent?.kind === 'element') {
-      // managed association as sub element not supported yet
+      // unmanaged association as sub element not supported yet
       // TODO: Only report once for multi-include chains, see
       //       Associations/SubElements/UnmanagedInSubElement.err.cds
       error( 'type-unsupported-rewrite', [ elem.location, elem ], { '#': 'sub-element' } );
@@ -946,6 +945,8 @@ function tweakAssocs( model ) {
    * for item.
    */
   function rewriteColumnPath( ref, column ) {
+    if (ref.query)
+      return traverseExpr.STOP; // sub queries rewrite not supported
     if (!ref._artifact)
       return null;
     const root = ref.path?.[0];
@@ -1010,9 +1011,12 @@ function tweakAssocs( model ) {
           state = setArtifactLink( i, elem );
       }
       else {
-        state = rewriteItem( state, i, assoc );
-        if (!state || state === true)
-          break;
+        state = rewriteItem( state, i, assoc, !location );
+        if (state && state !== true)
+          continue;
+        if (!state && !location)
+          return true;
+        break;
       }
     }
     if (state !== true)
@@ -1032,7 +1036,7 @@ function tweakAssocs( model ) {
    * @param item Path segment to rewrite.
    * @param assoc Published association of query.
    */
-  function rewriteItem( elem, item, assoc ) {
+  function rewriteItem( elem, item, assoc, noError ) {
     if (!elem._redirected)
       return true;
     let name = item.id;
@@ -1055,7 +1059,7 @@ function tweakAssocs( model ) {
     if (env?.target)
       env = env.target._artifact?._effectiveType;
     const found = setArtifactLink( item, env?.elements?.[name] );
-    if (found)
+    if (found || noError)
       return found;
 
     const isExplicit = elem.target && !elem.target.$inferred;