@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/compiler/resolve.js

@@ -67,6 +67,7 @@ const {
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
+const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -88,8 +89,8 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    resolveDefinitionName,
     traverseExpr,
-    createRemainingAnnotateStatements,
     effectiveType,
     getOrigin,
     getInheritedProp,
@@ -130,8 +131,6 @@ function resolve( model ) {
         resolveDefinitionName( model.sources[name].namespace );
     }
 
-    // create “super” ANNOTATE statements for annotations on unknown artifacts:
-    createRemainingAnnotateStatements();
     // report cyclic dependencies:
     detectCycles( model.definitions, ( user, art, location, semanticLoc ) => {
       if (location) {
@@ -157,68 +156,102 @@ function resolve( model ) {
   // Phase 2+3: calculate propagated KEYs
   //--------------------------------------------------------------------------
 
+  /**
+   * Set `_projection` links in navigation elements and creates $navElement hierarchy.
+   *
+   * @param {XSN.Artifact} view
+   */
   function setNavigationProjections( view ) {
     if (!view.$queries)
       return;
     for (const query of view.$queries) {
-      forEachGeneric( query, 'elements', ( elem ) => {
-        if (!elem._origin || elem.expand || !elem.value)
+      // traversing sub-elements not necessary, since we're in a view
+      // TODO: Handle expand.
+      forEachGeneric( query, 'elements', function navProjectionsForElement( elem ) {
+        if (!elem._origin || elem.expand || !elem.value?.path)
           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.)
-        const nav = pathNavigation( elem.value );
-        const { path } = elem.value;
-
-        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; // should not happen
 
-          let navItem = nav.navigation;
-          if (!nav.item._navigation) // first non-table-alias
-            setLink( nav.item, '_navigation', navItem );
+        if (elem._pathHead) {
+          if (elem._pathHead?.kind !== '$inline')
+            // we're traversing top-level elements of the query; other _pathHead kinds can't happen
+            throw new CompilerAssertion('found unexpected "expand", but expected "inline"');
 
-          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;
+          if (!isPathBreakout( elem.value )) {
+            const fullPath = columnParentPath( elem );
+            if (fullPath)
+              setNavigationProjectionsForElementRef({ path: fullPath }, elem);
           }
-          // Last path step, if found, is a simple projection
-          if (index === path.length && navItem)
-            pushLink( navItem, '_projections', elem );
+        }
+        else {
+          setNavigationProjectionsForElementRef( elem.value, elem );
         }
       } );
     }
   }
 
+  function setNavigationProjectionsForElementRef( ref, elem ) {
+    const { path } = ref;
+    const nav = pathNavigation( ref );
+    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; // should not happen
+
+      let navItem = nav.navigation;
+      if (!nav.item._navigation) // first non-table-alias
+        setLink( nav.item, '_navigation', navItem );
+
+      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 );
+    }
+  }
+
+  function columnParentPath( elem ) {
+    if (!elem._pathHead || !elem.value?.path || isPathBreakout( elem.value ))
+      return elem.value?.path;
+
+    const fullPath = [ ...elem.value.path ];
+    let pathHead = elem._pathHead;
+    while (pathHead) {
+      if (pathHead.kind !== '$inline' || !pathHead.value?.path ||
+          isPathBreakout( pathHead.value )) {
+        // path breakout for e.g. `$self.{ foo }`, `1 as a .{ foo }`
+        return null;
+      }
+      fullPath.unshift(...pathHead.value.path);
+      pathHead = pathHead._pathHead;
+    }
+    return fullPath;
+  }
+
   function propagateKeyProps( view ) {
     // Second argument true ensure that `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
@@ -255,9 +288,9 @@ function resolve( model ) {
   function inheritedSourceKeyProp( { value, _pathHead } ) {
     if (!value || !value.path)
       return null;
-    const nav = pathNavigation( value );
+    const nav = !_pathHead && pathNavigation( value );
     const item = value.path[value.path.length - 1];
-    if (nav.navigation && nav.item === item)
+    if (nav?.navigation && nav.item === item)
       return item._artifact?.key;
     if (value.path.length !== 1 || _pathHead?.kind !== '$inline')
       return null;
@@ -281,13 +314,11 @@ function resolve( model ) {
     const toMany = withAssociation( from, targetMaxNotOne, true );
     if (toMany) {
       propagateKeys = false;
-      info( 'query-from-many', [ toMany.location, query ], { art: toMany },
-            {
-              // eslint-disable-next-line max-len
-              std: 'Key properties are not propagated because a to-many association $(ART) is selected',
-              // eslint-disable-next-line max-len
-              element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
-            } );
+      info( 'query-from-many', [ toMany.location, query ], { art: toMany }, {
+        std: 'Key properties are not propagated because a to-many association $(ART) is selected',
+        // eslint-disable-next-line max-len
+        element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
+      } );
     }
     // Check that all keys from the source are projected:
     const notProjected = [];    // we actually push to the array
@@ -297,7 +328,7 @@ function resolve( model ) {
       if (nav.$duplicates)
         continue;
       const { key } = nav._origin;
-      if (key && key.val && !(nav._projections && nav._projections.length))
+      if (key?.val && !nav._projections?.length)
         notProjected.push( nav.name.id );
     }
     if (notProjected.length) {
@@ -311,9 +342,12 @@ function resolve( model ) {
     // Check that there is no to-many assoc used in select item:
     for (const name in query.elements) {
       const elem = query.elements[name];
-      if (!elem.$inferred && elem.value &&
-          testExpr( elem.value, selectTest, () => false, elem ))
-        propagateKeys = false;
+
+      if (!elem.$inferred && elem.value?.path) {
+        const path = elem._pathHead ? columnParentPath( elem ) : elem.value.path;
+        if (testExpr({ path }, selectTest, () => false, elem))
+          propagateKeys = false;
+      }
     }
     return propagateKeys;
 
@@ -321,15 +355,13 @@ function resolve( model ) {
       const art = withAssociation( expr, targetMaxNotOne );
       if (art) {
         // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
-        info( 'query-navigate-many', [ art.location, user || query ], { art },
-              {
-                // eslint-disable-next-line max-len
-                std: 'Navigating along to-many association $(ART) - key properties are not propagated',
-                // eslint-disable-next-line max-len
-                element: 'Navigating along to-many association $(MEMBER) of $(ART) - key properties are not propagated',
-                // eslint-disable-next-line max-len
-                alias: 'Navigating along to-many mixin association $(MEMBER) - key properties are not propagated',
-              } );
+        info( 'query-navigate-many', [ art.location, user || query ], { art }, {
+          std: 'Navigating along to-many association $(ART) - key properties are not propagated',
+          // eslint-disable-next-line max-len
+          element: 'Navigating along to-many association $(MEMBER) of $(ART) - key properties are not propagated',
+          // eslint-disable-next-line max-len
+          alias: 'Navigating along to-many mixin association $(MEMBER) - key properties are not propagated',
+        } );
       }
       return art;
     }
@@ -442,7 +474,7 @@ function resolve( model ) {
       obj.items = items;
       obj.$expand = 'origin';
     }
-    if (obj.items) {            // TODO: make this a while in v5 (also items proxy)
+    if (obj.items) {            // TODO: make this a while in v6 (also items proxy)
       obj = obj.items || obj; // the object which has type properties
       effectiveType( obj );
     }
@@ -510,14 +542,12 @@ function resolve( model ) {
     else if (obj.targetAspect && obj.targetAspect.elements) { // silent dependencies
       forEachGeneric( obj.targetAspect, 'elements', elem => dependsOnSilent( art, elem ) );
     }
+
     if (obj.foreignKeys) {       // silent dependencies
       // 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 );
-        } );
-      }
+      // Done by addImplicitForeignKeys() for implicit keys.
+      if (!art.foreignKeys?.[$inferred] && obj.$inferred !== 'aspect-composition')
+        forEachGeneric( obj, 'foreignKeys', elem => dependsOnSilent( art, elem ) );
       addForeignKeyNavigations( art );
     }
 
@@ -1266,7 +1296,6 @@ function resolve( model ) {
               { art: target, '#': variant, keyword: op || '' }, {
                 std: 'Redirection involves the complex view $(ART)',
                 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;
@@ -1360,19 +1389,6 @@ function resolve( model ) {
   // General resolver functions
   //--------------------------------------------------------------------------
 
-  // Resolve the n-1 path steps before the definition name for LSP.
-  function resolveDefinitionName( art ) {
-    const path = art?.name?.path;
-    if (!art || art._main || !path || path.length <= 1)
-      return;
-
-    let name = art.name.id;
-    for (let i = path.length - 1; i > 0; --i) {
-      name = name.substring(0, name.length - path[i].id.length - 1);
-      setArtifactLink( path[i - 1], model.definitions[name] || false );
-    }
-  }
-
   // Resolve the type and its arguments if applicable.
   function resolveTypeExpr( art, user ) {
     const typeArt = resolvePath( art.type, 'type', user );
@@ -1565,8 +1581,6 @@ function resolve( model ) {
 function pathNavigation( ref ) {
   // currently, indirectly projectable elements are not included - we might
   // keep it this way!  If we want them to be included - be aware: cycles
-  if (!ref._artifact)
-    return {};
   let item = ref.path && ref.path[0];
   const root = item && item._navigation;
   if (!root)
@@ -1583,4 +1597,13 @@ function pathNavigation( ref ) {
   return { navigation: root.elements?.[item.id], item, tableAlias: root };
 }
 
+function isPathBreakout( ref ) {
+  if (!ref.path?.[0])
+    return false;
+  if (ref.scope === 'param')
+    return true;
+  const nav = (ref.path[0]._navigation || ref.path[0]._artifact);
+  return nav && (nav.kind === '$self' || ref.path[0].id.charAt(0) === '$');
+}
+
 module.exports = resolve;

package/lib/compiler/shared.js

@@ -19,7 +19,6 @@ const {
   isAssocToPrimaryKeys,
   artifactRefLocation,
 } = require('./utils');
-const { isBetaEnabled } = require('../base/model');
 
 const $inferred = Symbol.for( 'cds.$inferred' );
 const $location = Symbol.for( 'cds.$location' );
@@ -56,13 +55,14 @@ function fns( model ) {
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedForAnnotate,
+      accept: extendableArtifact,
     },
     extend: {
       isMainRef: 'no-generated',
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
-      accept: acceptRealArtifact,
+      accept: extendableArtifact,
     },
     _extensions: {
       isMainRef: 'all',
@@ -163,7 +163,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     'limit-offset': 'limit-rows',
-    // general element references -----------------------------------------------
+    // general element / variable references --------------------------------------
     where: {
       lexical: tableAliasesAndSelf,
       dollar: true,
@@ -279,7 +279,7 @@ function fns( model ) {
     annotation: { // annotation assignments
       lexical: justDollarAliases,
       dollar: true,
-      dynamic: parentElements,
+      dynamic: parentElementsOrKeys,
       navigation: assocOnNavigation,
       noDep: true,
       notFound: undefinedParentElement,
@@ -298,6 +298,7 @@ function fns( model ) {
       }),
     },
     // TODO: introduce some kind of inheritance
+    // used by xpr-rewrite.js to resolve rewritten path roots.
     annoRewrite: { // annotation assignments
       lexical: justDollarAliases,
       dollar: true,
@@ -323,6 +324,7 @@ function fns( model ) {
     resolveTypeArgumentsUnchecked, // TODO: move to some other file
     resolvePathRoot,
     resolvePath,
+    resolveDefinitionName,
     checkExpr,
     checkOnCondition,
     navigationEnv,
@@ -405,6 +407,7 @@ 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 );
@@ -512,6 +515,25 @@ function fns( model ) {
     artifact.$typeArgs = undefined;
   }
 
+  // Resolve the n-1 path steps before the definition name for LSP.
+  function resolveDefinitionName( art ) {
+    const path = art?.name?.path;
+    if (!art || art._main || !path || path.length <= 1)
+      return;
+
+    // Don't resolve paths in an annotation as a definition!
+    const definitions = art.kind === 'annotation' ? model.vocabularies : model.definitions;
+
+    let name = art.name.id;
+    if (art.kind === 'namespace') // namespace-statements are ref-only.
+      setArtifactLink( path[path.length - 1], definitions[name] || false );
+
+    for (let i = path.length - 1; i > 0; --i) {
+      name = name.substring(0, name.length - path[i].id.length - 1);
+      setArtifactLink( path[i - 1], definitions[name] || false );
+    }
+  }
+
   function getPathRoot( { path, scope, location }, semantics, user ) {
     // TODO: use string value of isMainRef?
     const head = path[0];
@@ -524,8 +546,11 @@ function fns( model ) {
       ruser = ruser._outer;
 
     // Handle expand/inline, `type of`, :param, global (internally for CDL):
-    if (user._pathHead && !semantics.isMainRef) // in expand/inline
+    if (user._pathHead && !semantics.isMainRef) { // in expand/inline
+      const { name } = semantics;
       semantics = semantics.nestedColumn();
+      semantics.name = name;
+    }
     if (typeof scope === 'string') { // typeOf, param, global
       semantics = semantics?.[scope] && semantics[scope]( ruser, path, location, semantics );
       if (!semantics) {
@@ -563,10 +588,13 @@ function fns( model ) {
     if (r)
       return setArtifactLink( head, r );
 
-    if (!semantics.dollar)
+    if (!semantics.dollar) {
       valid.push( dynamicDict );
-    else
-      valid.push( model.$magicVariables.elements, removeDollarNames( dynamicDict ) );
+    }
+    else {
+      valid.push( removeInvalidMagicVariables( model.$magicVariables.elements, semantics ),
+                  removeDollarNames( dynamicDict ) );
+    }
     // TODO: streamline function arguments (probably: user, path, semantics )
     const undef = semantics.notFound?.( user._user || user, head, valid, dynamicDict,
                                         !isMainRef && user._user && user._artifact,
@@ -629,7 +657,6 @@ function fns( model ) {
         // simple 'ref-undefined-art'/'ref-undefined-def' - TODO: which we
         // could "change" to this message at the end of compile():
         error( 'ref-unexpected-autoexposed', [ item.location, user ], { art },
-               // eslint-disable-next-line max-len
                'An auto-exposed entity can\'t be referred to - expose entity $(ART) explicitly' );
         return null;            // continuation semantics: like “not found”
       }
@@ -663,9 +690,13 @@ function fns( model ) {
     // Do not accept a lonely table alias and `$projection`
     // TODO: test table alias and mixin named `$projection`
     if (path.length !== 1 || user.expand || user.inline) {
-      // Rewrite $projection to $self
-      if (semantics.rewriteProjectionToSelf && art.kind === '$self' && path[0].id === '$projection')
+      if (semantics.rewriteProjectionToSelf &&
+          art.kind === '$self' && path[0].id === '$projection') {
+        // Rewrite $projection to $self
         path[0].id = '$self';
+        warning( 'ref-expecting-$self', [ path[0].location, user ],
+                 { code: '$projection', newcode: '$self' });
+      }
       return art.name?.$inferred !== '$internal'; // not a compiler-generated internal alias
     }
 
@@ -725,7 +756,14 @@ function fns( model ) {
         message( 'ref-obsolete-parameters', [ head.location, user ],
                  { code: `$parameters.${ id }`, newcode: `:${ id }` },
                  'Obsolete $(CODE) - replace by $(NEWCODE)' );
-        // TODO: replace it in to-csn correspondingly, probably v5 or later in v4 ?
+        return art;
+      }
+      case 'builtin': {
+        if (art.name.id === '$at') {
+          warning( 'ref-deprecated-variable', [ head.location, user ],
+                   { code: '$at', newcode: '$valid' },
+                   '$(CODE) is deprecated; use $(NEWCODE) instead' );
+        }
         return art;
       }
       default:
@@ -868,6 +906,13 @@ function fns( model ) {
     return environment( useParent ? user._parent : user );
   }
 
+  function parentElementsOrKeys( user ) {
+    // annotations on foreign keys only ever have access to their keys (except of course via $self)
+    if (user.kind === 'key')
+      return user._parent?.foreignKeys || Object.create( null );
+    return parentElements( user );
+  }
+
   function queryElements( user ) {
     return environment( user );
   }
@@ -1113,11 +1158,11 @@ function fns( model ) {
       // TODO: if it becomes non-configurable, we can omit this warning
       let id = pathName( path );
       let head = path[0]._artifact || { _parent: art };
-      // eslint-disable-next-line no-cond-assign
       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 ], valid, { id }, semantics );
+      signalNotFound( msgId, [ item.location, user ],
+                      removeInvalidMagicVariables( valid, semantics ), { id }, semantics );
     }
     else if (art.kind === 'aspect' && !art.name) { // anonymous target aspect - TODO: still?
       signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
@@ -1199,9 +1244,16 @@ function fns( model ) {
       : acceptElemOrVar( art, user, ref );
   }
 
-  function acceptElemOrVar( art, user, ref ) {
+  function acceptElemOrVar( art, user, ref, semantics ) {
     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› }';
@@ -1234,16 +1286,19 @@ function fns( model ) {
     return art;
   }
 
-  function acceptRealArtifact( art, user, ref ) {
+  /**
+   * Returns true, if the artifact is a _real_ artifact that can be used for `extend`/`annotate`.
+   */
+  function extendableArtifact( art, user, ref ) {
     if (art.kind !== 'namespace')
       return art;
-    // For compatibility (≤v4), we accept `extend Unknown` without elements/actions/includes
-    // In v5, only allow `extend with definitions`.
-    if (!isBetaEnabled( model.options, 'v5preview' ) &&
-      !(user.elements || user.actions || user.includes))
-      return art;
     const { location } = ref.path[ref.path.length - 1];
-    signalNotFound( 'ref-undefined-def', [ location, user ], null, { art } );
+    if (user.kind === 'extend' && !(user.elements || user.actions || user.includes))
+      return art; // allow `extend with definitions` and empty extends
+
+    // for `annotate`, handle "namespaces" just like unknown artifacts: only emit a warning
+    signalNotFound( user.kind === 'annotate' ? 'ext-undefined-def' : 'ref-undefined-def',
+                    [ location, user ], null, { art } );
     return false;
   }
 
@@ -1459,7 +1514,7 @@ function fns( model ) {
     // console.log('NAV:',expr.path.map(r=>r.id),self)
     if (self || self == null && columnRefStartsWithSelf( user )) {
       checkOnlyForeignKeyNavigation( user, expr.path, 0, 'self-' );
-      checkNoUnmanaged( expr, user, 'self-unmanaged' );
+      checkNoUnmanaged( expr, user, true, 'self-unmanaged' );
     }
     // TODO: set navigation dependencies later to avoid both ref-cyclic and
     // ref-invalid-navigation/ref-unexpected-assoc
@@ -1469,18 +1524,20 @@ function fns( model ) {
     const { path } = expr;
     if (!path)
       return;
-    if (path?.[0]?._navigation?.kind !== '$tableAlias')
+    const self = path?.[0]?._navigation?.kind !== '$tableAlias';
+    if (self)
       checkOnlyForeignKeyNavigation( user, expr.path );
-    checkNoUnmanaged( expr, user );
+    checkNoUnmanaged( expr, user, self );
   }
 
   function checkRefInQuery( expr, exprCtx, user ) {
     const { path } = expr;
     if (!path)
       return;
-    if (pathStartsWithSelf( expr ))
+    const self = pathStartsWithSelf( expr );
+    if (self)
       checkOnlyForeignKeyNavigation( user, expr.path, 0, 'self-' );
-    checkNoUnmanaged( expr, user );
+    checkNoUnmanaged( expr, user, self );
   }
 
   function checkExpandInlineRef( art, user, ref ) {
@@ -1523,10 +1580,10 @@ function fns( model ) {
     }
     const index = userTargetElementPathIndex( user, path );
     checkOnlyForeignKeyNavigation( user, path, index );
-    if (ref._artifact?.on) {
+    const last = path[path.length - 1];
+    if (!last.where && ref._artifact?.on) { // filter already complained about
       const target = index > 0 && index < path.length && ref._artifact?.target;
       const msg = (target?._artifact === user._main) ? 'self' : 'unmanaged';
-      const last = path[path.length - 1];
       error( 'ref-unexpected-assoc', [ last.location, user ],
              { '#': msg, code: '= $self' } );
     }
@@ -1614,6 +1671,16 @@ function fns( model ) {
         index = checkCoveredByForeignKey( assoc, path, index, user, msgPrefix );
       }
       assoc = path[index]?._artifact;
+      if (assoc?.target) {
+        // testing this above is not enough: we would not complain about $self
+        // assoc filter at end of ref with expand/inline. We might also move the
+        // unmanaged test above to here.
+        if (path[index]?.where) {
+          error( 'ref-unexpected-assoc', [ path[index].location, user ],
+                 { '#': `${ msgPrefix }with-filter`, alias: '$self' } );
+          return;
+        }
+      }
     }
   }
 
@@ -1635,7 +1702,6 @@ function fns( model ) {
     const txt = index >= path.length
       ? 'complete'
       : (isAssocToPrimaryKeys( assoc ) ? 'keys' : 'std');
-    // eslint-disable-next-line max-len
     error( 'ref-invalid-navigation', [ last.location, user ], {
       '#': msgPrefix + txt, art: assoc, name: last.id, alias: '$self',
     }, {
@@ -1653,10 +1719,12 @@ function fns( model ) {
     return path.length;
   }
 
-  function checkNoUnmanaged( ref, user, messageVariant = 'unmanaged' ) {
+  function checkNoUnmanaged( ref, user, self, messageVariant = 'unmanaged' ) {
     if (ref._artifact?.on && !ref.$expected) {
       const { path } = ref;
       const last = path[path.length - 1];
+      if (self && last.where)   // already complained about filter
+        return;
       error( 'ref-unexpected-assoc', [ last.location, user ],
              { '#': messageVariant, alias: '$self' } );
     }
@@ -1670,7 +1738,8 @@ function fns( model ) {
    * @param {string} msgId
    * @param {any} location
    * @param {object[]} valid
-   * @param  {object} [textParams]
+   * @param {object} [textParams]
+   * @param {object} [semantics]
    */
   function signalNotFound( msgId, location, valid, textParams, semantics ) {
     if (location.$notFound)     // TODO: still necessary?
@@ -1745,6 +1814,19 @@ function fns( model ) {
   }
 }
 
+function removeInvalidMagicVariables( variables, semantics ) {
+  if (Array.isArray(variables))
+    return variables.map(variable => removeInvalidMagicVariables( variable, semantics ));
+
+  const valid = Object.create(null);
+  for (const name in variables) {
+    const variable = variables[name];
+    if (!variable.$onlyInExprCtx || variable.$onlyInExprCtx.includes( semantics.name ))
+      valid[name] = variable;
+  }
+  return valid;
+}
+
 function removeDollarNames( dict ) {
   const r = Object.create( null );
   for (const name in dict) {