@sap/cds-compiler 3.1.2 → 3.3.2

package/lib/compiler/populate.js

@@ -19,7 +19,6 @@
 
 const {
   isDeprecatedEnabled,
-  isBetaEnabled,
   forEachDefinition,
   forEachMember,
   forEachGeneric,
@@ -59,7 +58,6 @@ function populate( model ) {
     resolvePath,
     attachAndEmitValidNames,
     initArtifact,
-    projectionAncestor,
   } = model.$functions;
   model.$volatileFunctions.environment = environment;
   Object.assign( model.$functions, {
@@ -103,8 +101,8 @@ function populate( model ) {
   function traverseElementEnvironments( art ) {
     populateView( art );
     environment( art );
-    if (art.elements$)
-      mergeSpecifiedElements(art);
+    if (art.elements$ || art.enum$)
+      mergeSpecifiedElementsOrEnum(art);
     forEachMember( art, traverseElementEnvironments );
   }
 
@@ -188,9 +186,6 @@ function populate( model ) {
         setLink( a, '_effectiveType', art );
     }
     else {
-      let eType = art;
-      if (eType._outer)
-        eType = effectiveType( eType._outer );
       // collect the "latest" cardinality (calculate lazily if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
@@ -200,8 +195,8 @@ function populate( model ) {
           cardinality = a.cardinality;
         if (a.expand && expandFromColumns( a, art, cardinality ) ||
             art.target && redirectImplicitly( a, art ) ||
-            art.elements && expandElements( a, art, eType ) ||
-            art.items && expandItems( a, art, eType ))
+            art.elements && expandElements( a, art ) ||
+            art.items && expandItems( a, art ))
           art = a;
         else if (art.enum && expandEnum( a, prev ))
           prev = a;             // do not set art - effective type is base
@@ -292,31 +287,32 @@ function populate( model ) {
   // Expansiosn --------------------------------------------------------------
 
 
-  function expandItems( art, origin, eType ) {
+  function expandItems( art, origin ) {
     if (art.items)
       return false;
-    if (isInParents( art, eType )) {
+    if (origin.items === 0 || art.$inferred === 'expanded' && isInRecursiveExpansion( art )) {
       art.items = 0;            // circular
       return true;
     }
     const ref = art.type || art.value || art.name;
     const location = ref && ref.location || art.location;
-    art.items = { $inferred: 'expand-element', location };
+    art.items = { $inferred: 'expanded', location };
     setLink( art.items, '_outer', art );
+    setLink( art.items, '_parent', art._parent );
     setLink( art.items, '_origin', origin.items );
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
     return true;
   }
 
-  function expandElements( art, struct, eType ) {
-    if (art.elements || art.kind === '$tableAlias' ||
+  function expandElements( art, struct ) {
+    if (art.elements || art.kind === '$tableAlias' || art.kind === '$inline' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
         struct.kind !== 'type' && struct.kind !== 'element' && struct.kind !== 'param' &&
         !struct._outer)
       return false;
-    if (struct.elements === 0 || isInParents( art, eType )) {
+    if (struct.elements === 0 || art.$inferred === 'expanded' && isInRecursiveExpansion( art )) {
       art.elements = 0;         // circular
       return true;
     }
@@ -331,14 +327,14 @@ function populate( model ) {
         continue;
       linkToOrigin( orig, name, art, 'elements', weakLocation( location ), true )
         // or should we use orig.location? - TODO: try to find test to see message
-        .$inferred = 'expand-element';
+        .$inferred = 'expanded';
     }
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    // TODO: have some art.elements[SYM.$inferred] = 'expand-element';
+    // TODO: have some art.elements[SYM.$inferred] = 'expanded';
     return true;
   }
 
@@ -352,39 +348,56 @@ function populate( model ) {
       const orig = origin.enum[name];
       linkToOrigin( orig, name, art, 'enum', location, true )
         // or should we use orig.location? - TODO: try to find test to see message
-        .$inferred = 'expand-element';
+        .$inferred = 'expanded';
     }
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    art.enum[$inferred] = 'expand-element';
+    art.enum[$inferred] = 'expanded';
     return true;
   }
 
   /**
-   * Return true iff `struct` is `art` or a direct or indirect parent of `art`,
-   * we also check for the outer objects of `items`.  (There is no need to
-   * check the parents of main artifacts, as these are contexts, services or
-   * namespaces, and do not serve as type.)
+   * Return true iff `art` is from a recursive expansion, i.e.  if any of its
+   * expanded parents (including _outer) has the same non-expansion-origin.
    */
-  function isInParents( art, struct ) {
-    if (art === struct)
+  function isInRecursiveExpansion( art ) {
+    const current = nonExpandedArtifact( art );
+    if (current.$inCycle)
       return true;
-    while (art._outer) {        // for items
-      art = art._outer;
-      if (art === struct)
-        return true;
-    }
-    while (art._main) {
-      art = art._parent;
-      if (art === struct)
+    const cycle = [ current ];
+    while (art.$inferred === 'expanded') {
+      art = outerOrParent( art );
+      const origin = nonExpandedArtifact( art );
+      cycle.push( origin );
+      if (origin.$inCycle || origin === current) {
+        for (const a of cycle)
+          a.$inCycle = true;
         return true;
+      }
     }
     return false;
   }
 
+  function outerOrParent( art ) {
+    if (art._outer)
+      return art._outer;
+    art = art._parent;
+    // TODO: think about setting _parent of elements in `items` object holding
+    // `elements`, not the most outer `items` -> return art._outer || art._parent
+    while (art.items)
+      art = art.items;
+    return art;
+  }
+
+  function nonExpandedArtifact( art ) {
+    while (art.$inferred === 'expanded')
+      art = art._origin;
+    return art;
+  }
+
   //--------------------------------------------------------------------------
   // Views
   //--------------------------------------------------------------------------
@@ -442,12 +455,12 @@ function populate( model ) {
    *
    * @param art
    */
-  function mergeSpecifiedElements( art ) {
+  function mergeSpecifiedElementsOrEnum( art ) {
     // Later we use specified elements as proxies to inferred of leading query
     // (No, we probably do not.)
-    for (const id in art.elements) {
-      const ielem = art.elements[id];  // inferred element
-      const selem = art.elements$[id]; // specified element
+    for (const id in (art.elements || art.enum)) {
+      const ielem = art.elements ? art.elements[id] : art.enum[id];  // inferred element
+      const selem = art.elements$ ? art.elements$[id] : art.enum$[id]; // specified element
       if (!selem) {
         info( 'query-missing-element', [ ielem.name.location, art ], { id },
               'Element $(ID) is missing in specified elements' );
@@ -463,8 +476,14 @@ function populate( model ) {
           setLink(ielem, 'elements$', selem.elements);
           delete selem.elements;
         }
+        if (selem.enum) {
+          setLink(ielem, 'enum$', selem.enum);
+          delete selem.enum;
+        }
       }
     }
+    // TODO: We don't check enum$, yet! We first need to fix expansion for
+    //       `cast(elem as EnumType)` (see #9421)
     for (const id in art.elements$) {
       const selem = art.elements$[id]; // specified element
       if (!selem.$replacement) {
@@ -569,10 +588,6 @@ function populate( model ) {
         const siblings = wildcardSiblings( columns, query );
         expandWildcard( col, siblings, inlineHead, query );
       }
-      if ((col.expand || col.inline) && !isBetaEnabled( options, 'nestedProjections' )) {
-        error( null, [ col.location, query ], { prop: (col.expand ? 'expand' : 'inline') },
-               'Unsupported nested $(PROP)' );
-      }
       // If neither expression (value), expand nor new association.
       if (!col.value && !col.expand && !(col.target && col.type))
         continue;             // error should have been reported by parser
@@ -645,18 +660,28 @@ function populate( model ) {
     // console.log( message( null, elem.location, elem, {art:query}, 'Info','RED').toString(),
     //              elem.value)
     // TODO: make this resolvePath() also part of directType() ?!
-    if (!origin)
+    if (!origin || elem.expand)
       return;
+    // TODO: or should we push elems with `expand` sibling to extra list for better messages?
     if (elem.foreignKeys) {   // REDIRECTED with explicit foreign keys
       forEachGeneric( elem, 'foreignKeys', (key, name) => initKey( key, name, elem ) );
     }
 
     // now set things which are necessary for later sub phases:
     const nav = pathNavigation( elem.value );
-    if (nav.navigation && nav.item === elem.value.path[elem.value.path.length - 1]) {
+    const item = elem.value.path[elem.value.path.length - 1];
+    if (nav.navigation && nav.item === item) {
+      // sourceElem, alias.sourceElem, mixin:
       // redirectImplicitly( elem, origin );
       pushLink( nav.navigation, '_projections', elem );
     }
+    else if (elem._pathHead?.kind === '$inline' && elem.value.path.length === 1) {
+      const hpath = elem._pathHead.value?.path;
+      const head = hpath?.length === 1 && hpath[0]._navigation;
+      // Alias .{ elem }
+      if (head?.kind === '$tableAlias')
+        pushLink( head.elements[item.id], '_projections', elem );
+    }
   }
 
   function initKey( key, name, elem ) {
@@ -701,7 +726,7 @@ function populate( model ) {
     //             Object.keys(env),Object.keys(elements))
     for (const name in env) {
       const navElem = env[name];
-      // TODO: if it is an array, filter out those with masked
+      // TODO: remove all access to masked (use 'grep')
       if (excludingDict[name] || navElem.masked && navElem.masked.val)
         continue;
       const sibling = siblingElements[name];
@@ -770,13 +795,17 @@ function populate( model ) {
         path && path[path.length - 1].id !== sibling.name.id) { // or renamed
       const { id } = sibling.name;
       if (Array.isArray(navElem)) {
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'wildcard-excluding-many', [ sibling.name.location, query ], { id },
-              'This select item replaces $(ID) from two or more sources' );
+          // eslint-disable-next-line max-len
+              'This select item replaces $(ID) from two or more sources. Add $(ID) to $(KEYWORD) to silence this message' );
       }
       else {
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'wildcard-excluding-one', [ sibling.name.location, query ],
-              { id, alias: navElem._parent.name.id },
-              'This select item replaces $(ID) from table alias $(ALIAS)' );
+              { id, alias: navElem._parent.name.id, keyword: 'excluding' },
+          // eslint-disable-next-line max-len
+              'This select item replaces $(ID) from table alias $(ALIAS). Add $(ID) to $(KEYWORD) to silence this message' );
       }
     }
   }
@@ -787,9 +816,13 @@ function populate( model ) {
     queryElem.value = { path, location }; // TODO: can we omit that?  We have _origin
     setArtifactLink( path[0], origin );
     setLink( queryElem, '_origin', origin );
-    // TODO: set _projections when top-level?
+    // set _projections when inline with table alias:
+    const alias = pathHead?.value?.path?.[0]?._navigation;
+    if (alias?.kind === '$tableAlias')
+      pushLink( alias.elements[name], '_projections', queryElem );
   }
 
+  // called by expandWildcard():
   function setElementOrigin( queryElem, navElem, name, location ) {
     const sourceElem = navElem._origin;
     const alias = navElem._parent;
@@ -892,7 +925,7 @@ function populate( model ) {
           preferredElemScope( target, service, elem, assoc._main || assoc );
     const exposed = minimalExposure( target, service, elemScope );
 
-    if (!exposed.length && elemScope !== true) {
+    if (!exposed.length) {
       const origTarget = target;
       if (isAutoExposed( target ))
         target = createAutoExposed( origTarget, service, elemScope );
@@ -930,7 +963,7 @@ function populate( model ) {
       for (const proj of exposed) {
         // TODO: def-ambiguous-target (just v3, as the current is infamous and used in options),
         message( 'redirected-implicitly-ambiguous',
-                 [ weakLocation( proj.location ), proj ],
+                 [ weakLocation( proj.name.location ), proj ],
                  {
                    '#': withAnno && 'justOne',
                    target,
@@ -1021,17 +1054,6 @@ function populate( model ) {
   function scopedExposure( descendants, elemScope, target ) {
     if (!elemScope)             // no scoped redirections
       return descendants;
-    if (elemScope === true || elemScope === 'auto') {
-      // cross-scope navigation, scoped model target, but there is no unique
-      // redirection target for target model scope -> unsure redirection scope
-      const unscoped = descendants.filter( d => d === definitionScope( d ) );
-      if (unscoped.length)      // use unscoped new targets if present
-        return unscoped;
-      // Need to filter out auto-exposed, otherwise the behavior is
-      // processing-order dependent (not storing the autoexposed in
-      // _descendents would only be an alternative w/o recompilation)
-      return descendants.filter( d => !d.$generated && !annotationVal( d['@cds.autoexposed'] ) );
-    }
     // try scope as target first, even if it has @cds.redirection.target: false
     if (isDirectProjection( elemScope, target ))
       return [ elemScope ];
@@ -1059,7 +1081,6 @@ function populate( model ) {
 
   function isDirectProjection( proj, base ) {
     return proj.kind === 'entity' && // not event
-      projectionAncestor( base, proj.params ) && // same params
       // direct proj (TODO: or should we add them to another list?)
       proj.query && proj.query.op && proj.query.op.val === 'SELECT' &&
       proj._from && proj._from.length === 1 &&

package/lib/compiler/propagator.js

@@ -233,7 +233,7 @@ function propagate( model ) {
   }
 
   function onlyViaParent( prop, target, source ) {
-    if (target.$inferred === 'proxy' || target.$inferred === 'expand-element')
+    if (target.$inferred === 'proxy' || target.$inferred === 'expanded')
       // assocs and enums do not have 'include'
       always( prop, target, source );
   }

package/lib/compiler/resolve.js

@@ -69,7 +69,6 @@ const {
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
-const layers = require('./moduleLayers');
 
 const $location = Symbol.for('cds.$location');
 
@@ -91,11 +90,14 @@ function resolve( model ) {
     defineAnnotations,
     attachAndEmitValidNames,
     lateExtensions,
+    applyTypeExtensions,
     effectiveType,
     directType,
     resolveType,
     resolveTypeArgumentsUnchecked,
     populateQuery,
+    layeredAssignments,
+    assignmentsOfHighestLayers,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
   Object.assign( model.$functions, {
@@ -168,15 +170,7 @@ function resolve( model ) {
     for (const name in query.elements) {
       const elem = query.elements[name];
       // no key prop for duplicate elements or additional specified elements:
-      if (elem.$duplicates || !elem.value)
-        continue;
-      const nav = pathNavigation( elem.value );
-      if (!nav.navigation)
-        continue;            // undefined, expr, $magic, :const, $self (!), $self.elem
-      const { item } = nav;
-      if (item !== elem.value.path[elem.value.path.length - 1])
-        continue;         // having selected a sub elem / navigated along assoc
-      const { key } = item._artifact;
+      const key = !elem.$duplicates && !elem.expand && inheritedSourceKeyProp( elem );
       if (key) {
         if (!doIt)
           return true;
@@ -186,6 +180,20 @@ function resolve( model ) {
     return false;
   }
 
+  function inheritedSourceKeyProp( { value, _pathHead } ) {
+    if (!value || !value.path)
+      return null;
+    const nav = pathNavigation( value );
+    const item = value.path[value.path.length - 1];
+    if (nav.navigation && nav.item === item)
+      return item._artifact?.key;
+    if (value.path.length !== 1 || _pathHead?.kind !== '$inline')
+      return null;
+    const hpath = _pathHead.value?.path;
+    const head = hpath?.length === 1 && hpath[0]._navigation;
+    return head?.kind === '$tableAlias' && item._artifact?.key;
+  }
+
   function primarySourceNavigation( aliases ) {
     for (const name in aliases)
       return aliases[name].elements;
@@ -240,6 +248,7 @@ function resolve( model ) {
     function selectTest( expr ) {
       const art = withAssociation( expr, targetMaxNotOne );
       if (art) {
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'query-navigate-many', [ art.location, query ], { art },
               {
                 // eslint-disable-next-line max-len
@@ -314,9 +323,10 @@ function resolve( model ) {
       // TODO: shouldn't be this part of populate.js ?
       const items = {
         location: weakLocation( (obj.type || obj).location ),
-        $inferred: 'expand-items',
+        $inferred: 'expanded',
       };
       setLink( items, '_outer', obj );
+      setLink( items, '_parent', obj._parent );
       setLink( items, '_origin', type.items );
       obj.items = items;
       obj.$expand = 'origin';
@@ -511,7 +521,7 @@ function resolve( model ) {
       setArtifactLink( ext.name, art );
 
       if (art) {
-        if (art.kind === 'annotate')
+        if (ext.kind === 'annotate' || ext.kind === 'extend')
           checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // eslint-disable-next-line no-shadow
@@ -555,7 +565,7 @@ function resolve( model ) {
         }
       }
     }
-    if (art && art._annotate) {
+    if (art?._annotate) {
       if (art.kind === 'action' || art.kind === 'function') {
         expandParameters( art );
         if (art.returns)
@@ -579,6 +589,15 @@ function resolve( model ) {
       //     annotateMembers( env && env[n], dict[n], 'elements', n, parent, 'element' );
       // }
     }
+
+    if (art?._extendType) {
+      // Only works because annotateMembers is called in resolveRefs() _after_ `.type` was resolved.
+      // TODO: If we allow extending included elements, we may need custom $expand,
+      //       similar to annotate above.
+      art._extendType.forEach(resolveRefs);
+      applyTypeExtensions(art);
+    }
+
     return;
 
     function notFound( msgId, location, address, args, validDict ) {
@@ -632,7 +651,7 @@ function resolve( model ) {
           // not to create proxies
           const orig = origin.params[name];
           linkToOrigin( orig, name, art, 'params', weakLocation( orig.location ), true )
-            .$inferred = 'expand-param';
+            .$inferred = 'expanded';
         }
       }
       if (!art.returns && origin.returns) {
@@ -642,7 +661,7 @@ function resolve( model ) {
           name: Object.assign( {}, art.name, { id: '', param: '', location } ),
           kind: 'param',
           location,
-          $inferred: 'expand-param',
+          $inferred: 'expanded',
         };
         setLink( art.returns, '_parent', art );
         setLink( art.returns, '_main', art._main || art );
@@ -751,90 +770,21 @@ function resolve( model ) {
       : Object.assign( {}, scheduledAssignments[scheduledAssignments.length - 1], result );
   }
 
-  // Group assignments by their layers.  An assignment provided with a definition
-  // is considered to be provided in a layer named '', the lowest layer.
-  // TODO: make this usable for extend (elements), too =
-  // do not use $priority, make assignments on define do not have own _block
-  function layeredAssignments( assignment ) {
-    const layered = Object.create(null);
-    for (const a of assignment) {
-      const layer = a.$priority && layers.layer( a );
-      // just consider layer if Extend/Annotate, not Define
-      const name = (layer) ? layer.realname : '';
-      const done = layered[name];
-      if (done)
-        done.assignments.push( a );
-      else
-        layered[name] = { name, layer, assignments: [ a ] };
-      // TODO: file - if set: unique in layer
-    }
-    return layered;
-  }
-
-  // Return assignments of the highest layers.
-  // Also return whether there could be an issue:
-  // - false: there is just one assignment
-  // - 'unrelated': there is just one assignment per layer
-  // - true: there is at least one layer with two or more assignments
-  // TODO: make this usable for extend (elements), too
-  function assignmentsOfHighestLayers( layeredAnnos ) {
-    const layerNames = Object.keys( layeredAnnos );
-    // console.log('HIB:',layerNames)
-    if (layerNames.length <= 1) {
-      const name = layerNames[0];
-      const { assignments } = layeredAnnos[name] || { assignments: [] };
-      delete layeredAnnos[name];
-      return { assignments, issue: assignments.length > 1 };
-    }
-
-    // collect all layers which are lower than another layer
-    const allExtends = Object.create(null);
-    allExtends[''] = {};        // the "Define" layer
-    for (const name of layerNames) {
-      if (name)                 // not the "Define" layer
-        Object.assign( allExtends, layeredAnnos[name].layer._layerExtends );
-    }
-    // console.log('HIE:',Object.keys(allExtends))
-    const assignments = [];
-    const highest = [];
-    for (const name of layerNames) {
-      if (!(name in allExtends)) {
-        const layer = layeredAnnos[name];
-        delete layeredAnnos[name];
-        highest.push( layer );
-        assignments.push( ...layer.assignments );
-      }
-    }
-    assignments.sort( compareAssignments );
-    const good = highest.every( layer => layer.assignments.length === 1 );
-    // TODO: use layer.file instead
-    const issue = !good || highest.length > 1 && 'unrelated';
-    // console.log('HI:',highest.map(l=>l.name),issue,issue&&assignments)
-    return { assignments, issue };
-  }
-
-  function compareAssignments( a, b ) {
-    const fileA = layers.realname( a._block );
-    const fileB = layers.realname( b._block );
-    if (fileA !== fileB)
-      return (fileA > fileB) ? 1 : -1;
-    return (a?.location?.line || 0) - (b?.location?.line || 0) ||
-           (a?.location?.col || 0) - (b?.location?.col || 0);
-  }
-
   function applyAssignment( previousAnno, anno, art, annoName ) {
+    const hasBase = previousAnno?.literal === 'array';
     if (!previousAnno) {
-      if (!annotationHasEllipsis( anno ))
+      const firstEllipsis = annotationHasEllipsis( anno );
+      if (!firstEllipsis)
         return anno;
       if (anno.$priority) {   // already complained about with Define
-        message( 'anno-unexpected-ellipsis-layers', // TODO: better location
-                 [ anno.name.location, art ], { code: '...' } );
+        const loc = firstEllipsis.location || anno.name.location;
+        message( 'anno-unexpected-ellipsis-layers', [ loc, art ], { code: '...' } );
       }
       previousAnno = { val: [] };
     }
     else if (previousAnno.literal !== 'array') {
-      error( 'anno-mismatched-ellipsis', // TODO: better location
-             [ anno.name.location, art ], { code: '...' } );
+      // TODO: If we introduce sub-messages, point to the non-array base value.
+      error( 'anno-mismatched-ellipsis', [ anno.name.location, art ], { code: '...' } );
       previousAnno = { val: [] };
     }
     const previousValue = previousAnno.val;
@@ -855,7 +805,8 @@ function resolve( model ) {
             break;
           }
         }
-        if (upToSpec) {       // non-matched UP TO
+        if (upToSpec && hasBase) {
+          // non-matched UP TO; if there is no base to apply to, there is already an error.
           warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
                    'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
         }
@@ -1045,7 +996,7 @@ function resolve( model ) {
     else if (obj.type && !obj.type.$inferred && art._parent && art._parent.kind === 'select') {
       // New association in views, i.e. parent is a query.
       error( 'query-expected-on-condition', [ obj.target.location, art ], {},
-             'Expected on-condition for published association' );
+             'Expected ON-condition for published association' );
       return; // avoid subsequent errors
     }
     else if (target && !obj.foreignKeys && target.kind === 'entity') {
@@ -1135,7 +1086,7 @@ function resolve( model ) {
       if (!elem.on && origType.on) {
         error( 'rewrite-not-supported', [ elem.target.location, elem ], {},
                // TODO: Better text ?
-               'The ON condition is not rewritten here - provide an explicit ON condition' );
+               'The ON-condition is not rewritten here - provide an explicit ON-condition' );
         return;
       }
     }
@@ -1148,6 +1099,7 @@ function resolve( model ) {
       if (!elem.target.$inferred && !elem.on && !elem.foreignKeys) {
         // Only a managed redirection gets this info message.  Because otherwise
         // we'd have to check whether on-condition/foreignKeys are the same.
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'redirected-to-same', [ elem.target.location, elem ], { art: target },
               'The redirected target is the original $(ART)' );
       }
@@ -1162,12 +1114,17 @@ function resolve( model ) {
       if (!from)
         return;                 // parse error - TODO: or UNION?
       if (!from.path) {
-        warning( 'redirected-to-complex', [ elem.target.location, elem ],
-                 { art: target, '#': target === elem.target._artifact ? 'target' : 'std' },
-                 {
-                   std: 'Redirection involves the complex view $(ART)',
-                   target: 'The redirected target $(ART) is a complex view',
-                 });
+        const isTarget = target === elem.target._artifact;
+        const op = from.op?.val || target.query.op?.val;
+        const variant = (!isTarget && 'std') || (op && 'targetOp') || 'target';
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
+        info( 'redirected-to-complex', [ elem.target.location, elem ],
+              { 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;
       }
       target = from._artifact;
@@ -1301,13 +1258,13 @@ function resolve( model ) {
 
           let variant;
           if (type.builtin)
-          // `.type` is already a builtin: use a nicer message.
+            // `.type` is already a builtin: use a nicer message.
             variant = 'builtin';
           else if (effectiveTypeArt.builtin)
-          // base type is a builtin, i.e. a scalar
+            // base type is a builtin, i.e. a scalar
             variant = 'type';
           else
-          // effectiveType is not a builtin -> array or structured
+            // effectiveType is not a builtin -> array or structured
             variant = 'non-scalar';
 
           error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
@@ -1432,7 +1389,7 @@ function resolve( model ) {
     }
     const exp = (expected === 'from') ? 'expr' : expected;
     if (Array.isArray(dict)) {
-      message( 'args-expected-named', [ dict[0] && dict[0].location || stepLocation, user ],
+      message( 'args-expected-named', [ dict[0] && dict[0].location || stepLocation, user ], {},
                'Named parameters must be provided for the entity' );
       for (const a of dict)
         resolveExpr( a, exp, user, extDict );