@sap/cds-compiler 6.8.0 → 6.9.1

package/lib/compiler/extend.js

@@ -11,7 +11,7 @@ const {
   setLink,
   setArtifactLink,
   copyExpr,
-  setExpandStatusAnnotate,
+  setExpandStatus,
   linkToOrigin,
   initItemsLinks,
   setMemberParent,
@@ -84,6 +84,8 @@ function extend( model ) {
   const includesNonShadowedFirst
     = isDeprecatedEnabled( model.options, '_includesNonShadowedFirst' );
 
+  const includeCollisions = [];
+
   forEachGeneric( model, 'definitions', tagCompositionTargets );
   dictForEach( model.$collectedExtensions, e => e._extensions.forEach( tagCompositionTargets ) );
   // remark: tagging on extensions works _before_ running extendArtifactBefore() on each artifact
@@ -174,7 +176,7 @@ function extend( model ) {
       // elements etc.  TODO: do that more specifically on the dicts (via symbol)
       // Probably better: we could use the _extensions dict prop directly in to-csn
       if (art.$inferred)
-        setExpandStatusAnnotate( art, 'annotate' );
+        setExpandStatus( art, 'annotate' );
       if (Array.isArray( art._extensions )) {
         checkExtensionsKind( art._extensions, art );
         transformArtifactExtensions( art );
@@ -258,7 +260,8 @@ function extend( model ) {
           checkReturnsExtension( ext, art );
       }
       // if (art.elements || art.enum || art.kind === 'annotate')
-      moveDictExtensions( art, extensionsMap, (art.enum ? 'enum' : 'elements'), 'elements' );
+      moveDictExtensions( art, extensionsMap,
+                          (art.enum ? 'enum' : 'elements'), false );
     }
   }
 
@@ -399,7 +402,9 @@ function extend( model ) {
           pushTo$add( dict, ext );
         }
         else if (prop.charAt(0) === '@' || prop === 'doc' || prop === 'columns' ||
-            prop === 'length' || prop === 'scale' || prop === 'precision' || prop === 'srid') {
+                 prop === 'groupBy' || prop === 'where' || prop === 'having' ||
+                 prop === 'orderBy' || prop === 'limit' || prop === 'length' ||
+                 prop === 'scale' || prop === 'precision' || prop === 'srid') {
           if (!isAutoItemsOrReturns)
             pushToDict( dict, prop, ext );
         }
@@ -577,7 +582,7 @@ function extend( model ) {
     else if (prop === 'columns') {
       const { query } = art;
       for (const col of ext.columns)
-        col.$extended = true;
+        col.$extended = 'columns';
 
       if (art.kind === 'annotate' && art.$inferred === '')
         return; // internal super-annotate for unknown artifacts
@@ -593,6 +598,10 @@ function extend( model ) {
         query.columns.push( ...ext.columns );
       ext.columns.forEach( col => changeParentLinks( col, query ) );
     }
+    else if (prop === 'groupBy' || prop === 'where' || prop === 'having' ||
+             prop === 'orderBy' || prop === 'limit') {
+      applyQueryClause( prop, ext, art );
+    }
     else if (typeParameters.list.includes( prop )) {
       const typeExts = art.$typeExts || (art.$typeExts = {});
       typeExts[prop] = ext;
@@ -603,6 +612,39 @@ function extend( model ) {
     }
   }
 
+  function applyQueryClause( prop, ext, art ) {
+    const { query } = art;
+    const clause = ext[prop];
+    const isArray = Array.isArray( clause );
+
+    if (prop !== 'limit') {
+      const items = isArray ? clause : [ clause ];
+      for (const item of items) {
+        item.$extended = prop;
+        setLink( item, '_block', ext._block );
+        setLink( item, '_outer', query );
+      }
+    }
+    if (!query?.from?.path) {
+      const variant = (query?.from || query)?.op?.val || 'std';
+      const loc = isArray ? clause[$location] : clause.location;
+      error( `extend-${ prop.toLowerCase() }`, [ loc, ext ], { '#': variant, art } );
+      return;
+    }
+    if (isArray) {
+      if (!query[prop])
+        query[prop] = [];
+      query[prop].push( ...clause );
+    }
+    else {
+      if (query[prop]) {
+        error( 'ext-unexpected-sql-clause', [ clause.location, ext ], { art, keyword: prop } );
+        return;
+      }
+      query[prop] = clause;
+    }
+  }
+
   function changeParentLinks( art, queryOrMain ) {
     // TODO: we might also change the implicit name (if name.id is a number,
     // adding the previous column lenght - 1) for better error messages
@@ -838,18 +880,18 @@ function extend( model ) {
   }
 
   function moveDictExtensions( art, extensionsMap, artProp, extProp = artProp ) {
-    // TODO: setExpandStatusAnnotate
-    const extensions = extensionsMap[extProp];
+    // TODO: setExpandStatus
+    const extensions = extensionsMap[extProp || 'elements'];
     if (!extensions)
       return;
 
     for (const ext of extensions) {
       let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
-      forEachGeneric( ext, extProp, ( elemExt, name ) => {
+      forEachGeneric( ext, extProp || (ext.enum ? 'enum' : 'elements'), ( elemExt, name ) => {
         if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
           return;             // definitions inside extend, already handled
         dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
-        const elem = art[artProp]?.[name] || annotateFor( art, extProp, name );
+        const elem = art[artProp]?.[name] || annotateFor( art, extProp || 'elements', name );
         setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
         // TODO: why null for annotate?
         ensureArtifactNotProcessed( elem );
@@ -1055,11 +1097,23 @@ function extend( model ) {
 
   function checkRemainingMainExtensions( art, ext ) {
     const refCtx = extensionRefContext( ext );
-    if (!resolvePath( ext.name, refCtx, ext )) // error for extend, info for annotate
-      return;
-
-    if (art?.builtin) {                                       // TODO: do via accept
-      info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
+    if (resolvePath( ext.name, refCtx, ext ) && art?.builtin) {
+      if (ext.kind === 'extend') {
+        // extending built-ins with elements/enums already gives an error
+        warning( 'ext-unexpected-builtin', [ ext.name.location, ext ], {}, // error v8?
+                 'Built-in types should not be extended' ); // keep the text general
+        const typeProp = typeParameters.list.find( p => ext[p] );
+        if (typeProp) {
+          const location = ext.$typeArgs?.[$location] || ext[typeProp].location;
+          message( 'ext-unexpected-type-property', [ location, ext ], {}, // error v7
+                   'Built-in types can\'t be extended with type properties' );
+          // see also 'ext-invalid-type-property'
+        }
+      }
+      else {
+        info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
+      }
+      // TODO: remove built-ins as CC candidates via accept property of ./shared.js
     }
   }
 
@@ -1119,7 +1173,8 @@ function extend( model ) {
     }
     if (art._extensions?.$add)
       extendArtifact( art._extensions.$add, art );
-    // TODO: for proper shadowing: first collect defined element & action names
+    checkRedefinitionThroughIncludes( art, 'elements' );
+    checkRedefinitionThroughIncludes( art, 'actions' );
   }
 
   /**
@@ -1142,10 +1197,33 @@ function extend( model ) {
     // TODO: complain if $inferred
     // checkExtensionsKind( extensions, art );
     extendMembers( extensions, art );
+    reportIncludeCollisions( art );
     // TODO: complain about element extensions inside projection
     return true;
   }
 
+  function reportIncludeCollisions( art ) {
+    const grouped = Object.create( null );
+    for (const {
+      prop, name, existing, elem,
+    } of includeCollisions) {
+      const key = `${ prop }:${ name }`;
+      if (!grouped[key])
+        grouped[key] = { prop, name, collisions: new Set( [ existing ] ) };
+      grouped[key].collisions.add( elem );
+    }
+    for (const key in grouped) {
+      const { prop, name, collisions } = grouped[key];
+      const member = art[prop]?.[name];
+      if (member?.$inferred === 'include') {
+        const arts = [ ...collisions ].map( m => m._origin._main );
+        message( 'ext-duplicate-include', [ art.name.location, member ],
+                 { '#': prop, name, sorted_arts: arts } );
+      }
+    }
+    includeCollisions.length = 0;
+  }
+
   function extendMembers( extensions, art ) {
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
@@ -1154,7 +1232,11 @@ function extend( model ) {
     // TODO: use same sequence as in chooseAssignment() - better: use common code with that fn
     // console.log('EM:',art.name,extensions,art._extensions)
     for (const ext of extensions) { // those in extMap.includes
-      if (art.$inferred) {
+      if (art.$inferred === 'include') {
+        error( 'ref-expected-direct-structure', [ ext.name.location, ext ],
+               { '#': 'elements', art } );
+      }
+      else if (art.$inferred) {
         error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
                'You can\'t use $(KEYWORD) on the generated $(ART)' ); // or with inferred elements
       }
@@ -1298,6 +1380,8 @@ function extend( model ) {
 
     if (obj !== parent && obj.elements && parent.enum) { // applying the extension
       initElementsAsEnum();
+      if (parent.enum[$inferred])
+        setExpandStatus( parent, 'extend' );
     }
     else {
       if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
@@ -1341,7 +1425,11 @@ function extend( model ) {
         e.kind = 'enum';
         hasElement = true;    // warning with CDL input or `name: {}` in CSN input
       }
-      if (hasElement) {
+      if (!parent.type || parent.type.$inferred || (parent._main || parent).query) {
+        error( 'extend-type', [ obj.elements[$location], construct ], {},
+               'Only structures or enum types can be extended with elements/enums' );
+      }
+      else if (hasElement) {
         warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
                  { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
       }
@@ -1404,26 +1492,45 @@ function extend( model ) {
 
       if (isQueryExtension && elem.kind === 'element') {
         error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
-               { code: 'extend projection' },
+               { code: 'extend … with columns' },
                'Use $(CODE) to add select items to the query entity' );
         return;
       }
 
       const existing = parent[prop]?.[name];
+      const shadowsIncludeMember = construct !== parent &&
+        elem.$inferred !== 'include' &&
+        existing?.$inferred === 'include';
       const add = construct !== parent && (!existing || elem.$inferred !== 'include');
+      if (!add && existing?.$inferred === 'include' && elem.$inferred === 'include') {
+        includeCollisions.push( {
+          prop, name, existing, elem,
+        } );
+      }
       // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
       const { $duplicates } = elem;
       if ($duplicates === true && add)
         elem.$duplicates = null;
-      setMemberParent( elem, name, parent, add && prop );
-      if (!$duplicates)         // not already reported
-        checkRedefinition( elem );
+      if (add && elem.$inferred === 'include' && Array.isArray( $duplicates ))
+        elem.$duplicates = null;
+      if (shadowsIncludeMember) {
+        parent[prop][name] = elem;
+        setMemberParent( elem, name, parent );
+      }
+      else {
+        setMemberParent( elem, name, parent, add && prop );
+        if (!$duplicates)       // not already reported
+          checkRedefinition( elem );
+      }
       initMembers( elem, elem, elem._block );
       if (elem.kind === 'action' || elem.kind === 'function')
         initBoundSelfParam( elem.params, elem._main );
 
       // for a correct home path, setMemberParent needed to be called
 
+      if (parent[prop]?.[$inferred])
+        setExpandStatus( parent, 'extend' );
+
       if (!elem.value || elem.kind !== 'element')
         return;
       // remark: potential enum elements have already been turned into enums
@@ -1502,10 +1609,14 @@ function extend( model ) {
         error( 'ref-expected-direct-structure', [ location, construct ],
                { '#': variant, art: parent } );
       }
-      else {
+      else if (prop !== 'enum' || !parent.enum ||
+               !parent.type || parent.type.$inferred || (parent._main || parent).query) {
         error( 'extend-type', [ location, construct ], {},
                'Only structures or enum types can be extended with elements/enums' );
       }
+      else {
+        return true;
+      }
     }
     else if (prop === 'elements') {
       error( 'def-unexpected-elements', [ location, construct ], {},
@@ -1585,6 +1696,7 @@ function extend( model ) {
     // TODO two kind of messages:
     // Error 'More than one include defines element "A"' (at include ref)
     // Warning 'Overwrites definition from include "I" (at elem def)
+    const propagateKeys = art.kind !== 'type' || !model.options.v7KeyPropagation;
     const parent = ext === art && art;
     const members = ext[prop];
     // if (members)console.log( 'EXT:', prop, art.kind, art.name.id, ...Object.keys(members));
@@ -1624,7 +1736,7 @@ function extend( model ) {
           elem.$inferred = 'include';
           if (origin.masked)    // TODO(v6): remove 'masked'
             elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
-          if (origin.key)
+          if (origin.key && propagateKeys)
             elem.key = Object.assign( { $inferred: 'include' }, origin.key );
           if (origin.value && origin.$syntax === 'calc') {
             // TODO: If paths become invalid in the new artifact, should we mark
@@ -1640,9 +1752,6 @@ function extend( model ) {
         } );
       }
     }
-
-    checkRedefinitionThroughIncludes( parent, prop );
-
     if (!hasNewElement && members) {
       ext[prop] = members;
     }
@@ -1688,7 +1797,8 @@ function extend( model ) {
 
   /**
    * Report duplicates in parent[prop] that happen due to multiple includes having the
-   * same member.  Covers `entity G : E, G {};` but not `entity G : E {};  extend G with F;`.
+   * same member.  Run after includes and extends so shadowing members have already
+   * replaced any include-derived survivors in-place.
    */
   function checkRedefinitionThroughIncludes( parent, prop ) {
     if (!parent[prop])

package/lib/compiler/lsp-api.js

@@ -7,7 +7,7 @@
 //
 // This files includes an iterator over "semantic tokens" in an XSN model.
 // "Semantic tokens" are identifiers, but also the "return" parameter.
-// See <../../internalDoc/lsp/IdentifierCrawling.md> for details.
+// See <../../internalDoc/lsp/SemanticTokenCrawling.md> for details.
 
 const { CompilerAssertion } = require('../base/error');
 const $inferred = Symbol.for( 'cds.$inferred' );
@@ -190,7 +190,7 @@ function* artifactTokens( art ) {
  * @returns {Generator<LspSemanticTokenEvent>}
  */
 function* extensionTokens( ext ) {
-  if (ext.kind !== 'extend' && ext.kind !== 'annotate')
+  if (ext.kind !== 'extend' && ext.kind !== 'annotate' || !ext.name)
     return null;
 
   const wasApplied = ext.name._artifact && !ext.name._artifact.$inferred;
@@ -203,7 +203,7 @@ function* extensionTokens( ext ) {
 
   // We need to traverse all dictionaries that could themselves contain
   // extensions.  Enum extensions or columns don't need to be traversed,
-  // for example, because there can't be inner extensions.
+  // for example, because there can't be inner extensions.  TODO: still?
   yield* dictOf( extensionTokens )( ext.params );
   yield* dictOf( extensionTokens )( ext.actions );
   yield* dictOf( extensionTokens )( ext.elements );

package/lib/compiler/populate.js

@@ -36,7 +36,6 @@ const {
   dependsOn,
   proxyCopyMembers,
   setExpandStatus,
-  setExpandStatusAnnotate,
   dependsOnSilent,
   columnRefStartsWithSelf,
   forEachDefinition,
@@ -218,8 +217,8 @@ function populate( model ) {
       populateGeneratedEntity( a );
       if (a.includes)
         a.includes.forEach( i => resolveInclude( i, a ) );
-      extendArtifactAdd( a );
       art = populateArtifact( a, art ) || a;
+      extendArtifactAdd( a );
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
       // console.log('PE:',require('../model/revealInternalProperties').ref(a))
@@ -614,7 +613,7 @@ function populate( model ) {
     }
 
     if (wasAnnotated)
-      setExpandStatusAnnotate( art, 'annotate' );
+      setExpandStatus( art, 'annotate' );
 
     // TODO: We don't check enum$, yet! We first need to fix expansion for
     //       `cast(elem as EnumType)` (see #9421)
@@ -668,7 +667,7 @@ function populate( model ) {
       }
     }
     if (wasAnnotated)
-      setExpandStatusAnnotate( art, 'annotate' );
+      setExpandStatus( art, 'annotate' );
 
     for (const id in art.foreignKeys$) {
       const specifiedElement = art.foreignKeys$[id];
@@ -767,7 +766,7 @@ function populate( model ) {
     const { targetMax } = path[path.length - 1].cardinality ||
                           getInheritedProp( assoc, 'cardinality' ) || {};
     if (targetMax && (targetMax.val === '*' || targetMax.val > 1)) {
-      elem.items = { location: elem.expand[$location] };
+      elem.items = { location: elem.expand[$location], $inferred: 'query' };
       setLink( elem.items, '_outer', elem );
     }
     return initFromColumns( elem, elem.expand );

package/lib/compiler/resolve.js

@@ -39,7 +39,7 @@
 'use strict';
 
 const { isDeprecatedEnabled } = require('../base/specialOptions');
-const { dictAdd } = require('./dictionaries');
+const { dictAdd, pushToDict } = require('./dictionaries');
 const { weakLocation } = require('../base/location');
 const { combinedLocation } = require('../base/location');
 const { typeParameters } = require('./builtins');
@@ -285,9 +285,9 @@ function resolve( model ) {
       // we don't propagate keys to type projections, see #13575
       return;
     }
-    // Second argument true ensure that `key` is only propagated along simple
+    // Second argument controls whether `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
-    traverseQueryPost( view.query, true, ( query ) => {
+    traverseQueryPost( view.query, !options.v7KeyPropagation, ( query ) => {
       if (!withExplicitKeys( query ) && inheritKeyProp( query ) &&
           withKeyPropagation( query )) // now the part with messages
         inheritKeyProp( query, true );
@@ -331,47 +331,47 @@ function resolve( model ) {
     return head?.kind === '$tableAlias' && item._artifact?.key;
   }
 
-  function primarySourceNavigation( aliases ) {
-    for (const name in aliases)
-      return aliases[name].elements;
-    return undefined;
-  }
-
   function withKeyPropagation( query ) {
-    const { from } = query;
+    const { from, $tableAliases } = query;
     if (!from)                  // parse error SELECT FROM <EOF>
       return false;
-
     let propagateKeys = true;   // used instead early RETURN to get more messages
-    const toMany = withAssociation( from, targetMaxNotOne, true );
-    if (toMany) {
-      propagateKeys = false;
-      info( 'query-from-many', [ toMany.location, query ], { art: toMany }, {
-        std: 'Key properties are not propagated because a to-many association $(ART) is selected',
-        // eslint-disable-next-line @stylistic/max-len
-        element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
-      } );
-    }
+
     // Check that all keys from the source are projected:
-    const notProjected = [];    // we actually push to the array
-    const navElems = primarySourceNavigation( query.$tableAliases );
+    const notProjected = Object.create( null );
+    const navElems = query._combined;
     for (const name in navElems) {
       const nav = navElems[name];
-      if (nav.$duplicates)
-        continue;
-      const { key } = nav._origin;
-      if (key?.val && !nav._projections?.length)
-        notProjected.push( nav.name.id );
+      if (Array.isArray( nav ))
+        nav.forEach( pushNonProjected );
+      else
+        pushNonProjected( nav );
     }
-    if (notProjected.length) {
+    for (const [ alias, names ] of Object.entries( notProjected )) {
       propagateKeys = false;
-      info( 'query-missing-keys', [ from.location, query ], { names: notProjected },
+      // TODO: mention alias
+      const location = $tableAliases[alias].name?.location || from.location;
+      info( 'query-missing-keys', [ location, query ], { names },
             {
               std: 'Keys $(NAMES) have not been projected - key properties are not propagated',
               one: 'Key $(NAMES) has not been projected - key properties are not propagated',
             } );
     }
-    // Check that there is no to-many assoc used in select item:
+    if (options.v7KeyPropagation)
+      return propagateKeys;
+
+    // Check that there is no to-many assoc in the FROM reference or in the select
+    // item reference (references in expressions are not checked,
+    // withAssociation() will see no _artifact links anyway)
+    const toMany = withAssociation( from, targetMaxNotOne, true );
+    if (toMany) {
+      propagateKeys = false;
+      info( 'query-from-many', [ toMany.location, query ], { art: toMany }, {
+        std: 'Key properties are not propagated because a to-many association $(ART) is selected',
+        // eslint-disable-next-line @stylistic/max-len
+        element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
+      } );
+    }
     for (const name in query.elements) {
       const elem = query.elements[name];
 
@@ -383,6 +383,14 @@ function resolve( model ) {
     }
     return propagateKeys;
 
+    function pushNonProjected( nav ) {
+      if (nav.$duplicates)
+        return;
+      const { key } = nav._origin;
+      if (key?.val && !nav._projections?.length)
+        pushToDict( notProjected, nav._parent.name.id, nav.name.id );
+    }
+
     function selectTest( expr, user ) {
       const art = withAssociation( expr, targetMaxNotOne );
       if (art) {
@@ -1004,11 +1012,16 @@ function resolve( model ) {
       forEachGeneric( query, 'elements', resolveRefs );
     if (query.from)
       resolveJoinOn( query.from );
-    if (query.where)
-      resolveExpr( query.where, 'where', query );
+    if (query.where) {
+      const user = query.where._block ? query.where : query;
+      resolveExpr( query.where, 'where', user );
+    }
     if (query.groupBy)
       resolveBy( query.groupBy, 'groupBy', 'groupBy' );
-    resolveExpr( query.having, 'having', query );
+    if (query.having) {
+      const user = query.having._block ? query.having : query;
+      resolveExpr( query.having, 'having', user );
+    }
     if (query.$orderBy)       // ORDER BY from UNION:
       // TODO clarify: can I access the tab alias of outer queries?  If not:
       // 4th arg query._main instead query._parent.
@@ -1051,8 +1064,10 @@ function resolve( model ) {
      */
     function resolveBy( array, refMode, exprMode ) {
       for (const value of array ) {
-        if (value)
-          resolveExpr( value, (value.path ? refMode : exprMode), query );
+        if (value) {
+          const user = value._block ? value : query;
+          resolveExpr( value, (value.path ? refMode : exprMode), user );
+        }
       }
     }
 

package/lib/compiler/shared.js

@@ -790,6 +790,8 @@ function fns( model ) {
       return undefined;         // parse error
     if (head._artifact !== undefined)
       return head._artifact;
+    if (user.$extended && user._outer && !semantics.isMainRef)
+      user = user._outer;
     let ruser = user._user || user; // TODO: nicer name if we keep this
     // TODO: re-think _user link
     if (ruser._outer && !semantics.isMainRef) {
@@ -982,8 +984,6 @@ function fns( model ) {
           art.kind === '$self' && path[0].id === '$projection') {
         // Rewrite $projection to $self
         path[0].id = '$self';
-        warning( 'ref-expecting-$self', [ path[0].location, user ],
-                 { code: '$projection', newcode: '$self' });
       }
       return art.name?.$inferred !== '$internal'; // not a compiler-generated internal alias
     }
@@ -1035,13 +1035,23 @@ function fns( model ) {
         return null;
       }
       case 'mixin': {
-        // use a source element having that name if in `extend … with columns`:
-        const elem = (user._user || user).$extended &&
-          art._parent._combined[head.id];
+        // use a source element having that name if in `extend … with` (columns or groupBy):
+        const $extended = user._user?.$extended ?? user.$extended;
+        const elem = $extended && art._parent._combined[head.id];
         if (elem) {
           path.$prefix = elem._parent.name.id; // prepend alias name
-          info( 'ref-special-in-extend', [ head.location, user ],
-                { '#': 'mixin', id: head.id, art: elem._origin._main } );
+          if ($extended === 'columns') {
+            warning( 'ref-special-in-extend', [ head.location, user ],
+                     { '#': 'mixin', id: head.id, art: elem._origin._main } );
+          }
+          else {
+            error( 'ref-unexpected-in-extend', [ head.location, user ], {
+              '#': 'mixin',
+              keyword: $extended,
+              id: head.id,
+              art: elem._origin._main,
+            } );
+          }
           setLink( head, '_navigation', elem );
           return setArtifactLink( head, elem._origin );
         }
@@ -1052,21 +1062,30 @@ function fns( model ) {
         return setArtifactLink( head, art._origin );
       }
       case '$tableAlias': {
-        // use a source element having that name if in `extend … with columns`:
-        const { $extended } = user._user || user;
+        // use a source element having that name if in `extend … with` (columns or groupBy):
+        const $extended = user._user?.$extended ?? user.$extended;
         // if query source has duplicates, table alias has no elements
         const elem = $extended && art.elements?.[head.id];
         if (elem) {
           path.$prefix = art.name.id; // prepend alias name
-          info( 'ref-special-in-extend', [ head.location, user ],
-                { '#': 'alias', id: head.id, art: elem._origin._main } );
+          if ($extended === 'columns') {
+            warning( 'ref-special-in-extend', [ head.location, user ],
+                     { '#': 'alias', id: head.id, art: elem._origin._main } );
+          }
+          else {
+            error( 'ref-unexpected-in-extend', [ head.location, user ], {
+              '#': 'alias',
+              keyword: $extended,
+              id: head.id,
+              art: elem._origin._main,
+            } );
+          }
           setLink( head, '_navigation', elem );
           return setArtifactLink( head, elem._origin );
         }
         else if ($extended && art.elements) {
-          warning( 'ref-deprecated-in-extend', [ head.location, user ], { id: head.id },
-                   // eslint-disable-next-line @stylistic/max-len
-                   'In an added column, do not use the table alias $(ID) to refer to source elements' );
+          warning( 'ref-deprecated-in-extend', [ head.location, user ],
+                   { '#': $extended, id: head.id } );
         }
       }
       /* FALLTHROUGH */

package/lib/compiler/tweak-assocs.js

@@ -87,7 +87,7 @@ function tweakAssocs( model ) {
       forEachGeneric( art, 'elements', complainAboutTargetOutsideService );
 
     if (art.query) {
-      traverseQueryPost(art.query, false, (query) => {
+      traverseQueryPost(art.query, null, (query) => {
         forEachGeneric( query, 'elements', handleQueryElements );
       });
     }
@@ -103,7 +103,7 @@ function tweakAssocs( model ) {
   // Check explicit ON / keys with REDIRECTED TO
   // TODO: run on all queries, but this is potentially incompatible
   // function rewriteViewCheck( view ) {
-  //   traverseQueryPost( view.query, false, ( query ) => {
+  //   traverseQueryPost( view.query, null, ( query ) => {
   //     forEachGeneric( query, 'elements', rewriteAssociationCheck );
   //   } );
   // }