@sap/cds-compiler 4.0.0 → 4.1.2

package/lib/compiler/shared.js

@@ -13,16 +13,23 @@ const {
   pathName,
   userQuery,
   definedViaCdl,
+  isDirectComposition,
+  pathStartsWithSelf,
+  columnRefStartsWithSelf,
+  isAssocToPrimaryKeys,
+  artifactRefLocation,
 } = require('./utils');
 
+const $inferred = Symbol.for('cds.$inferred');
+const $location = Symbol.for('cds.$location');
+
 /**
  * Main export function of this file.  Attach "resolve" functions shared for phase
  * "define" and "resolve" to `model.$functions`, where argument `model` is the XSN.
  *
  * Before calling `resolvePath`, make sure that the following function
  * in model.$function is set:
- * - `navigationEnv`: a function which returns the search environment defined by
- *    its argument, e.g. a function which returns the dictionary of subartifacts.
+ * - `effectiveType`
  *
  * @param {XSN.Model} model
  */
@@ -30,7 +37,7 @@ const {
 function fns( model ) {
   const { options } = model;
   const {
-    info, warning, error, message,
+    info, error, warning, message,
   } = model.$messageFunctions;
   const Functions = model.$functions;
 
@@ -59,53 +66,68 @@ function fns( model ) {
       isMainRef: 'all',
       lexical: userBlock,
       dynamic: modelDefinitions,
-      notFound: false,          // without message
+      notFound: () => null,     // without message
     },
     include: {
       isMainRef: 'no-generated',
       lexical: userBlock,
       dynamic: modelBuiltinsOrDefinitions,
       notFound: undefinedDefinition,
+      accept: acceptStructOrBare,
+    },
+    _include: {                 // cyclic include: no accept
+      isMainRef: 'no-generated',
+      lexical: userBlock,
+      dynamic: modelBuiltinsOrDefinitions,
+      notFound: undefinedDefinition,
     },
-    viewInclude: 'include',     // TODO: do differently
     target: {
       isMainRef: 'no-autoexposed',
       lexical: userBlock,
       dynamic: modelBuiltinsOrDefinitions,
       notFound: undefinedDefinition,
-      // special `scope`s for redirections:
+      accept: acceptEntity,
+      noDep: true,
+      // special `scope`s for auto-redirections:
       global: () => ({ isMainRef: 'all', dynamic: modelDefinitions }),
     },
-    targetAspect: {             // TODO: do differently
+    targetAspect: {
       isMainRef: 'no-autoexposed',
       lexical: userBlock,
       dynamic: modelBuiltinsOrDefinitions,
       notFound: undefinedDefinition,
+      accept: acceptAspect,
     },
     from: {
       isMainRef: 'no-autoexposed',
       lexical: userBlock,
       dynamic: modelBuiltinsOrDefinitions,
-      notFound: undefinedDefinition,
       navigation: environment,
+      notFound: undefinedDefinition,
+      accept: acceptEntityOrAssoc,
+      noDep: '',                // dependency special for from
     },
     type: {
       isMainRef: 'no-autoexposed',
       lexical: userBlock,
       dynamic: modelBuiltinsOrDefinitions,
+      navigation: staticTarget,
       notFound: undefinedDefinition,
-      navigation: targetAspectOnly,
+      accept: acceptTypeOrElement,
       // special `scope`s for CDL parser - TYPE OF (TODO generated?), cds.Association:
       typeOf: typeOfSemantics,
-      global: () => ({ isMainRef: 'no-autoexposed', dynamic: modelDefinitions }),
+      global: () => ({
+        isMainRef: 'no-autoexposed',
+        dynamic: modelDefinitions,
+        navigation: staticTarget, // TODO: Object.assign() with main
+      }),
     },
-    actionParamType: 'type',    // TODO: do differently
-    eventType: 'type',          // TODO: do differently
     // element references without lexical scope (except $self/$projection): -----
     targetElement: {
       lexical: null,
       dollar: false,
       dynamic: targetElements,
+      navigation: targetNavigation,
       notFound: undefinedTargetElement,
       param: paramSemantics,
     },
@@ -120,6 +142,7 @@ function fns( model ) {
       lexical: justDollarSelf,
       dollar: true,
       dynamic: targetElements,
+      navigation: calcElemNavigation,
       notFound: undefinedTargetElement,
       param: paramUnsupported,
     },
@@ -131,21 +154,33 @@ function fns( model ) {
       param: paramUnsupported,
     },
     // general element references -----------------------------------------------
-    expr: {                     // TODO: this is too general -> column
+    where: {
       lexical: tableAliasesIfNotExtendAndSelf,
       dollar: true,
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
+      check: checkRefInQuery,
+      param: paramSemantics,
+    },
+    having: 'where',
+    groupBy: 'where',
+    column: {
+      lexical: tableAliasesIfNotExtendAndSelf,
+      dollar: true,
+      dynamic: combinedSourcesOrParentElements,
+      notFound: undefinedSourceElement,
+      check: checkColumnRef,
       param: paramSemantics,
       nestedColumn: () => ({       // in expand and inline
         lexical: justDollarSelf,
         dollar: true,
         dynamic: nestedElements,
         notFound: undefinedNestedElement,
+        check: checkColumnRef,
         param: paramSemantics,
       }),
     },
-    'param-only': {
+    'from-args': {
       lexical: null,
       dollar: true,
       dynamic: () => Object.create( null ),
@@ -156,10 +191,11 @@ function fns( model ) {
       lexical: justDollarSelf,
       dollar: true,
       dynamic: parentElements,
+      navigation: calcElemNavigation,
       notFound: undefinedParentElement,
       param: paramUnsupported,
     },
-    joinOn: {
+    'join-on': {
       lexical: tableAliasesAndSelf,
       dollar: true,
       dynamic: combinedSourcesOrParentElements, // TODO: source alone...
@@ -168,256 +204,99 @@ function fns( model ) {
     },
     on: {     // unmanaged assoc: outside query, redirected or new assoc in column
       lexical: justDollarSelf,
-      allowBareSelf: true,
       dollar: true,
       dynamic: parentElements,
+      navigation: assocOnNavigation,
       notFound: undefinedParentElement,
+      accept: acceptElemOrVarOrSelf,
+      check: checkAssocOn,
       param: paramUnsupported,
       nestedColumn: () => ({       // in expand and inline
         lexical: justDollarSelf,
         dollar: true,
         dynamic: parentElements,
+        navigation: assocOnNavigation,
         notFound: undefinedParentElement,
       }),
     },
     'mixin-on': {
       lexical: tableAliasesAndSelf,
-      allowBareSelf: true,
       dollar: true,
       dynamic: combinedSourcesOrParentElements,
+      navigation: assocOnNavigation,
       notFound: undefinedSourceElement,
+      accept: acceptElemOrVarOrSelf,
+      check: checkAssocOn,
       param: paramSemantics, // TODO: check that assocs containing param in ON is not published
     },
-    'order-by-ref': {
+    'orderBy-ref': {
       lexical: tableAliasesAndSelf,
       dollar: true,
       dynamic: parentElements,
       notFound: undefinedOrderByElement,
+      check: checkOrderByRef,
       param: paramSemantics,
     },
-    'order-by-expr': {
+    'orderBy-expr': {
       lexical: tableAliasesAndSelf,
       dollar: true,
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
+      check: checkRefInQuery,
       param: paramSemantics,
     },
-    'order-by-set-ref': {
+    'orderBy-set-ref': {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
       dollar: true,
       dynamic: queryElements,
       notFound: undefinedParentElement,
+      check: checkOrderByRef,
       param: paramSemantics,
     },
-    'order-by-set-expr': {
+    'orderBy-set-expr': {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
       dollar: true,
       dynamic: () => Object.create( null ),
       notFound: undefinedVariable,
+      check: checkRefInQuery,
       param: paramSemantics,
     },
   };
 
-  // TODO: combine envFn and assoc ?
-  const specExpected = {
-    using: {},                  // for using declaration
-    // TODO: artifact references ---------------------------------------------
-    extend: {},
-    // ref in top-level EXTEND
-    annotate: {},
-    _extensions: {},
-    type: { // TODO: more detailed later (e.g. for enum base type?)
-      check: checkTypeRef,
-      expectedMsgId: 'ref-expecting-type',
-      sloppyMsgId: 'ref-sloppy-type',
-    },
-    actionParamType: {
-      check: checkActionParamTypeRef,
-      expectedMsgId: 'ref-expecting-action-param-type',
-      sloppyMsgId: 'ref-sloppy-actionparam-type',
-    },
-    eventType: {
-      check: checkEventTypeRef,
-      expectedMsgId: 'ref-expecting-event-type',
-      sloppyMsgId: 'ref-sloppy-event-type',
-    },
-    include: {
-      check: checkIncludesRef,
-      expectedMsgId: 'ref-expecting-struct',
-    },
-    viewInclude: {
-      check: checkViewIncludesRef,
-      expectedMsgId: 'ref-expecting-bare-aspect',
-    },
-    target: {
-      check: checkEntityRef,
-      expectedMsgId: 'ref-expecting-entity',
-      noDep: true,
-    },
-    targetAspect: {
-      check: checkTargetRef,
-      expectedMsgId: 'ref-expecting-target',
-      sloppyMsgId: 'ref-sloppy-target',
-      noDep: 'only-entity',
-    },
-    from: {
-      check: checkSourceRef,
-      expectedMsgId: 'ref-expecting-source',
-      assoc: 'from',
-      argsSpec: 'expr',
-    },
-    // element references ----------------------------------------------------
-    // TODO: dep for (explicit+implicit!) foreign keys
-    // TODO: also check that we do not follow associations in foreign key? no args, no filter
-    targetElement: { assoc: false },
-    filter: {
-      escape: 'param',
-    },
-    'calc-filter': {
-      escape: 'param',
-    },
-    default: {
-      check: checkConstRef,
-      expectedMsgId: 'ref-expecting-const',
-    },
-    expr: {
-      escape: 'param', assoc: 'nav',
-    },
-    'param-only': {
-      escape: 'param',
-    },
-    calc: {
-      assoc: 'nav',
-    },
-    joinOn: {                   // ON condition for JOIN: should be different to 'expr'!
-      escape: 'param', assoc: 'nav',
-    },
-    on: {               // TODO: there will also be a 'from-on' (see 'expr')
-      noDep: true,              // do not set dependency for circular-check
-      allowSelf: true,
-    }, // TODO: special assoc for only on user
-    'mixin-on': {
-      escape: 'param',    // TODO: extra check that assocs containing param in ON is not published
-      noDep: true,              // do not set dependency for circular-check
-      allowSelf: true,
-    }, // TODO: special assoc for only on user
-    // ---------marker for getPathRoot replaced-----------
-    'order-by-ref': {
-      next: '_$next',
-      dollar: true,
-      escape: 'param',
-      assoc: 'nav',
-      dynamic: 'query',
-      deprecatedSourceRefs: true,
-    },
-    'order-by-expr': {
-      next: '_$next',
-      dollar: true,
-      escape: 'param',
-      assoc: 'nav',
-    },
-    'order-by-set-ref': {
-      next: '_$next',
-      dollar: true,
-      escape: 'param',
-      noDep: true,
-      dynamic: 'query',
-      lexical: 'next',
-    },
-    'order-by-set-expr': {
-      next: '_$next',
-      dollar: true,
-      escape: 'param',
-      noDep: true,
-      dynamic: false,
-      lexical: 'next',
-    },
-    // expr TODO: better - on condition for assoc, other on
-    // expr TODO: write dependency, but care for $self
-    param: {
-      check: checkConstRef,
-      expectedMsgId: 'ref-expecting-const',
-    },
-  };
-
   Object.assign( model.$functions, {
+    traverseExpr,
     resolveUncheckedPath,
-    resolveTypeArgumentsUnchecked,
+    resolveTypeArgumentsUnchecked, // TODO: move to some other file
     resolvePath,
+    checkExpr,
+    checkOnCondition,
+    nestedElements,
     attachAndEmitValidNames,
   } );
   return;
 
-  function checkConstRef( art ) {
-    return art.kind !== 'builtin' && art.kind !== 'param';
-  }
-
-  function checkIncludesRef( art ) {
-    // We currently disallow using
-    // - derived structure types: would have to follow type in extend/include;
-    // - entities with params: clarify inheritance, use of param in ON/DEFAULT;
-    // - query entities/events: difficult sequence of resolve steps
-    // - aspect without elements (useful for actions/annotations)
-    return !(art.elements && !art.query && !art.type && !art.params) && art.kind !== 'aspect';
-  }
-
-  /**
-   * Returns true, if the given artifact can be included by a query entity / view.
-   *
-   * We currently allow:
-   * - aspects without elements (the aspect may have actions):
-   *   either no `elements` property or empty dictionary
-   *
-   * @param {XSN.Artifact} art
-   * @return {boolean}
-   */
-  function checkViewIncludesRef( art ) {
-    return !(art.kind === 'aspect' && (!art.elements || Object.keys(art.elements).length === 0));
-  }
-
-  /**
-   * @returns {boolean|string}
-   */
-  function checkTypeRef( art ) {
-    if (art.kind === 'type' || art.kind === 'element')
-      return false;
-    return ![ 'entity', 'aspect', 'event' ].includes( art.kind ) || 'sloppy';
-  }
-
-  /**
-   * @returns {boolean|string}
-   */
-  function checkActionParamTypeRef( art ) {
-    return !(art.kind === 'entity' && art._service) && checkTypeRef( art );
-  }
-
-  /**
-   * @returns {boolean|string}
-   */
-  function checkEventTypeRef( art ) {
-    return art.kind !== 'event' && checkActionParamTypeRef( art );
-  }
-
-  function checkEntityRef( art ) {
-    return art.kind !== 'entity';
-  }
+  // Expression traversal function ----------------------------------------------
+  function traverseExpr( expr, exprCtx, user, callback ) {
+    if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
+      return;
 
-  /**
-   * @returns {boolean|string}
-   */
-  function checkTargetRef( art ) {
-    if (art.kind === 'entity' || art.kind === 'aspect')
-      return false;
-    return art.kind !== 'type' || 'sloppy';
-  }
+    if (expr.path) {
+      callback( expr, exprCtx, user );
+      // TODO: move arguments and filter traversal to here
+      return;
+    }
+    else if (expr.type || expr.query) {
+      callback( expr, exprCtx, user );
+    }
 
-  function checkSourceRef( art, path ) { // for FROM
-    if (!art._main)
-      return (art.kind !== 'entity');
-    const elem = path.find( item => item._artifact._main )._artifact;
-    // at least the last main definition should be an entity
-    // an additional check for target would need effectiveType()
-    return (elem && elem._main.kind !== 'entity');
+    if (expr.args) {
+      const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
+      // TODO: re-think $expected
+      if (!callback.traverse?.( args, exprCtx, user, callback ))
+        args.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
+    }
+    if (expr.suffix)              // fn( … ) OVER …
+      expr.suffix.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
   }
 
   // Return absolute name for unchecked path `ref`.  We first try searching for
@@ -441,7 +320,7 @@ function fns( model ) {
     if (Array.isArray( art ))
       art = art[0];
     if (!art)
-      return (semantics.notFound) ? art : pathName( path );
+      return (semantics.dynamic !== modelDefinitions) ? art : pathName( path );
     if (path.length === 1)
       return art.name.absolute; // TODO: name.id
     return `${ art.name.absolute }.${ pathName( ref.path.slice(1) ) }`;
@@ -465,7 +344,7 @@ function fns( model ) {
       return setArtifactLink( ref, undefined );
     }
 
-    const s = referenceSemantics[expected]; // TODO: temp indirection
+    const s = referenceSemantics[expected];
     const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
 
     const r = getPathRoot( ref, semantics, origUser );
@@ -473,59 +352,38 @@ function fns( model ) {
     if (!root)
       return setArtifactLink( ref, root );
 
-    let spec = specExpected[expected];
-    if (ref.scope === 'param') {
-      if (!spec.escape)
-        throw new CompilerAssertion( 'getPathRoot() should have returned falsy val' );
-      spec = specExpected[spec.escape];
-    }
-
     // how many path items are for artifacts (rest: elements)
     // console.log(expected, ref.path.map(a=>a.id),artItemsCount)
-    let art = getPathItem( ref, semantics, spec, user );
+    let art = getPathItem( ref, semantics, user );
     if (!art)
       return setArtifactLink( ref, art );
 
-    if (art.$autoElement) {
-      const { location } = path[path.length - 1];
-      const step = { id: art.$autoElement, $inferred: '$autoElement', location };
-      art = art.elements[step.id];
-      setArtifactLink( step, art );
-      path.push( step );
-    }
-    if (spec.check && !ref.$expected) { // do not check with exists path (is already error)
-      const fail = spec.check( art, path );
-      if (fail === true) {
-        signalNotFound( spec.expectedMsgId, [ ref.location, user ], null );
-        return setArtifactLink( ref, false );
-      }
-      else if (fail) {
-        signalNotFound( spec.sloppyMsgId, [ ref.location, user ], null );
-        // no return!
-      }
-    }
-    if (spec.warn) {
-      const msgId = spec.warn( art, user );
-      if (msgId)
-        warning( msgId, [ ref.location, user ] );
-    }
-    if (user && (!spec.noDep ||
-                 spec.noDep === 'only-entity' && art.kind !== 'entity')) {
-      const { location } = ref; // || combinedLocation( head, path[tail.length] );
-      // TODO: location of last path item if not main artifact
-      if (spec.assoc === 'from' && art._main) {
-        dependsOn( user, art._main, location );
+    // TODO: use isMainRef string value here?
+    const acceptFn = semantics.accept || (semantics.isMainRef ? a => a : acceptElemOrVar);
+    art = setArtifactLink( ref, acceptFn( art, user, ref, semantics ) );
+
+    // TODO TMP: remove noDep: an association does not depend on the target, only
+    // -- on its keys/on, which depend on certain target elements
+    if (art && user && !semantics.noDep) {
+      const location = artifactRefLocation( ref );
+      if (semantics.noDep === '' && art._main) { // assoc in FROM
         environment( art, location, user );
+        const target = art._effectiveType?.target?._artifact;
+        if (target)
+          dependsOn( user._main, target, location, user );
       }
-      else if (art.kind !== 'select') { // no real dependency to bare $self
+      else if (art._main && art.kind !== 'select' || path[0]._navigation?.kind !== '$self') {
+        // no real dependency to bare $self (or actually: the underlaying query)
         dependsOn( user, art, location );
         // Without on-demand resolve, we can simply signal 'undefined "x"'
       // instead of 'illegal cycle' in the following case:
       //    element elem: type of elem.x;
       }
+      // TODO: really write dependency with expand/inline?  write test
+      // (removing it is not incompatible => not urgent)
     }
     // TODO: follow FROM here, see csnRef - fromRef
-    return setArtifactLink( ref, art );
+    return art;
   }
 
   /**
@@ -533,7 +391,7 @@ function fns( model ) {
    * User is used for semantic message location.
    *
    * For builtins, for each property name `<prop>` in `typeArtifact.parameters`, we move a value
-   * in art.$typeArgs (a vector of numbers with locations) to `artifact.<prop>`.
+   * from `art.$typeArgs` (a vector of numbers with locations) to `artifact.<prop>`.
    *
    * For non-builtins, we take either one or two arguments and interpret them
    * as `length` or `precision`/`scale`.
@@ -550,14 +408,12 @@ function fns( model ) {
     let args = artifact.$typeArgs || [];
     const parameters = typeArtifact?.parameters || [];
 
-    if (parameters.length > 0) {
+    if (args.length > 0 && parameters.length > 0) {
       // For Builtins
       for (let i = 0; i < parameters.length; ++i) {
-        let par = parameters[i];
-        if (!(par instanceof Object))
-          par = { name: par };
-        if (!artifact[par.name] && i < args.length)
-          artifact[par.name] = args[i];
+        const par = parameters[i].name || parameters[i];
+        if (!artifact[par] && i < args.length)
+          artifact[par] = args[i];
       }
       args = args.slice(parameters.length);
     }
@@ -622,7 +478,7 @@ function fns( model ) {
       const [ nextProp, dictProp ] = (isMainRef)
         ? [ '_block', 'artifacts' ]
         : [ '_$next', '$tableAliases' ];
-      // let notApplicable = ...;  // for table aliases in JOIN-ON and UNION order-by
+      // let notApplicable = ...;  // for table aliases in JOIN-ON and UNION orderBy
       for (let env = lexical; env; env = env[nextProp]) {
         const dict = env[dictProp] || Object.create(null);
         const r = dict[head.id];
@@ -646,8 +502,6 @@ function fns( model ) {
       valid.push( dynamicDict );
     else
       valid.push( model.$magicVariables.artifacts, removeDollarNames( dynamicDict ) );
-    if (semantics.notFound === false)
-      return setArtifactLink( head, null );
     // TODO: streamline function arguments (probably: user, path, semantics )
     const undef = semantics.notFound( ruser, head, valid, dynamicDict,
                                       !isMainRef && user._user && user._artifact, path );
@@ -661,7 +515,7 @@ function fns( model ) {
   // TODO - think about setting _navigation for all $navElement – the
   // "ref: ['tabAlias']: inline: […]" handling might be easier
   // (no _pathHead consultation for key prop and renaming support)
-  function getPathItem( ref, semantics, spec, user ) {
+  function getPathItem( ref, semantics, user ) {
     // let art = (headArt && headArt.kind === '$tableAlias') ? headArt._origin : headArt;
     const { path } = ref;
     let artItemsCount = 0;
@@ -671,11 +525,10 @@ function fns( model ) {
                       (ref.scope ? 1 : path.length);
     }
     let art = null;
-    let nav = spec.assoc !== '$keys' && null; // false for '$keys'
-    const last = path[path.length - 1];
-    // TODO: change elementsEnv via semantics for static versus dynamic assoc navigation
     const elementsEnv = semantics.navigation || environment;
+    let index = -1;
     for (const item of path) {
+      ++index;
       --artItemsCount;
       if (!item?.id)    // incomplete AST due to parse error
         return undefined;
@@ -686,33 +539,24 @@ function fns( model ) {
 
       const prev = art;
       const envFn = (artItemsCount >= 0) ? artifactsEnv : elementsEnv;
-      const env = envFn( art, item.location, user, spec.assoc );
-      art = setArtifactLink( item, env?.[item.id] );
+      // TOOD: call envFn with location of last item (for dependency error)
+      const env = envFn( art, path[index - 1].location, user );
+      const found = env && env[item.id];  // not env?.[item.id] ! …we want to keep the 0
+      // Reject `$self.$_column_1`:
+      art = setArtifactLink( item, (found?.name?.$inferred === '$internal') ? undefined : found );
 
       if (!art) {
-        // element was not found in environment
-
         // TODO (done?): if `env` was 0, we might set a dependency to induce an
         // illegal-cycle error instead of reporting via `errorNotFound`.
-        if (prev.$uncheckedElements) { // magic variable / replacement variable
-          signalNotFound( 'ref-unknown-var', [ item.location, user ], [ env ],
-                          { id: pathName( path ) } );
-        }
-        else if (isMainRef && artItemsCount >= 0) { // artifact ref
-          if (semantics.notFound === false)
-            return null;
-          // TODO: streamline funtion arguments (probably: user, path, semantics, prev )
-          semantics.notFound( user, item, [ env ], null, prev, path );
-        }
-        else {
-          errorNotFound( item, env, prev, spec, user );
-        }
+        const notFound = (artItemsCount >= 0) ? semantics.notFound : undefinedItemElement;
+        // TODO: streamline function arguments (probably: user, path, semantics, prev )
+        // false returned by semantics.navigation: no further error:
+        if (env !== false)
+          notFound( user, item, [ env ], null, prev, path );
         return null;
       }
-      // TODO: what what about extra dependencies if we navigate along
-      // associations?  See also extra args for environment()
-      nav = setSomeNavigationLinkForAssoc( nav, item, art, prev?.target, last, user );
       // need to do that here, because we also need to disallow Service.AutoExposed:elem
+      // TODO: but Service.AutoExposed.NotAuto should be fine
       if (isMainRef !== 'all' && artItemsCount === 0 &&
           art.$inferred === 'autoexposed' && !user.$inferred) {
         // Depending on the processing sequence, the following could be a
@@ -721,92 +565,12 @@ function fns( model ) {
         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;
+        return null;            // continuation semantics: like “not found”
       }
     }
-    // Final checks on artifact (could be done in an extra function)
-    if (art.$requireElementAccess) { // on some CDS variables
-      // Path with only one item, but we expect an element, e.g. `$at.from`.
-      signalMissingElementAccess(art, [ last.location, user ]);
-    }
     return art;
   }
 
-  // To be analysed what it does exactly, see changes #3660, #3666:
-  function setSomeNavigationLinkForAssoc( nav, item, sub, target, last, user ) {
-    if (nav) {              // we have already "pseudo-followed" a managed association
-      // We currently rely on the check that targetElement references do
-      // not (pseudo-) follow associations, otherwise potential redirection
-      // there had to be considered, too.  Also, fk refs to sub elements in
-      // combinations with redirections of the target which directly access
-      // the potentially renamed sub elements would be really complex.
-      // With our restriction, no renaming must be considered for item.id.
-      setTargetReferenceKey( item.id );
-    }
-    // Now set an _navigation link for managed assocs in ON condition etc
-    else if (target && nav != null) {
-      // Find the original ref for sub and the original foreign key
-      // definition.  This way, we do not need the foreign keys with
-      // rewritten target element path, which might not be available at
-      // this point (rewriteKeys in Resolver Phase 5).  If we want to
-      // follow associations in foreign key definitions, rewriteKeys must
-      // be moved to the on-demand Resolver Phase 2.
-      let orig;             // for the original target element
-      for (let o = sub; o; o = o.value && o.value._artifact) // TODO: or use _origin?
-        orig = o;
-      nav = (orig._effectiveType || orig).$keysNavigation;
-      setTargetReferenceKey( orig.name.id );
-    }
-    return nav;
-
-    function setTargetReferenceKey( id ) {
-      const node = nav && nav[id];
-      nav = null;
-      if (node) {
-        if (node._artifact) {
-          // set the original(!) foreign key for the assoc - the "right" ones
-          // after rewriteKeys() is the one with the same name.id
-          setLink( item, '_navigation', node._artifact );
-          if (item === last)
-            return;
-        }
-        else if (item !== last) {
-          nav = node.$keysNavigation;
-          return;
-        }
-      }
-      error( null, [ item.location, user ], {},
-             // eslint-disable-next-line max-len
-             'You can\'t follow associations other than to elements referred to in a managed association\'s key' );
-    }
-  }
-
-  function errorNotFound( item, env, art, spec, user ) {
-    if (art.name && art.name.select && art.name.select > 1) {
-      // TODO: 'The current query has no element $(MEMBER)' with $self.MEMBER
-      // and 'The sub query for alias $(ALIAS) has no element $(MEMBER)'
-      // TODO: probably not extra messageId, but text variant
-      // TODO: views elements are proxies to query-0 elements, not the same
-      // TODO: better message text
-      signalNotFound( 'query-undefined-element', [ item.location, user ],
-                      [ env ], { id: item.id } );
-    }
-    else if (art.kind === '$parameters') {
-      signalNotFound( 'ref-undefined-param', [ item.location, user ],
-                      [ env ], { art: art._main, id: item.id } );
-    }
-    else {
-      const variant = art.kind === 'aspect' && !art.name && 'aspect';
-      signalNotFound( spec.undefinedDef || 'ref-undefined-element', [ item.location, user ],
-                      [ env ], {
-                        '#': variant,
-                        art: (variant ? '' : searchName( art, item.id, 'element' )),
-                        id: item.id,
-                      } );
-    }
-    return null;
-  }
-
   // Helper functions for resolve[Unchecked]Path, getPath{Root,Item}: -----------
 
   function acceptLexical( art, path, semantics, user ) {
@@ -822,7 +586,7 @@ function fns( model ) {
       return true;
     }
     // return !art.$internal && art;
-    return art.$inferred !== '$internal';
+    return art.name?.$inferred !== '$internal'; // not a compiler-generated internal alias
   }
 
   function acceptPathRoot( art, ref, semantics, user ) {
@@ -859,12 +623,6 @@ function fns( model ) {
         // TODO: remove again, should be easy enough in to-csn without.
         if (path.length === 1 && art.kind === '$tableAlias')
           user.$noOrigin = true;
-        if (path.length === 1 && !semantics.allowBareSelf && !user.expand && !user.inline) {
-          // TODO: better ref-invalid-self
-          error( 'ref-unexpected-self', [ head.location, user ], { id: head.id } );
-          // TODO: reject bare $projection here (new message id, configurable)
-          // not really helpful to attach valid names here (would include $self)
-        }
         return art;
       }
       case '$parameters': {     // TODO: remove from CC
@@ -902,11 +660,13 @@ function fns( model ) {
 
   function typeOfSemantics( user, [ head ] ) {
     // `type of` is only allowed for (sub) elements of main artifacts
+    while (!user.kind && user._outer)
+      user = user._outer;
     let struct = user;
     while (struct.kind === 'element')
       struct = struct._parent;
     if (struct === user._main && struct.kind !== 'annotation')
-      return { dynamic: typeOfParentDict };
+      return { dynamic: typeOfParentDict, navigation: staticTarget };
     error( 'type-unexpected-typeof', [ head.location, user ],
            { keyword: 'type of', '#': struct.kind } );
     return false;
@@ -916,7 +676,7 @@ function fns( model ) {
     return { dynamic: artifactParams, notFound: undefinedParam };
   }
   function paramUnsupported( user, _path, location ) {
-    error( 'ref-unexpected-scope', [ location, user ],
+    error( 'ref-unexpected-scope', [ location, user ], // TODO: ref-unexpected-param
            // why an extra text for calculated elements? or separate for all?
            { '#': (user.$syntax === 'calc' ? 'calc' : 'std') } );
     return false;
@@ -979,9 +739,10 @@ function fns( model ) {
   }
 
   function targetElements( user, pathItemArtifact ) {
-    // const assoc = user._parent;
-    // const target = resolvePath( assoc.target, 'target', assoc );
-    return environment( pathItemArtifact || user._parent, null, null, null, true );
+    // has already been computed - no further `navigationEnv` args needed
+    const env = navigationEnv( pathItemArtifact || user._parent );
+    // do not use env?.elements: a `0` should stay a `0`:
+    return env && env.elements;
   }
 
   function combinedSourcesOrParentElements( user ) {
@@ -999,16 +760,27 @@ function fns( model ) {
   }
 
   function nestedElements( user ) {
-    Functions.navigationEnv( user._pathHead ); // set _origin
-    return environment( user._pathHead._origin );
+    const colParent = user._pathHead;
+    Functions.effectiveType( colParent ); // set _origin
+    const path = colParent?.value?.path;
+    if (!path?.length)
+      return undefined;
+    // also set dependency when navigating along assoc → provide location
+    return environment( colParent._origin, path[path.length - 1].location, colParent );
+  }
+
+  // Function called via semantics.navigation: ----------------------------------
+  // default is function `environment`
+
+  function artifactsEnv( art ) {
+    return art._subArtifacts || Object.create(null);
   }
 
-  function targetAspectOnly( prev ) {
-    let env = Functions.navigationEnv( prev, null, null, 'targetAspectOnly' );
-    while (env?.target && !env.targetAspect)
-      env = env._origin || env.type?._artifact;
+  function staticTarget( prev ) {
+    let env = navigationEnv( prev ); // we do not write dependencies for assoc navigation
     if (env === 0)
       return 0;
+    // Last try - Composition with targetAspect only (in aspect def):
     const target = env?.targetAspect;
     if (target) {
       if (target.elements)
@@ -1018,8 +790,28 @@ function fns( model ) {
     return env?.elements || Object.create(null);
   }
 
-  function artifactsEnv( art ) {
-    return art._subArtifacts || Object.create(null);
+  function targetNavigation( art, location, user ) {
+    const env = navigationEnv( art, location, user, false );
+    // do not use env?.elements: a `0`/false should stay a `0`/false:
+    return env && env.elements;
+  }
+
+  function assocOnNavigation( art, location, user ) {
+    const env = navigationEnv( art, location, user, null );
+    // `null` means: do not write a dependency from target of any association
+    // otherwise “following” own assoc would lead to cycle.
+    // TODO: disallow navigation other than of own assoc, and to foreign keys
+    // This way (not here though, but later in resolve.js)
+    if (env === 0)
+      return 0;
+    return env?.elements || Object.create(null);
+  }
+
+  function calcElemNavigation( art, location, user ) {
+    const env = navigationEnv( art, location, user, 'calc' );
+    if (env === 0)
+      return 0;
+    return env?.elements || Object.create(null);
   }
 
   // Return effective search environment provided by artifact `art`, i.e. the
@@ -1027,13 +819,47 @@ function fns( model ) {
   // chain and resolve the association `target`.  View elements are calculated
   // on demand.
   // TODO: what about location/user when called from getPath ?
-  // TODO: think of always acting as if falsyIfNone would be true
+  // TODO: think of removing `|| Object.create(null)`.
   //       (if not possible, move to second param position)
-  function environment( art, location, user, assocSpec, falsyIfNone ) {
-    const env = Functions.navigationEnv( art, location, user, assocSpec );
+  function environment( art, location, user ) {
+    const env = navigationEnv( art, location, user, 'nav' );
     if (env === 0)
       return 0;
-    return env?.elements || !falsyIfNone && Object.create(null);
+    return env?.elements || Object.create(null);
+  }
+
+  function navigationEnv( art, location, user, assocSpec ) {
+    // = effectiveType() on from-path, TODO: should actually already part of
+    // resolvePath() on FROM
+    if (!art)
+      return undefined;
+    let type = Functions.effectiveType( art );
+    while (type?.items)          // TODO: disallow navigation to many sometimes
+      type = Functions.effectiveType( type.items );
+    if (!type?.target)
+      return type;
+
+    if (assocSpec === false) {  // TODO: move to getPathItem
+      error( null, [ location, user ], {},
+             'Following an association is not allowed in an association key definition' );
+      return false;
+    }                   // TODO: else warning for assoc usage with falsy assocSpec
+    const target = type?.target._artifact;
+    if (!target)
+      return target;
+    // TODO: really write final dependency with expand/inline?
+    if (target && assocSpec && user) {
+      if (assocSpec !== 'calc')
+        dependsOn( user._main || user, target, location || user.location, user );
+      else  // (TODO: users of) calc elements must depend on navigation target
+        dependsOn( user, target, location || user.location );
+      // TODO: have some _delayedDeps for calc elements
+    }
+    const effectiveTarget = Functions.effectiveType( target );
+    // if (effectiveTarget === 0 && location)
+    //   dependsOn( user, user, (user.target || user.type || user.value || user).location );
+    // console.log('NT:',assocSpec,!!user,target)
+    return effectiveTarget;
   }
 
   // Functions called via semantics.notFound: -----------------------------------
@@ -1072,10 +898,12 @@ function fns( model ) {
     // TODO: avoid message if we have already complained about `(exists …)`?
     const { id } = head;
     const isVar = id.charAt( 0 ) === '$' && id !== '$self';
+    // TODO: for wrong $self, also use ref-undefined-var, but with extra msg id
+    // otherwise, use s/th like ref-unexpected-element
     signalNotFound( (isVar ? 'ref-undefined-var' : 'ref-expecting-const'),
                     [ head.location, user ],
                     valid, { '#': 'std', id } );
-    // TODO: use s/th better than 'ref-expecting-const'?
+    // TODO: use s/th better than 'ref-expecting-const' !!
   }
 
   function undefinedSourceElement( user, head, valid, dynamicDict ) {
@@ -1110,7 +938,7 @@ function fns( model ) {
     }
     else {
       // TODO: extra msg like ref-rejected-on if elem found in source elements?
-      // also whether users wronly tried to refer to aliases/mixins?
+      // also whether users wrongly tried to refer to aliases/mixins?
       const msgVar = userQuery( user ) ? 'query' : null;
       // TODO: better with ON in expand if that is supported
       signalNotFound( 'ref-undefined-element', [ head.location, user ], valid,
@@ -1132,16 +960,489 @@ function fns( model ) {
     return null;
   }
 
-  function undefinedNestedElement( user, head, valid ) {
-    // environment( user._pathHead ); // set _origin
+  function undefinedNestedElement( user, head, valid, _dict, _art, path ) {
     const art = user._pathHead._origin;
-    // if (!art) console.log('UNE:',user,user._pathHead)
     if (!art)
-      return;                   // no consequential error
-    // TODO: better message with $ref
-    signalNotFound( 'ref-undefined-element', [ head.location, user ], valid,
-                    { art: searchName( art, head.id, 'element' ) } );
-    // TODO: remove use of searchName() ?
+      return null;              // no consequential error
+    return undefinedItemElement( user, head, valid, null, art, path );
+  }
+
+  function undefinedItemElement( user, item, valid, _dict, art, path ) {
+    if (art.name && art.name.select && art.name.select > 1) {
+      // TODO: 'The current query has no element $(MEMBER)' with $self.MEMBER
+      // and 'The sub query for alias $(ALIAS) has no element $(MEMBER)'
+      // both as text variants to ref-undefined-element
+      signalNotFound( 'query-undefined-element', [ item.location, user ],
+                      valid, { id: item.id } );
+    }
+    else if (art.kind === '$parameters') {
+      signalNotFound( 'ref-undefined-param', [ item.location, user ],
+                      valid, { art: art._main, id: item.id } );
+    }
+    else if (art.kind === 'builtin') { // magic variable / replacement variable
+      const id = (item === path[path.length - 1])
+        ? item.id
+        : pathName( path.slice( path.indexOf( item ) ) );
+      signalNotFound( (art.$uncheckedElements ? 'ref-unknown-var' : 'ref-undefined-var'),
+                      [ item.location, user ], valid,
+                      { id: `${ art.name.element }.${ id }` } );
+    }
+    else {
+      const variant = art.kind === 'aspect' && !art.name && 'aspect';
+      signalNotFound( 'ref-undefined-element', [ item.location, user ],
+                      valid, {
+                        '#': variant,
+                        art: (variant ? '' : searchName( art, item.id, 'element' )),
+                        id: item.id,
+                      } );
+    }
+    return null;
+  }
+
+  // Functions called via semantics.accept: -------------------------------------
+  // function arguments ( art, user, ref, semantics ),
+  // default (for elements only): acceptElemOrVar
+
+  function acceptElemOrVarOrSelf( art, user, ref ) {
+    // TODO: make $self._artifact point to the $self alias, not the entity
+    return (!(art._main && art.kind !== 'select') && ref.path[0]._navigation?.kind === '$self')
+      ? art
+      : acceptElemOrVar( art, user, ref );
+  }
+
+  function acceptElemOrVar( art, user, ref ) {
+    const { path } = ref;
+    if (art.kind === 'builtin') {
+      if (user.expand || user.inline) {
+        const location = (user.expand || user.inline)[$location];
+        const code = (user.expand) ? '{ ‹expand› }' : '.{ ‹inline› }';
+        message( 'def-unexpected-nested-proj', [ location, user ], { '#': 'var', code } );
+      }
+      else if (art.$requireElementAccess) { // on some CDS variables
+        // Path with only one item, but we expect an element, e.g. `$at.from`.
+        signalMissingElementAccess(art, [ path[0].location, user ]);
+        return null;
+      }
+      else if (art.$autoElement) {
+        const { location } = path[0];
+        const step = { id: art.$autoElement, $inferred: '$autoElement', location };
+        path.push( step );
+        art = art.elements[step.id];
+        return setArtifactLink( step, art );
+      }
+    }
+    // TODO: combine $requireElementAccess/$autoElement to $bareRoot ?
+    else if (!user.expand && !user.inline &&  // $self._artifact to main artifact
+        !(art._main && art.kind !== 'select') && ref.path[0]._navigation?.kind === '$self') {
+      // TODO: better ref-invalid-self
+      const { location, id } = path[0];
+      error( 'ref-unexpected-self', [ location, user ], { id } );
+      // TODO: reject bare $projection here (new message id, configurable)
+      // TODO: should we also attach valid names?  Probably not...
+      // TODO: return false;   ??
+      // return false;
+    }
+    return art;
+  }
+
+  function acceptStructOrBare( art, user, ref ) { // for includes[]
+    // It had been checked before that `includes` is already forbidden for
+    // non-entity/aspect/type/event.
+    //
+    // We currently disallow as include:
+    // - non-structured types or derived type of structured:
+    //   would have to follow type in extend/include;
+    // - entities with params: clarify inheritance, use of param in ON/DEFAULT;
+    // - query entities/events: difficult sequence of resolve steps
+    // - aspect with one ore more elements on query entities / events
+    // - aspect with `elements` property on non-structured types
+
+    // TODO: adapt `user` if it is an `extend`?  NOTE: we cannot call
+    // effectiveType() on user - it might be in the process of being computed!
+    // Also, it is not clear whether `art.elements` has been completed → testing
+    // its length might be processing-sequence dependent, see #11346.  We must
+    // ensure that an include does not add the `elements` property!
+    const base = (user.kind === 'extend' ? user.name._artifact : user);
+    if (!base)
+      return art;
+    if (base.query || base.type || !base.elements) {
+      // Remark: it is not necessary to test for user.elements[$inferred], because
+      // the type could only have inferred elements if it has a type expression.
+      // Including aspects with elements is forbidden for aspects without the
+      // `elements` property (TODO: ensure that, see #11346).  Testing for the length of
+      // `art.elements` requires that we have applied potential `includes` of
+      // `art` before!
+      if (art.kind === 'aspect' &&
+          (!art.elements || base.query && !Object.keys( art.elements ).length))
+        return art;
+      signalNotFound( 'ref-invalid-include', [ ref.location, user ], null,
+                      { '#': 'bare' } );
+    }
+    else {
+      if (!art.query && !art.type && !art.params && (art.elements || art.kind === 'aspect'))
+        return art;
+      signalNotFound( 'ref-invalid-include', [ ref.location, user ], null );
+    }
+    return false;
+  }
+
+  // Remember: an aspect should have already been moved to XSN targetAspect, but
+  // the error messages should still talk about potential aspects
+  function acceptEntity( art, user, ref ) { // for target
+    if (art.kind === 'entity')
+      return art;
+    // Extra msg text with Composition of NeitherEntityNorAspect:
+    const bare = !art.elements || art.elements[$inferred];
+    const std = (art.targetAspect || !isDirectComposition( user ) || user.kind === 'mixin');
+    const msg = std && 'std' || (bare && art.kind === 'aspect' ? 'bare' : 'composition');
+    signalNotFound( 'ref-invalid-target', [ ref.location, user ], null,
+                    { '#': msg } );
+    return false;
+  }
+
+  function acceptAspect( art, user, ref ) { // for targetAspect
+    const bare = !art.elements || art.elements[$inferred];
+    if (!bare) {
+      if (art.kind === 'aspect')
+        return art;
+      if (art.kind === 'type') {  // v4: Warning → config Error
+        signalNotFound( 'ref-sloppy-target', [ ref.location, user ], null );
+        return art;
+      }
+    }
+    signalNotFound( 'ref-invalid-target', [ ref.location, user ], null,
+                    { '#': (bare ? 'bare' : 'aspect'), prop: 'targetAspect' } );
+    return false;
+  }
+
+  function acceptEntityOrAssoc( art, user, ref ) { // for FROM
+    const { path, scope } = ref;
+    // see getPathItem(): how many path items are for the main artifact ref?
+    const artItemsCount = (typeof scope === 'number' && scope) || (scope ? 1 : path.length);
+    // at least the last main definition should be an entity
+    // an additional check for target would need effectiveType()
+    const source = path[artItemsCount - 1]._artifact;
+    if (source.kind !== 'entity') {
+      signalNotFound( 'ref-invalid-source', [ ref.location, user ], null );
+      return false;
+    }
+    if (source === art)
+      return art;
+    const assoc = Functions.effectiveType( art );
+    if (assoc.target)
+      return art;               // TODO: use target here
+    signalNotFound( 'ref-invalid-source', [ ref.location, user ], null );
+    return false;
+  }
+
+  function acceptTypeOrElement( art, user, ref ) { // for type
+    // was ['action', 'function'].includes( user._parent?.kind ))
+    while (user._outer)
+      user = user._outer;
+    const kind = (user.kind !== 'param' || user._parent?.kind !== 'entity')
+      ? user.kind
+      : 'entity-param';
+    switch (art.kind) {
+      case 'type':
+      case 'element':
+        return art;
+      case 'entity':
+        if (kind === 'param' && art._service)
+          return art;
+        // FALLTHROUGH
+      case 'event':
+        if (kind === 'event')
+          return art;
+        break;
+      default:
+        break;
+    }
+    signalNotFound( 'ref-invalid-type', [ ref.location, user ], null, { '#': kind } );
+    return false;
+  }
+
+  // Functions called via semantics.check by checkExpr(): -----------------------
+  //
+  // function arguments: ( expr, exprCtx, user )
+  // default: tbd (nothing for main artifac ref)
+
+  // Performs checks which would be too early to do via semantics.accept.  It is
+  // actually assumed that the foreign-keys / ON-condition rewrite has already
+  // been done.
+
+  // Main check area "navigation" (see also semantics.navigation):
+  // - navigation along any assoc
+  // - navigation only along foreign keys
+  // - (no navigation already via semantics.navigation for target refs of foreign keys)
+  // - special (ON-condition of unmanaged associations)
+
+  // Main check area: checks on the referred artifact
+  // - all artifacts are allowed
+  // - all except unmanaged associations
+  // - ...
+
+  function checkExpr( expr, exprCtx, user ) {
+    if (!expr)
+      return;
+    const s = referenceSemantics[exprCtx];
+    const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
+    const checkFn = semantics.check; // || !semantics.isMainRef && checkElementStd;
+
+    if (checkFn)
+      traverseExpr( expr, exprCtx, user, checkFn );
+  }
+
+  // TODO: Don't allow path args and filter!
+  function checkOnCondition( expr, exprCtx, user ) {
+    if (!expr || expr.$inferred)
+      return;
+    const { op } = expr;
+    let { args } = expr;
+    if (!op || !args) {
+      checkExpr( expr, exprCtx, user );
+      return;
+    }
+    if (op?.val === '=')        // TMP
+      args = [ args[0], { val: '=', literal: 'token' }, args[1] ];
+
+    for (let index = 0; index < args.length; ++index) {
+      const item = args[index];
+      const eq = args[index + 1];
+      if (eq?.val === '=' && eq.literal === 'token' && item.path && !item.scope) {
+        const right = args[index + 2];
+        if (right?.path && !right.scope &&
+            (isDollarSelfPair( item, right, user ) || isDollarSelfPair( right, item, user ))) {
+          checkAssocOnSelf( item, exprCtx, user );
+          checkAssocOnSelf( right, exprCtx, user );
+          index += 2;
+          continue;
+        }
+      }
+      checkOnCondition( item, exprCtx, user );
+    }
+  }
+
+  // // standard element reference check;
+  // function checkElementStd( art, _user, ref, semantics ) {
+  //   // No further checks on navigation: nothing to do
+  //   // Must not end with any association (TODO: allow managed?):
+  //   if (art.target) { // && art.on
+  //     // error
+  //   }
+  // }
+
+  function checkColumnRef( expr, exprCtx, user ) {
+    if (!expr.path)
+      return;
+    if (expr === user.value && // is already a syntax error with non-ref expression
+        (user.expand || user.inline))
+      checkExpandInlineRef( expr._artifact, user, expr );
+
+    const self = pathStartsWithSelf( expr );
+    // 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' );
+    }
+    // TODO: set navigation dependencies later to avoid both ref-cyclic and
+    // ref-invalid-navigation/ref-unexpected-assoc
+  }
+
+  function checkOrderByRef( expr, exprCtx, user ) {
+    const { path } = expr;
+    if (!path)
+      return;
+    if (path?.[0]?._navigation?.kind !== '$tableAlias')
+      checkOnlyForeignKeyNavigation( user, expr.path );
+    checkNoUnmanaged( expr, user );
+  }
+
+  function checkRefInQuery( expr, exprCtx, user ) {
+    const { path } = expr;
+    if (!path)
+      return;
+    if (pathStartsWithSelf( expr ))
+      checkOnlyForeignKeyNavigation( user, expr.path, 0, 'self-' );
+    checkNoUnmanaged( expr, user );
+  }
+
+  function checkExpandInlineRef( art, user, ref ) {
+    if (!art || !art._main ||   // $self has entity as _artifact
+        art.kind === 'builtin') // no repeated error for CDS variables
+      return;
+    const effective = art._effectiveType;
+    if (!effective || effective.target || effective.elements)
+      return;
+    const { path } = ref;
+    const location = (user.expand || user.inline)[$location];
+    // mention `table alias` in text only with initial single path item ref,
+    // but do not mention that $self { … } is allowed, shouldn't be advertised:
+    const txt = (path.length > 1 || user._pathHead) ? 'struct' : 'init';
+    const code = (user.expand) ? '{ ‹expand› }' : '.{ ‹inline› }';
+    message( 'def-unexpected-nested-proj', [ location, user ], { '#': txt, code } );
+  }
+
+  function isDollarSelfPair( left, right, user ) {
+    if (!left.path || !right.path || left.scope || right.scope)
+      return false; // param ref `:$self` is not $self
+    // $self in entity (TODO: mixin? new assoc in col? in aspect?)
+    const kind = right._artifact?.kind;
+    if (kind !== 'entity' && kind !== 'aspect' && kind !== 'select')
+      return false;           // (ok, this would also return `false` for `:$self`)
+    const { path } = left;
+    // TODO: we might return true and issue an extra error here
+    return userTargetElementPathIndex( user, path ) > 0;
+  }
+
+  function checkAssocOn( ref, exprCtx, user ) {
+    const { path } = ref;
+    if (!path)
+      return;
+    if (path.length === 1 && path[0]._navigation?.kind === '$self') {
+      // resolvePath() for `on` allowed bare $self: disallow except in checkAssocOnSelf
+      const { location, id } = path[0];
+      error( 'ref-unexpected-self', [ location, user ], { '#': 'on', id } );
+      return;
+    }
+    const index = userTargetElementPathIndex( user, path );
+    checkOnlyForeignKeyNavigation( user, path, index );
+    if (ref._artifact?.on) {
+      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' } );
+    }
+  }
+
+  function checkAssocOnSelf( ref, exprCtx, user ) {
+    // TODO: fully specify what `‹current_assoc›.‹backlink› = $self` means if the
+    // target of ‹backlink› is not the current entity.
+    // - what does it mean in an aspect
+    // - how about auto-redirections/rewrite
+    const { path } = ref;
+    if (path.length === 1 && path[0]._navigation?.kind === '$self') {
+      const query = userQuery( user );
+      const main = query?._main;
+      if (query && query !== main._leadingQuery) {
+        const { txt, op } = getQueryOperatorName( query );
+        const { location, id } = path[0];
+        error( 'ref-unexpected-self', [ location, user ], { '#': txt, id, op } );
+      }
+      return;
+    }
+    const index = userTargetElementPathIndex( user, path );
+    checkOnlyForeignKeyNavigation( user, path, index );
+    const target = index > 0 && index < path.length && ref._artifact?.target;
+    if (!target) {
+      const last = path[path.length - 1];
+      error( 'ref-expecting-target-assoc', [ last.location, user ], { id: '$self' },
+             'Only an association of the target side can be compared to $(ID)' );
+    }
+    // in entity: target must match
+    // in aspect: must end with assoc, TODO: target must include aspect (+ add/ check)
+    else if (target._artifact && target._artifact !== user._main && user._main.kind === 'entity') {
+      const last = path[path.length - 1];
+      warning( 'ref-invalid-backlink', [ last.location, user ], { art: target, id: '$self' },
+               // eslint-disable-next-line max-len
+               'The target $(ART) of the association is not the current entity represented by $(ID)' );
+    }
+  }
+
+
+  // right of union: parent = main → get correct operator
+  // FROM subquery: parent = tab alias of outer query
+  // other sub query: parent = outer query
+  function getQueryOperatorName( query ) {
+    if (query._parent !== query._main)
+      return { txt: 'subQuery', op: '' };
+
+    for (let set = query._main.query; set.op; set = set.args[0]) {
+      const right = set.args[1];
+      if (query.name.select >= (right._leadingQuery || right).name.select)
+        return { txt: 'setQuery', op: set.op.val };
+    }
+    throw new CompilerAssertion( 'Did we pass the leading query as argument?' );
+  }
+
+  function userTargetElementPathIndex( user, path ) {
+    const head = path[0];
+    if (head._artifact === user) // standard case
+      return 1;
+    if (head._navigation?.kind !== '$self')
+      return 0;
+    for (let index = 1; index < path.length; ++index) {
+      const assoc = path[index]?._artifact;
+      if (assoc?.target)
+        return (assoc === user) ? index + 1 : 0;
+    }
+    return 0;
+  }
+
+  function checkOnlyForeignKeyNavigation( user, path, startIndex = 0, msgPrefix = '' ) {
+    // has to be run after foreign-key rewrite
+    const outer = user._pathHead?._origin;
+    let assoc = outer?.foreignKeys &&
+                pathStartsWithSelf( { path } ) == null && // not $self or CDS var like $now
+                outer;
+    for (let index = startIndex; index < path.length; ++index) {
+      if (assoc?.target) {
+        if (!assoc.foreignKeys) {
+          error( 'ref-unexpected-assoc', [ path[index - 1].location, user ],
+                 { '#': `${ msgPrefix }unmanaged`, alias: '$self' } );
+          return;
+        }
+        if (!assoc.$keysNavigation)
+          Functions.addForeignKeyNavigations( assoc, true );
+        index = checkCoveredByForeignKey( assoc, path, index, user, msgPrefix );
+      }
+      assoc = path[index]?._artifact;
+    }
+  }
+
+  function checkCoveredByForeignKey( nav, path, index, user, msgPrefix = '' ) {
+    const assoc = nav;
+    while (index < path.length) {
+      const item = path[index];
+      nav = nav.$keysNavigation?.[item.id];
+      if (!nav)
+        break;
+      if (nav._artifact)
+        return index;
+      ++index;
+    }
+    const last = path[index] || path[index - 1];
+    // TODO: or just location of `last`?
+    // TODO: extra text variant if the foreign keys are the key elements !
+    // eslint-disable-next-line no-nested-ternary
+    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',
+    }, {
+      std: 'Can follow association $(ART) only to its foreign key references, not to $(NAME)',
+      keys: 'Can follow managed association $(ART) only to the keys of its target, not to $(NAME)',
+      complete: 'The reference must cover a full foreign key reference of association $(ART)',
+      // eslint-disable-next-line max-len
+      'self-std': 'In column ref starting with $(ALIAS), we can follow association $(ART) only to its foreign key references, not to $(NAME)',
+      // eslint-disable-next-line max-len
+      'self-keys': 'In column ref starting with $(ALIAS), we can follow managed association $(ART) only to the keys of its target, not to $(NAME)',
+      // eslint-disable-next-line max-len
+      'self-complete': 'The column reference starting with $(ALIAS) must cover a full foreign key reference of association $(ART)',
+    } );
+    // TODO later: mention allowed ones
+    return path.length;
+  }
+
+  function checkNoUnmanaged( ref, user, messageVariant = 'unmanaged' ) {
+    if (ref._artifact?.on && !ref.$expected) {
+      const { path } = ref;
+      const last = path[path.length - 1];
+      error( 'ref-unexpected-assoc', [ last.location, user ],
+             { '#': messageVariant, alias: '$self' } );
+    }
   }
 
   // Low-level functions --------------------------------------------------------
@@ -1155,7 +1456,7 @@ function fns( model ) {
    * @param  {object} [textParams]
    */
   function signalNotFound( msgId, location, valid, textParams ) {
-    if (location.$notFound)
+    if (location.$notFound)     // TODO: still necessary?
       return;
     location.$notFound = true;
     /** @type {object} */
@@ -1177,6 +1478,7 @@ function fns( model ) {
    * @param {any} location
    */
   function signalMissingElementAccess( art, location ) {
+    // TODO: ref-undefined-var ?
     const err = message( 'ref-expected-element', location,
                          { '#': 'magicVar', id: art.name.id } );
     // Mapping for better valid names: from -> $at.from
@@ -1205,7 +1507,7 @@ function fns( model ) {
       const art = valid[name];
       // ignore internal types such as cds.Association, ignore names with dot for
       // CDL references to main artifacts:
-      if (!art.internal && !art.deprecated && art.$inferred !== '$internal' &&
+      if (!art.internal && !art.deprecated && art.name?.$inferred !== '$internal' &&
           (viaCdl ? art._main || !name.includes('.') : art.kind !== 'namespace'))
         msg.validNames[name] = art;
     }