@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/compiler/populate.js

@@ -38,6 +38,7 @@ const {
   annotationLocation,
   linkToOrigin,
   setMemberParent,
+  dependsOn,
   proxyCopyMembers,
   setExpandStatus,
   setExpandStatusAnnotate,
@@ -855,6 +856,9 @@ function populate( model ) {
         const elemLocation = !query._main.$inferred && location;
         const origin = envParent ? navElem : navElem._origin;
         const elem = linkToOrigin( origin, name, query, null, elemLocation );
+        if (origin.$calcDepElement) // TODO: this will be changed in the next PR
+          dependsOn( elem, origin.$calcDepElement, location );
+
         // TODO: check assocToMany { * }
         dictAdd( elements, name, elem, ( _name, loc ) => {
           // there can be a definition from a previous inline with the same name:
@@ -1183,7 +1187,7 @@ function populate( model ) {
   function isDirectProjection( proj, base ) {
     return proj.kind === 'entity' && // not event
       // direct proj (TODO: or should we add them to another list?)
-      // TODO: delete ENTITY._from
+      // TODO: delete ENTITY._from - maybe not...
       proj.query && proj.query.op && proj.query.op.val === 'SELECT' &&
       proj._from && proj._from.length === 1 &&
       base === resolvePath( proj._from[0], 'from', proj.query );

package/lib/compiler/propagator.js

@@ -21,7 +21,7 @@ const {
   viewFromPrimary,
 } = require('./utils');
 const $inferred = Symbol.for( 'cds.$inferred' );
-// const { refString } = require( '../base/messages')
+// const { ref } = require( '../model/revealInternalProperties' )
 
 // Note that propagation here is also used for deep-copying (function `onlyViaParent`)
 function propagate( model ) {
@@ -59,7 +59,7 @@ function propagate( model ) {
     srid: always,
     localized: always,
     target: notWithExpand,
-    targetAspect: notWithExpand,
+    targetAspect,
     cardinality: notWithExpand,
     on: notWithExpand,
     foreignKeys: expensive,    // includes "notWithExpand", dictionary copy
@@ -68,6 +68,7 @@ function propagate( model ) {
     enum: expensive,
     params: expensive,          // actually only with parent action
     returns,
+    $filtered: annotation,
   };
   const { options } = model;
   // eslint-disable-next-line max-len
@@ -90,7 +91,7 @@ function propagate( model ) {
       runMembers( art );
       return;
     }
-    // console.log('RUN:', art.name, art.elements ? Object.keys(art.elements) : 0)
+    // if (!art.builtin)console.log('RUN:', ref(art))
 
     const chain = [];
     let targets = [ art ];
@@ -109,6 +110,7 @@ function propagate( model ) {
             if (target.value?._artifact.$inferred !== 'include') {
               // If the referred to element is not inferred, it is a new one and not the original.
               // The new one was not originally referred to => error;
+              // TODO: no messages in propagator.js
               warning( 'ref-unexpected-override', [ target.name.location, target ],
                        { id: target.name.id, target: target.value?._artifact },
                        'Calculated element $(ID) does not originally refer to $(TARGET)' );
@@ -134,11 +136,11 @@ function propagate( model ) {
     chain.reverse();
     chain.forEach( step );
     runMembers( art );
-    // console.log('DONE:', art.name, art.elements ? Object.keys(art.elements) : 0);
+    // if(!art.builtin)console.log('DONE:',ref(art),art.elements?Object.keys(art.elements):0);
   }
 
   function runMembers( art ) {
-    // console.log('MEMBERS:',refString(art), art.elements ? Object.keys(art.elements) : 0)
+    // if(!art.builtin)console.log('MEMBERS:',ref(art))
     forEachMember( art, run ); // after propagation in parent!
     // propagate to sub query elements even if not requested:
     if (art.$queries)
@@ -150,16 +152,29 @@ function propagate( model ) {
     }
     if (obj.items)
       run( obj.items );
+    obj = obj.targetAspect;
+    // if(obj)console.log('TA:',ref(art),!!getOrigin( obj ))
+    if (obj && isAnonymousAspect( obj ))
+      run( obj );
     setLink( art, '_status', 'propagated' );
   }
 
+  function isAnonymousAspect( aspect ) {
+    while (aspect) {
+      if (aspect.elements)
+        return true;
+      aspect = getOrigin( aspect );
+    }
+    return false;
+  }
+
   function step({ target, source }) {
-    // console.log('PROPS:',source&&source.name,'->',target.name)
     const viaType = target.type && // TODO: falsy $inferred value instead of 'cast'?
           (!target.type.$inferred || target.type.$inferred === 'cast');
     const keys = Object.keys( source );
+    // console.log('PROPS:',ref(source),'->',ref(target),keys.join('+'))
     for (const prop of keys) {
-      // TODO: warning with competing props from multi-includes
+      // TODO: warning with competing props from multi-includes, but not in propagator.js
       if (target[prop] !== undefined || source[prop] === undefined)
         continue;
       const transformer = props[prop] || props[prop.charAt(0)];
@@ -227,7 +242,7 @@ function propagate( model ) {
   // * `enum`: an enum cannot be used with `expand`
   // * `keys`: should also not be propagated with `expand`
   function expensive( prop, target, source ) {
-    // console.log(prop,source.name,'->',target.kind,target.name);
+    // console.log('EXP:',prop,ref(source),'->',ref(target));
     if (source.kind === 'builtin')
       return;
     if (target.expand)          // do not propagate `keys` with expand
@@ -245,8 +260,12 @@ function propagate( model ) {
                 target._outer && target._outer.location;
     const dict = source[prop];
     target[prop] = Object.create( null ); // also propagate empty elements
+    const propagateKey = target.kind === 'aspect'; // anonymous aspect
     for (const name in dict) {
-      const member = linkToOrigin( dict[name], name, target, prop, location );
+      const origin = dict[name];
+      const member = linkToOrigin( origin, name, target, prop, location );
+      if (propagateKey && origin.key)
+        member.key = Object.assign( { $inferred: 'expanded' }, origin.key );
       member.$inferred = 'proxy';
       if (prop === 'foreignKeys')
         setLink( member, '_effectiveType', member );
@@ -262,6 +281,24 @@ function propagate( model ) {
       always( prop, target, source );
   }
 
+  function targetAspect( prop, target, source ) {
+    if (target.targetAspect)
+      return;
+    const ta = source.targetAspect;
+    if (!ta.elements && !ta._origin) { // _origin set for elements in source
+      notWithExpand( prop, target, source );
+    }
+    else {
+      const tat = { location: ta.location, $inferred: 'prop', kind: 'aspect' };
+      setLink( tat, '_origin', ta );
+      setLink( tat, '_outer', target );
+      setLink( tat, '_parent', target._parent );
+      setLink( tat, '_main', null );
+      target.targetAspect = tat;
+      // console.log('TAC:',ref(tat),'via',ref(ta))
+    }
+  }
+
   function notWithExpand( prop, target, source ) {
     if (!target.expand || prop === 'type' && source.elements)
       always( prop, target, source );

package/lib/compiler/resolve.js

@@ -44,6 +44,7 @@ const {
   forEachGeneric,
   forEachInOrder,
   isDeprecatedEnabled,
+  isBetaEnabled,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { dictLocation, weakLocation } = require('../base/location');
@@ -132,7 +133,9 @@ function resolve( model ) {
       if (location) {
         model.$assert = null;
         const msg = semanticLoc && 'target';
-        error( 'ref-cyclic', [ location, semanticLoc || user ], { art, '#': msg }, {
+        error( 'ref-cyclic', [ location, semanticLoc || user ], {
+          art, '#': msg,
+        }, {
           std: 'Illegal circular reference to $(ART)',
           element: 'Illegal circular reference to element $(MEMBER) of $(ART)',
           target: 'Illegal circular reference to target $(ART)',
@@ -516,8 +519,8 @@ function resolve( model ) {
     if (art.value) {
       if (art.$syntax === 'calc')
         checkCalculatedElement( art );
-      else if (art.type && !art.$inferred )
-        checkStructureCast( art );
+      else if (art.type && !art.$inferred)
+        checkColumnTypeCast( art );
     }
 
     resolveExprInAnnotations( art );
@@ -554,10 +557,12 @@ function resolve( model ) {
 
       // Check explicit types: If either side has one, so must the other.
       const sType = specifiedElement.type?._artifact;
-      const iType = getInferredPropFromOrigin( 'type' )?._artifact || inferredElement;
+      const iTypeArt = getInferredPropFromOrigin( 'type' )?._artifact;
+      const iType = iTypeArt || inferredElement;
 
       // xor: could be missing a type;
       // FIXME: The coding above returns incorrect iType for expand on associations
+
       if (!specifiedElement.type && inferredElement.type) {
         error( 'query-mismatched-element', [ specifiedElement.location, user ], {
           '#': !specifiedElement.type ? 'missing' : 'extra', name: user.name.id, prop: 'type',
@@ -565,8 +570,12 @@ function resolve( model ) {
         return;
       }
       // If specified type is `null`, type could not be resolved.
-      else if (sType && sType !== iType) {
-        const typeName = iType?.name && sType?.name ? 'typeName' : 'type';
+      else if (sType && sType !== iType &&
+        // Special case for $recompilation: allow one level of type indirection. See #12113.
+        (!model.options.$recompile || sType !== iType.type?._artifact)) {
+        const typeName = !iTypeArt && 'typeExtra' ||  // no inferred type prop
+          iType?.name && sType?.name && 'typeName' || // both types are named
+          'type';                                     // unknown type names
         const othertype = typeName !== 'type' && iType || '';
         error( 'query-mismatched-element', [
           specifiedElement.type.location || specifiedElement.location, user,
@@ -638,8 +647,11 @@ function resolve( model ) {
 
         // If cardinality is not specified, the compiler uses the inferred one.
         if (specifiedElement.cardinality) {
+          // Users can change the origin's cardinality via filter: We can't rely on the origin.
+          const ref = inferredElement.value?.path;
+          const assocFilterCardinality = ref?.[ref.length - 1]?.cardinality;
           const sCardinality = specifiedElement.cardinality;
-          const iCardinality = getInferredPropFromOrigin( 'cardinality' );
+          const iCardinality = assocFilterCardinality || getInferredCardinality();
           if (!iCardinality) {
             error( 'query-mismatched-element', [
               sCardinality.location || specifiedElement.location, user,
@@ -747,6 +759,20 @@ function resolve( model ) {
         }
         return element[prop];
       }
+
+      function getInferredCardinality() {
+        let element = inferredElement;
+        if (element._effectiveType !== 0) {
+          while (getOrigin( element )) {
+            const ref = element.value?.path;
+            if (element.cardinality || ref?.[ref.length - 1]?.cardinality)
+              break;
+            element = getOrigin( element );
+          }
+        }
+        const ref = element.value?.path;
+        return element.cardinality || ref?.[ref.length - 1]?.cardinality;
+      }
     }
 
 
@@ -795,24 +821,20 @@ function resolve( model ) {
     else if (!allowedInKind.includes( parent.kind )) {
       error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
     }
-    else if (effectiveType( art )?.elements) {
+    else if (effectiveType( art )?.elements && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
-      if (!art.$inferred) {
-        if (art.type)
-          error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
-        else
-          error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
-      }
+      if (art.type)
+        error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
+      else
+        error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
     }
-    else if (effectiveType( art )?.items) {
+    else if (effectiveType( art )?.items && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
-      if (!art.$inferred) {
-        const isCast = art.type?.$inferred === 'cast';
-        error( 'type-unexpected-many', [ (art.type || art.value).location, art ], {
-          '#': (!art.type && 'calc-implicit') || (isCast && 'calc-cast') || 'calc',
-          elemref: art.type ? undefined : { ref: art.value.path },
-        } );
-      }
+      const isCast = art.type?.$inferred === 'cast';
+      error( 'type-unexpected-many', [ (art.type || art.value).location, art ], {
+        '#': (!art.type && 'calc-implicit') || (isCast && 'calc-cast') || 'calc',
+        elemref: art.type ? undefined : { ref: art.value.path },
+      } );
     }
     else {
       const noTruthyAllowed = [ 'localized', 'key', 'virtual' ];
@@ -827,7 +849,7 @@ function resolve( model ) {
     }
   }
 
-  function checkStructureCast( art ) {
+  function checkColumnTypeCast( art ) {
     const elem = (art.value.op?.val === 'cast')
       ? art.value.args[0]?._artifact
       : art.value._artifact;
@@ -836,6 +858,9 @@ function resolve( model ) {
         error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'to-structure' } );
       else if (elem.elements) // TODO: calc elements
         error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-structure' } );
+      else if (elem.target && !art.type._artifact?.target)
+        // allow cast to association -> that is already checked and denied elsewhere
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-assoc' } );
     }
   }
 
@@ -1353,18 +1378,50 @@ function resolve( model ) {
     }
   }
 
-  function resolveAnnoExpr( expr, art ) {
-    if (expr.$tokenTexts)
-      resolveExpr( expr, 'annotation', art );
-    else if (expr.literal === 'array')
-      expr.val.forEach( val => resolveAnnoExpr( val, art ) );
-    else if (expr.literal === 'struct')
-      Object.values( expr.struct ).forEach( val => resolveAnnoExpr( val, art ) );
+  function resolveAnnoExpr( expr, art, anno = expr ) {
+    if (expr.$tokenTexts) {
+      if (!anno.kind)
+        initAnnotationForExpression( anno, art );
+      resolveExpr( expr, 'annotation', anno );
+      reportUnsupportedAnnoExpr( expr );
+    }
+    else if (expr.literal === 'array') {
+      expr.val.forEach( val => resolveAnnoExpr( val, art, anno ) );
+    }
+    else if (expr.literal === 'struct') {
+      Object.values( expr.struct ).forEach( val => resolveAnnoExpr( val, art, anno ) );
+    }
+  }
+
+  function reportUnsupportedAnnoExpr( expr ) {
+    if (isBetaEnabled( model.options, 'annotationExpressions' ))
+      return;
+    const alreadyReported = model.$messageFunctions.messages
+      .find(msg => msg.messageId === 'anno-experimental-expressions');
+    if (!alreadyReported) {
+      info( 'anno-experimental-expressions', [ expr.location ], {
+        option: 'annotationExpressions',
+        // eslint-disable-next-line max-len
+      }, 'Expressions in annotation values are a beta feature. Use at your own risk. (This message can be suppressed with beta flag $(OPTION))' );
+    }
+  }
+
+  // for faster processing, mark artifacts and annotations which contain anno expressions
+  function initAnnotationForExpression( anno, art ) {
+    anno.kind = '$annotation';
+    setLink( anno, '_outer', art );
+    while (!art.$contains?.$annotation) {
+      art.$contains ??= {};
+      art.$contains.$annotation = true; // TODO: extra values for elem and $self refs
+      if (!art._main)
+        break;
+      art = art._parent;        // TODO: really go up?
+    }
   }
 
   function resolveExpr( expr, exprCtx, user ) {
     // console.log(expr?.location.line,exprCtx)
-    traverseExpr( expr, exprCtx, user, (e, c, u) => resolveExprItem( e, c, u ) );
+    traverseExpr( expr, exprCtx, user, resolveExprItem );
   }
 
   function resolveExprItem( expr, expected, user ) {
@@ -1374,8 +1431,10 @@ function resolve( model ) {
     if (expr.path) {
       // TODO: re-think this $expected: 'exists' thing
       if (expr.$expected === 'exists') {
-        error( 'expr-unexpected-exists', [ expr.location, user ], {},
-               'An EXISTS predicate is not expected here' );
+        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
@@ -1414,8 +1473,8 @@ function resolve( model ) {
     if (step.args)
       resolveParams( step.args, art, entity, expected, user, step.location );
 
-    // Publishing an association with filters is ok in column
-    const publishAssoc = art.kind === 'entity' && expected === 'column';
+    // Publishing an association with filters is ok in columns and also ok in calculated elements.
+    const publishAssoc = art.kind === 'entity' && (expected === 'column' || expected === 'calc');
 
     if (entity || publishAssoc) {
       if (step.where) {

package/lib/compiler/shared.js

@@ -105,7 +105,7 @@ function fns( model ) {
       dynamic: modelBuiltinsOrDefinitions,
       navigation: environment,
       notFound: undefinedDefinition,
-      accept: acceptEntityOrAssoc,
+      accept: acceptQuerySource,
       noDep: '',                // dependency special for from
     },
     type: {
@@ -286,7 +286,6 @@ function fns( model ) {
         'ref-undefined-element': 'anno-undefined-element',
         'ref-undefined-param': 'anno-undefined-param',
       },
-      // check: checkAssocOn,
       param: paramSemantics,
       nestedColumn: () => ({       // in expand and inline - TODO
         lexical: justDollarSelf,
@@ -297,6 +296,17 @@ function fns( model ) {
         rewriteProjectionToSelf: true,
       }),
     },
+    // TODO: introduce some kind of inheritance
+    annoRewrite: { // annotation assignments
+      lexical: justDollarSelf,  // TODO: forbid $projection
+      dollar: true,
+      dynamic: parentElements,
+      navigation: assocOnNavigation,
+      noDep: true,
+      notFound: null,           // no error, just falsy links
+      param: paramSemantics,
+      // nestedColumn:     // in expand and inline - TODO
+    },
   };
 
   Object.assign( model.$functions, {
@@ -314,25 +324,23 @@ function fns( model ) {
   // Expression traversal function ----------------------------------------------
   function traverseExpr( expr, exprCtx, user, callback ) {
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
-      return;
+      return null;
 
     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 );
+      return callback( expr, exprCtx, user );
     }
+    let first = (expr.type || expr.query) && callback( expr, exprCtx, user );
 
-    if (expr.args) {
+    if (expr.args && !first) {
       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 ) );
+      first = args.find( e => traverseExpr( e, exprCtx, user, callback ) );
     }
-    if (expr.suffix)              // fn( … ) OVER …
-      expr.suffix.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
+
+    first ??= expr.suffix &&    // fn( … ) OVER …
+      expr.suffix.find( e => traverseExpr( e, exprCtx, user, callback ) );
+    return first;
   }
 
   // Return absolute name for unchecked path `ref`.  We first try searching for
@@ -395,7 +403,6 @@ function fns( model ) {
       return setArtifactLink( ref, root );
 
     // how many path items are for artifacts (rest: elements)
-    // console.log(expected, ref.path.map(a=>a.id),artItemsCount)
     let art = getPathItem( ref, semantics, user );
     if (!art)
       return setArtifactLink( ref, art );
@@ -413,14 +420,19 @@ function fns( model ) {
         const target = art._effectiveType?.target?._artifact;
         if (target)
           dependsOn( user._main, target, location, user );
+        if (target?.$calcDepElement)
+          dependsOn( user._main, target.$calcDepElement, location, user );
       }
       else if (art._main && art.kind !== 'select' || path[0]._navigation?.kind !== '$self') {
         // no real dependency to bare $self (or actually: the underlying query)
         dependsOn( user, art, location );
+        if (art.$calcDepElement)
+          dependsOn( user, art.$calcDepElement, 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;
+        // 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)
     }
@@ -498,7 +510,9 @@ function fns( model ) {
       return undefined;         // parse error
     if (head._artifact !== undefined)
       return head._artifact;
-    const ruser = user._user || user; // TODO: nicer name if we keep this
+    let ruser = user._user || user; // TODO: nicer name if we keep this
+    if (ruser.kind === '$annotation')
+      ruser = ruser._outer;
 
     // Handle expand/inline, `type of`, :param, global (internally for CDL):
     if (user._pathHead && !semantics.isMainRef) // in expand/inline
@@ -545,8 +559,9 @@ function fns( model ) {
     else
       valid.push( model.$magicVariables.elements, removeDollarNames( dynamicDict ) );
     // TODO: streamline function arguments (probably: user, path, semantics )
-    const undef = semantics.notFound( ruser, head, valid, dynamicDict,
-                                      !isMainRef && user._user && user._artifact, path, semantics );
+    const undef = semantics.notFound?.( user._user || user, head, valid, dynamicDict,
+                                        !isMainRef && user._user && user._artifact,
+                                        path, semantics );
     return setArtifactLink( head, undef || null );
   }
 
@@ -913,9 +928,8 @@ function fns( model ) {
     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
+      else
+        dependsOn( user.$calcDepElement, target, location || user.location, user );
     }
     const effectiveTarget = Functions.effectiveType( target );
     // if (effectiveTarget === 0 && location)
@@ -960,11 +974,11 @@ function fns( model ) {
   }
 
   function undefinedTargetElement( user, head, valid, _dict, pathItemArtifact ) {
-    // is only called if there is a target, targetElements() returns falsy otherwise
-    const { target } = pathItemArtifact?._effectiveType || user._parent;
+    // `art.target` may not set in case target entities `myEntity[unknown > 2]`
+    const art = pathItemArtifact?._effectiveType || user._parent;
     // TODO: better with $refs in filter conditions
     signalNotFound( 'ref-undefined-element', [ head.location, user ], valid,
-                    { '#': 'target', art: target, id: head.id } );
+                    { '#': 'target', art: art.target || art, id: head.id } );
   }
 
   function undefinedVariable( user, head, valid ) {
@@ -1033,14 +1047,16 @@ function fns( model ) {
     return null;
   }
 
-  function undefinedNestedElement( user, head, valid, _dict, _art, path ) {
+  function undefinedNestedElement( user, head, valid, _dict, _art, path, semantics ) {
     const art = user._pathHead._origin;
     if (!art)
       return null;              // no consequential error
-    return undefinedItemElement( user, head, valid, null, art, path );
+    return undefinedItemElement( user, head, valid, null, art, path, semantics );
   }
 
   function undefinedItemElement( user, item, valid, _dict, art, path, semantics ) {
+    if (semantics.notFound === null)
+      return;
     const query = userQuery( art );
     if (query?.name?.id > 1) {
       const root = userQuery( user ) !== query && path[0]._navigation;
@@ -1084,7 +1100,6 @@ function fns( model ) {
                         { '#': variant, art: a, id: item.id }, semantics );
       }
     }
-    return null;
   }
 
   // Functions called via semantics.accept: -------------------------------------
@@ -1264,15 +1279,17 @@ function fns( model ) {
     return false;
   }
 
-  function acceptEntityOrAssoc( art, user, ref ) { // for FROM
+  function acceptQuerySource( 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
+    // at least the last main definition should be an entity or an
+    // event (if the user is also an event)
     // 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 );
+    const variant = (user._main.kind === 'event') ? 'event' : 'std';
+    if (source.kind !== 'entity' && !acceptEventProjectionSource( source, user )) {
+      signalNotFound( 'ref-invalid-source', [ ref.location, user ], null, { '#': variant } );
       return false;
     }
     if (source === art)
@@ -1280,10 +1297,20 @@ function fns( model ) {
     const assoc = Functions.effectiveType( art );
     if (assoc.target)
       return art;               // TODO: use target here
-    signalNotFound( 'ref-invalid-source', [ ref.location, user ], null );
+    signalNotFound( 'ref-invalid-source', [ ref.location, user ], null, { '#': variant } );
     return false;
   }
 
+  function acceptEventProjectionSource( source, user ) {
+    if (user._main.kind !== 'event' || (source.kind !== 'event' && source.kind !== 'type'))
+      return false;
+    const effectiveType = Functions.effectiveType( source );
+    if (!effectiveType)
+      return false;
+    const { kind } = effectiveType;
+    return (kind === 'entity' || kind === 'event' || (kind === 'type' && effectiveType.elements));
+  }
+
   function acceptTypeOrElement( art, user, ref ) { // for type
     // was ['action', 'function'].includes( user._parent?.kind ))
     while (user._outer)