@sap/cds-compiler 6.4.6 → 6.5.0

package/lib/compiler/extend.js

@@ -19,8 +19,14 @@ const {
   copyExpr,
   setExpandStatusAnnotate,
   linkToOrigin,
+  initItemsLinks,
+  setMemberParent,
   createAndLinkCalcDepElement,
+  initExprAnnoBlock,
+  initDollarSelf,
+  initBoundSelfParam,
   dependsOnSilent,
+  storeExtension,
   pathName,
   annotationHasEllipsis,
 } = require('./utils');
@@ -62,7 +68,8 @@ function extend( model ) {
     resolveTypeArgumentsUnchecked,
     resolveDefinitionName,
     attachAndEmitValidNames,
-    initMembers,
+    targetIsTargetAspect,
+    checkRedefinition,
     initSelectItems,
   } = model.$functions;
 
@@ -730,12 +737,15 @@ function extend( model ) {
 
     for (const ext of extensions) {
       if (!artReturns && art.kind !== 'annotate') {
-        warning( 'ext-unexpected-returns', [ ext.returns.location, ext ], {
+        const msgId = ext.returns && hasSecurityAnno( ext.returns )
+          ? 'ext-unexpected-returns-sec'
+          : 'ext-unexpected-returns';
+        message( msgId, [ ext.returns.location, ext ], {
           '#': (isAction ? art.kind : 'std'), keyword: 'returns',
         }, {
           std: 'Unexpected $(KEYWORD); only actions and functions have return parameters',
           action: 'Unexpected $(KEYWORD) for action without return parameter',
-          // function without `returns` can happen via CSN input!
+          // function without `returns` can happen via CSN input! TODO: check in parser
           function: 'Unexpected $(KEYWORD) for function without return parameter',
         } );
         // Do not put completely wrong returns into a “super annotate” statement;
@@ -816,7 +826,8 @@ function extend( model ) {
     // if we consider this an error or such sub annotates are then ignored
     // (i.e. not put into the "super annotate").
     const dict = parent[prop];
-    if (!dict) {
+    const securityRelevant = hasSecurityAnno( ext ) ? '-sec' : '';
+    if (!dict && !securityRelevant) {
       // TODO: check - for each name? - better locations
       const location = ext._parent?.[prop]?.[$location] || ext.name.location;
       // Remark: no `elements` dict location with `annotate Main:elem`
@@ -851,7 +862,7 @@ function extend( model ) {
       }
       return false;
     }
-    else if (!dict[name]) {
+    else if (!dict?.[name]) {
       // TODO: make variant `returns` an auto-variant for ($ART) ?
       const inReturns = parent._parent?.returns && parent._parent;
       const art = inReturns || parent;
@@ -859,28 +870,28 @@ function extend( model ) {
         case 'elements':
           if (canBeDraftMember( name, parent, draftElements ))
             break;
-          notFound( 'ext-undefined-element', ext.name.location, ext,
+          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
                     { '#': (inReturns ? 'returns' : 'element'), art, name },
                     parent.elements );
           break;
         case 'enum':            // TODO: extra msg id?
-          notFound( 'ext-undefined-element', ext.name.location, ext,
+          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
                     { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
                     parent.enum );
           break;
         case 'foreignKeys':
-          notFound( 'ext-undefined-key', ext.name.location, ext,
+          notFound( `ext-undefined-key${ securityRelevant }`, ext.name.location, ext,
                     { name }, parent.foreignKeys );
           break;
         case 'params':
-          notFound( 'ext-undefined-param', ext.name.location, ext,
+          notFound( `ext-undefined-param${ securityRelevant }`, ext.name.location, ext,
                     { '#': 'param', art: parent, name },
                     parent.params );
           break;
         case 'actions':
           if (canBeDraftMember( name, parent, draftBoundActions ))
             break;
-          notFound( 'ext-undefined-action', ext.name.location, ext,
+          notFound( `ext-undefined-action${ securityRelevant }`, ext.name.location, ext,
                     { '#': 'action', art: parent, name },
                     parent.actions );
           break;
@@ -924,8 +935,16 @@ function extend( model ) {
     forEachMember( annotate, createSuperAnnotate );
   }
 
+  function hasSecurityAnno( ext ) {
+    return ext['@restrict'] || ext['@requires'] ||
+      Object.keys( ext ).some( prop => prop.startsWith( '@ams.' ) );
+  }
+
   function checkRemainingMainExtensions( art, ext ) {
-    if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
+    const refCtx = ext.kind === 'annotate' && hasSecurityAnno( ext )
+      ? 'annotate-sec'
+      : ext.kind;
+    if (!resolvePath( ext.name, refCtx, ext )) // error for extend, info for annotate
       return;
 
     if (art?.builtin) {
@@ -1186,6 +1205,273 @@ function extend( model ) {
     }
   }
 
+  // TODO TMP: copied from ./define.js: -----------------------------------------
+
+  /**
+   * Set property `_parent` for all elements in `parent` to `parent` and do so
+   * recursively for all sub elements.
+   *
+   * If not for extensions: construct === parent
+   *
+   * Param `initExtensions` is for parse.cdl - TODO delete
+   *
+   * TODO: separate extension!
+   */
+  function initMembers( construct, parent, block, initExtensions = false ) {
+    // TODO: split extend from init
+    const main = parent._main || parent;
+    const isQueryExtension = construct.kind === 'extend' && main.query;
+    let obj = initItemsLinks( construct, block );
+    initExprAnnoBlock( construct, block );
+    if (obj.target && targetIsTargetAspect( obj )) {
+      obj.targetAspect = obj.target;
+      delete obj.target;
+    }
+    const { targetAspect } = obj;
+    if (targetAspect) {
+      if (obj.foreignKeys) {
+        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ] );
+        delete obj.foreignKeys; // continuation semantics: not specified
+      }
+      if (obj.on && !obj.target) {
+        error( 'type-unexpected-on-condition', [ obj.on.location, construct ] );
+        delete obj.on;          // continuation semantics: not specified
+      }
+      if (targetAspect.elements)
+        initAnonymousAspect();
+    }
+    if (obj !== parent && obj.elements && parent.enum) { // applying the extension
+      initElementsAsEnum();
+    }
+    else {
+      if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
+        forEachInOrder( obj, 'elements', init );
+      if (checkDefinitions( construct, parent, 'enum', obj.enum || false ))
+        forEachGeneric( obj, 'enum', init );
+    }
+
+    if (obj.foreignKeys)
+      forEachInOrder( obj, 'foreignKeys', init );
+    if (checkDefinitions( construct, parent, 'actions' ))
+      forEachGeneric( construct, 'actions', init );
+    if (checkDefinitions( construct, parent, 'params' ))
+      forEachInOrder( construct, 'params', init );
+    const { returns } = construct;
+    if (returns) {
+      const { kind } = construct;
+      returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
+      init( returns, '' );      // '' is special name for returns parameter
+    }
+    return;
+
+    function initElementsAsEnum() {
+      // in extensions, extended enums are represented as elements
+      let hasElement = false;
+      for (const n in obj.elements) {
+        const e = obj.elements[n];
+        if (e.kind === 'extend')
+          continue;
+        const noVal = e.value?.val === undefined && e.value?.sym === undefined;
+        // TODO: forbid #symbol as enum value
+        if (e.$syntax === 'element' || // `extend … with elements` or `extend with { element … }`
+            noVal && e.$syntax !== 'enum' || // no value in CDL input
+            e.virtual || e.key || e.masked || e.type || e.elements || e.items || e.stored) {
+          // We do not want to complain separately about all element properties:
+          error( 'ext-unexpected-element', [ e.location, construct ],
+                 { name: e.name.id, code: 'extend … with enum' },
+                 // eslint-disable-next-line @stylistic/max-len
+                 'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
+          // Don't emit 'ext-expecting-enum' if this error is emitted.
+          return;
+        }
+        e.kind = 'enum';
+        if (noVal || e.$syntax !== 'enum')
+          hasElement = true;    // warning with CDL input or `name: {}` in CSN input
+      }
+      if (hasElement) {
+        // This message is similar to the one above.  In v6, we could probably
+        // turn this warning into an error, remove `$syntax: 'element',
+        // and use the above `ext-unexpected-element` only for CSN input.
+        warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
+                 { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
+      }
+      forEachGeneric( { enum: obj.elements }, 'enum', init );
+    }
+
+    function initAnonymousAspect() {
+      // TODO: main?
+      const inEntity = parent._main?.kind === 'entity';
+      // TODO: also allow indirectly (component in component in entity)?
+      setLink( targetAspect, '_outer', obj );
+      setLink( targetAspect, '_parent', parent._parent );
+      setLink( targetAspect, '_main', null ); // for name resolution
+
+      parent = targetAspect;
+      construct = parent;     // avoid extension behavior
+      targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+      setLink( targetAspect, '_block', block );
+      initDollarSelf( targetAspect );
+      // allow ref of up_ in anonymous aspect inside entity
+      // (TODO: complain if used and the managed composition is included into
+      // another entity - might induce auto-redirection):
+      if (inEntity && !targetAspect.elements.up_) {
+        const up = {
+          name: { id: 'up_' },
+          kind: '$navElement',
+          location: obj.location,
+        };
+        setLink( up, '_parent', targetAspect );
+        setLink( up, '_main', targetAspect ); // used on main artifact
+        // recompilation case: both target and targetAspect → allow up_ in that case, too:
+        const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
+        const entity = name && model.definitions[name];
+        if (entity && entity.elements)
+          setLink( up, '_origin', entity.elements.up_ );
+        // processAspectComposition/expand() sets _origin to element of
+        // generated target entity
+        targetAspect.$tableAliases.up_ = up;
+      }
+      obj = targetAspect;
+    }
+
+    function init( elem, name, prop ) {
+      if (!elem.kind)           // wrong CSN input
+        elem.kind = dictKinds[prop];
+      if (!elem.name && !elem._outer) {
+        const ref = elem.targetElement || elem.kind === 'element' && elem.value;
+        if (ref && ref.path) {
+          elem.name = Object.assign( { $inferred: 'as' },
+                                     ref.path[ref.path.length - 1] );
+        }
+        else {                  // RETURNS, parser robustness
+          elem.name = { id: name, location: elem.location };
+        }
+      }
+      // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
+      if ((elem.kind === 'extend' || elem.kind === 'annotate') && !initExtensions) {
+        storeExtension( elem, name, prop, parent, block );
+        return;
+      }
+      if (isQueryExtension && elem.kind === 'element') {
+        error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
+               { code: 'extend projection' },
+               'Use $(CODE) to add select items to the query entity' );
+        return;
+      }
+
+      const bl = elem._block || block;
+      setLink( elem, '_block', bl );
+      const existing = parent[prop]?.[name];
+      const add = construct !== parent && (!existing || elem.$inferred !== 'include');
+      // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
+      if (elem.$duplicates === true && add)
+        elem.$duplicates = null;
+      setMemberParent( elem, name, parent, add && prop );
+      checkRedefinition( elem );
+      initMembers( elem, elem, bl, initExtensions );
+      if (elem.kind === 'action' || elem.kind === 'function')
+        initBoundSelfParam( elem.params, elem._main );
+
+      // for a correct home path, setMemberParent needed to be called
+
+      if (!elem.value || elem.kind !== 'element' ||
+          elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
+        return;
+      // -> it's a calculated element
+      if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
+        if (!elem.target)
+          elem.type = { ...elem.value.type, $inferred: 'cast' };
+      }
+      elem.$syntax = 'calc';
+      // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
+      createAndLinkCalcDepElement( elem );
+
+      // Special case (hack) for calculated elements that use composition+filter:
+      // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
+      if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
+        delete elem.type;
+        delete elem.on;
+        delete elem.target;
+      }
+    }
+  }
+
+  // TODO: is only necessary for extensions - make special for extend/annotate
+  function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
+    // TODO: do differently, see also annotateMembers() in resolver
+    // To have been checked by parsers:
+    // - artifacts (CDL-only anyway) only inside [extend] context|service
+    if (!dict)
+      return false;
+    const feature = kindProperties[parent.kind ?? 'element'][prop];
+    if (feature &&
+        (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
+      return true;
+    const location = dict[$location];
+
+    // TODO: a bit inconsistent = not a simple switch on `prop`…
+    if (prop === 'actions') {
+      if (Object.keys( dict ).length) {
+        error( 'def-unexpected-actions', [ location, construct ], {}, // TODO: ext-
+               'Actions and functions only exist top-level and for entities' ); // or aspects
+      }
+      else {
+        warning( 'ext-ignoring-actions', [ location, construct ], {},
+                 'Actions and functions only exist top-level and for entities' );
+        return false;
+      }
+    }
+    else if (parent.kind === 'action' || parent.kind === 'function') {
+      error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
+        std: 'Actions and functions can\'t be extended, only annotated', // TODO: → ext-unsupported
+        action: 'Actions can\'t be extended, only annotated',
+        function: 'Functions can\'t be extended, only annotated',
+      } );
+    }
+    else if (prop === 'params') {
+      if (!feature) {
+        // Note: This error can't be triggered at the moment.  But as we likely want to
+        //       allow extensions with params in the future, we keep the code.
+        error( 'def-unexpected-params', [ location, construct ], {},
+               'Parameters only exist for entities, actions or functions' );
+      }
+      else {
+        // remark: we could allow this
+        error( 'extend-with-params', [ location, construct ], {},
+               'Extending artifacts with parameters is not supported' );
+      }
+    }
+    else if (feature) {         // allowed in principle, but not with extend
+      if (!Object.keys( dict ).length) {
+        warning( 'ext-ignoring-elements', [ location, construct ], {},
+                 'Only structures with directly specified elements can be extended by elements' );
+        return false;
+      }
+      else if (parent.$inferred === 'include') { // special case for better error message
+        const variant = (construct.enum || construct.elements) ? 'elements' : 'std';
+        error( 'ref-expected-direct-structure', [ location, construct ],
+               { '#': variant, art: parent } );
+      }
+      else {
+        error( 'extend-type', [ location, construct ], {},
+               'Only structures or enum types can be extended with elements/enums' );
+      }
+    }
+    else if (prop === 'elements') {
+      error( 'def-unexpected-elements', [ location, construct ], {},
+             'Elements only exist in entities, types or typed constructs' );
+    }
+    else if (prop === 'columns') {
+      error( 'extend-columns', [ location, construct ], { art: construct } );
+    }
+    else { // if (prop === 'enum') {
+      error( 'def-unexpected-enum', [ location, construct ], {},
+             'Enum symbols can only be defined for types or typed constructs' );
+    }
+    return construct === parent;
+  }
+
+
   // includes ----------------------------------------------------------------
 
   /**

package/lib/compiler/finalize-parse-cdl.js

@@ -42,7 +42,7 @@ function finalizeParseCdl( model ) {
       for (const ext of late[name]._extensions) {
         ext.name.id = resolveUncheckedPath( ext.name, '_uncheckedExtension', ext );
         // Initialize members and define annotations in sub-elements.
-        initMembers( ext, ext, ext._block, true );
+        initMembers( ext, true );
         extensions.push( ext );
       }
     }
@@ -117,15 +117,7 @@ function finalizeParseCdl( model ) {
     // containing it.  Otherwise some type's aren't properly resolved.
     // TODO: If resolveTypeUnchecked is reworked, we may be able to simplify this coding.
     (artifact.$queries || []).forEach( art => resolveTypesForParseCdl( art, artifact ) );
-    (artifact.columns || []).forEach( (col) => {
-      // TODO: Can we use "ensureColumnName" of populate.js? It depends on column indices
-      //  _after_ wildcards were expanded, though.
-      if (!col.name && col.value?.path) {
-        const last = col.value.path.at(-1);
-        col.name = { id: last?.id || '', location: last?.location, $inferred: 'as' };
-      }
-      resolveTypesForParseCdl( col, artifact );
-    } );
+    (artifact.columns || []).forEach( col => resolveTypesForParseCdl( col, artifact ) );
     forEachGeneric( artifact, 'mixin', art => resolveTypesForParseCdl( art, artifact ) );
 
     // For better error messages for `type of`s in `returns`, we pass the object as the new main.

package/lib/compiler/generate.js

@@ -411,6 +411,8 @@ function generate( model ) {
     const { location } = art;
 
     art.includes = [ createInclude( textsAspectName, location ) ];
+    propagateEarly( art, '@cds.autoexpose' );
+    propagateEarly( art, '@fiori.draft.enabled' );
 
     if (fioriEnabled) {
       // "Early" include; only for element `locale`, which has its `key` property
@@ -490,6 +492,7 @@ function generate( model ) {
 
   /**
    * Create a structure that can be used as an item in `includes`.
+   * TODO: replace by linkMainArtifact()
    *
    * @param {string} name
    * @param {XSN.Location} location
@@ -696,8 +699,11 @@ function generate( model ) {
       $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
-      if (!isDeprecatedEnabled( options, 'noCompositionIncludes' ))
+      if (!isDeprecatedEnabled( options, 'noCompositionIncludes' )) {
         art.includes = [ createInclude( target.name.id, location ) ];
+        propagateEarly( art, '@cds.autoexpose' );
+        propagateEarly( art, '@fiori.draft.enabled' );
+      }
       setLink( art, '_origin', target );
       setLink( art, '_upperAspects', [ target, ...(elem._main._upperAspects || []) ] );
     }
@@ -858,4 +864,26 @@ function checkTextsLanguageAssocOption( model, options ) {
 }
 
 
+/**
+ * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
+ * if they have the property.
+ * TEMPORARY copy from ./extend.js
+ *
+ * @param {XSN.Definition} art
+ * @param {string} prop
+ */
+function propagateEarly( art, prop ) {
+  if (art[prop])
+    return;
+  for (const ref of art.includes) {
+    const aspect = ref._artifact;
+    if (aspect) {
+      const anno = aspect[prop];
+      if (anno && (anno.val !== null || !art[prop]))
+        art[prop] = Object.assign( { $inferred: 'include' }, anno );
+    }
+  }
+}
+
+
 module.exports = generate;

package/lib/compiler/populate.js

@@ -716,8 +716,7 @@ function populate( model ) {
     return initFromColumns( elem, elem.expand );
   }
 
-  // TODO: make this function shorter - make part of this (e.g. setting
-  // parent/name) also be part of definer.js
+  // TODO: make this function shorter
   // TODO: query is actually the elemParent, where the new elements are added to
   // top-level: ( query, query.columns )
   // inline: ( queryOrColParent, col.inline, col )
@@ -730,14 +729,13 @@ function populate( model ) {
         query._main.elements = elemsParent.elements;
     }
 
-    const isExpand = (query.expand === columns);
     if (!columns)
       columns = [ { val: '*' } ];
 
     for (let i = 0; i < columns.length; ++i) {
       const col = columns[i];
       if (col.val === '*') {
-        const siblings = wildcardSiblings( columns, query );
+        const siblings = wildcardSiblings( columns );
         expandWildcard( col, siblings, inlineHead, query );
       }
       // If neither expression (value), expand, new virtual nor new association.
@@ -748,6 +746,7 @@ function populate( model ) {
         q.$inlines.push( col );
         col.kind = '$inline';
         col.name = { id: `.${ q.$inlines.length }`, $inferred: '$internal' };
+        // TODO: use a name already set in define.js
         // TODO: really use $inferred: '$internal', not '$inline' ? Re-check.
         // a name for this internal symtab entry (e.g. '.2' to avoid clashes
         // with real elements) is only relevant for `cdsc -R`/debugging
@@ -755,14 +754,15 @@ function populate( model ) {
         // (is also relevant for the semantic location - only use positive)
         dependsOnSilent( q, col );
         // or use userQuery( query ) in the following, too?
-        setMemberParent( col, null, query );
+        setMemberParent( col, null, query ); // TODO: really set _parent?
         initFromColumns( query, col.inline, col );
       }
       else if (!col.$replacement) {
-        const id = ensureColumnName( col, i, query, isExpand );
+        const { id } = col.name;
         col.kind = 'element';
-        dictAdd( elemsParent.elements, id, col, ( name, location ) => {
-          error( 'duplicate-definition', [ location, query ], { name, '#': 'element' } );
+        dictAdd( elemsParent.elements, id, col, ( name, location, c ) => {
+          if (c.name.$inferred !== '$internal')
+            error( 'duplicate-definition', [ location, query ], { name, '#': 'element' } );
         } );
         setMemberParent( col, id, query );
       }
@@ -771,54 +771,6 @@ function populate( model ) {
     return true;
   }
 
-  /**
-   * TODO: probably do this already in definer.js
-   *
-   * @param col
-   * @param {number} colIndex
-   * @param query
-   * @param {boolean} insideExpand
-   *     Whether the column is inside 'expand'.
-   *     Anonymous 'expands' don't have a column parent, hence why we need to know this explicitly.
-   */
-  function ensureColumnName( col, colIndex, query, insideExpand ) {
-    if (col.name)
-      return col.name.id;
-    if (col.inline || col.val === '*' || col.val === '**') // '**' = duplicate '*'
-      return '';
-    const path = col.value &&
-        (col.value.path || !col.value.args && col.value.func?.path);
-    if (path) {
-      const last = path.length && !path.broken && path[path.length - 1];
-      if (last) {
-        col.name = { id: last.id || '', location: last.location, $inferred: 'as' };
-        return col.name.id;
-      }
-    }
-    else if (insideExpand || col.expand ||
-        col.value && (col._columnParent || query._parent.kind !== 'select')) {
-      // _columnParent => inline/expand with path head; _parent -> only allowed in sub-selects
-      error( 'query-req-name', [ col.value?.location || col.location, query ], {},
-             'Alias name is required for this select item' );
-    }
-    else if (col.value) {
-      col.name = {
-        // NOTE: If the alias is changed, corresponding name-clash tests must be updated as well!
-        id: `$_column_${ colIndex + 1 }`,
-        location: col.value.location || col.location,
-        $inferred: '$internal',
-      };
-      return col.name.id;
-    }
-    // invent a name for code completion in expression, see also #10596
-    col.name = {
-      id: '',
-      location: col.value?.location || col.location,
-      $inferred: 'none',
-    };
-    return '';
-  }
-
   function initElem( elem ) {
     // TODO: we could share code with initMembers/init() in define.js
     if (elem.type && !elem.type.$inferred)
@@ -844,23 +796,21 @@ function populate( model ) {
 
   // col ($replacement set before *)
   // false if two cols have same name
-  function wildcardSiblings( columns, query ) {
+  function wildcardSiblings( columns ) {
     const siblings = Object.create( null );
     if (!columns)
       return siblings;
 
     let seenWildcard = null;
-    let colIndex = 0;
     for (const col of columns) {
-      const id = ensureColumnName( col, colIndex, query, false );
-      if (id) {
+      const { name } = col;
+      if (name) {
         col.$replacement = !seenWildcard;
-        siblings[id] = !(id in siblings) && col;
+        siblings[name.id] = !(name.id in siblings) && col;
       }
       else if (col.val === '*') {
         seenWildcard = true;
       }
-      ++colIndex;
     }
     return siblings;
   }
@@ -975,7 +925,14 @@ function populate( model ) {
     if (!sibling.target || sibling.target.$inferred || // not explicit REDIRECTED TO
         path && path[path.length - 1].id !== sibling.name.id) { // or renamed
       const { id } = sibling.name;
-      if (Array.isArray( navElem )) {
+      if (sibling.name.$inferred === '$internal') {
+        error( 'query-req-name',
+               // TODO: message function: `query` should work directly
+               [ (sibling.value || sibling).location, query ],
+               {},
+               'Alias name is required for this select item' );
+      }
+      else if (Array.isArray( navElem )) {
         // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'wildcard-excluding-many', [ sibling.name.location, query ],
               { id, keyword: 'excluding' },
@@ -1259,6 +1216,7 @@ function populate( model ) {
   // Auto-exposure -----------------------------------------------------------
 
   // TODO: do something in kick-start.js ?
+  // Remark: With includes, the compiler propagates @cds.autoexpose early.
   function isAutoExposed( target ) {
     if (target.$autoexpose !== undefined)
       return target.$autoexpose;

package/lib/compiler/propagator.js

@@ -12,7 +12,6 @@ const {
   forEachDefinition,
   forEachMember,
   forEachGeneric,
-  isBetaEnabled,
 } = require( '../base/model');
 const {
   setLink,
@@ -297,7 +296,7 @@ function propagate( model ) {
     else if (destination.kind === 'element' &&
              destination._main?.query && // query element
              !destination.$calc && origin.$calc !== true &&
-             isBetaEnabled( model.options, '$calcForDraft' )) {
+             !model.options.noDollarCalc ) {
       destination.$calc
         = Object.assign( copyExpr( origin[prop] ), { $inferred: 'prop' } );
       if (rewriteRefsInExpression( destination, origin, '$calc' ))