@sap/cds-compiler 6.5.0 → 6.5.2

package/CHANGELOG.md

@@ -13,6 +13,14 @@ we might not list every change in its behavior here.
 Productive code should never require a `beta` flag to be set, and
 might use a deprecated flag only for a limited period of time.
 
+## Version 6.5.2 - 2025-12-02
+
+### Fixed
+
+- to.sql|hdi:
+  + Don't add superfluous (and actually wrong) parentheses around `UNION`s
+  + Don't dump with a specific column expressions in the query after a `UNION`
+
 ## Version 6.5.0 - 2025-11-21
 
 ### Added

package/bin/cdsc.js

@@ -153,7 +153,7 @@ function cdscMain() {
   // Internally, parseCdl/parseOnly are options, so we map the command to it.
   if (cmdLine.command === 'parse') {
     cmdLine.command = 'toCsn';
-    cmdLine.options.toCsn = cmdLine.options.parseCdl;
+    cmdLine.options.toCsn = cmdLine.options.parse || cmdLine.options.parseCdl;
     cmdLine.options.parseCdl = true;
     cmdLine.args.files = [ cmdLine.args.file ];
   }

package/lib/base/message-registry.js

@@ -959,28 +959,28 @@ const centralMessageTexts = {
   'ext-undefined-art-sec': 'No artifact has been found with name $(ART)',
   'ext-undefined-element': {
     std: 'Element $(NAME) has not been found',
-    element: 'Artifact $(ART) has no element $(NAME)',
-    enum: 'Artifact $(ART) has no enum $(NAME)',
-    returns: 'Return value of $(ART) has no element $(NAME)',
-    'enum-returns': 'Return value of $(ART) has no enum $(NAME)',
+    enum: 'Enum symbol $(NAME) has not been found',
+    returns: 'The return value has no element $(NAME)',
+    'enum-returns': 'The return value has no enum $(NAME)',
+  },
+  'ext-undefined-element-sec': {
+    std: 'Element $(NAME) has not been found',
+    enum: 'Enum symbol $(NAME) has not been found',
+    returns: 'The return value has no element $(NAME)',
+    'enum-returns': 'The return value has no enum $(NAME)',
   },
-  'ext-undefined-element-sec': 'Element $(NAME) has not been found',
   'ext-undefined-key': 'Foreign key $(NAME) has not been found',
   'ext-undefined-action': {
-    std: 'Action $(ART) has not been found',
-    action: 'Artifact $(ART) has no action $(NAME)',
+    std: 'Action $(NAME) has not been found',
   },
   'ext-undefined-action-sec': {
-    std: 'Action $(ART) has not been found',
-    action: 'Artifact $(ART) has no action $(NAME)',
+    std: 'Action $(NAME) has not been found',
   },
   'ext-undefined-param': {
-    std: 'Parameter $(ART) has not been found',
-    param: 'Artifact $(ART) has no parameter $(NAME)',
+    std: 'Parameter $(NAME) has not been found',
   },
   'ext-undefined-param-sec': {
-    std: 'Parameter $(ART) has not been found',
-    param: 'Artifact $(ART) has no parameter $(NAME)',
+    std: 'Parameter $(NAME) has not been found',
   },
 
   // annotation checks against their definition

package/lib/compiler/define.js

@@ -140,7 +140,6 @@ const {
   initDollarSelf,
   initDollarParameters,
   initBoundSelfParam,
-  storeExtension,
   dependsOnSilent,
   pathName,
   targetCantBeAspect,
@@ -178,7 +177,7 @@ function define( model ) {
   Object.assign( model.$functions, {
     shuffleDict,
     shuffleArray,
-    initArtifact,
+    initMainArtifact,
     initMembers,                // for finalize-parser-cdl.js
     targetIsTargetAspect,
     checkRedefinition,
@@ -213,7 +212,7 @@ function define( model ) {
     // Phase 2:
     for (const name of sourceNames)
       initNamespaceAndUsing( model.sources[name] );
-    dictForEach( model.definitions, initArtifact );
+    dictForEach( model.definitions, initMainArtifact );
     dictForEach( model.vocabularies, initVocabulary );
     dictForEach( model.$collectedExtensions, e => e._extensions.forEach( initExtension ) );
 
@@ -254,7 +253,7 @@ function define( model ) {
     if (src.$frontend !== 'json') { // CDL input
       // TODO: set _block to builtin
       if (src.artifacts) {
-        // addArtifact() adds usings to src.artifacts: shuffleDict must be assigned first
+        // addBlockArtifact() adds usings to src.artifacts: shuffleDict must be assigned first
         src.artifacts = shuffleDict( src.artifacts );
         addPathPrefixes( src.artifacts, prefix ); // before addUsing
       }
@@ -265,14 +264,14 @@ function define( model ) {
         shuffleArray( src.usings ).forEach( u => addUsing( u, src ) );
       if (namespace?.id)        // successfully set a full name for namespace
         addNamespace( namespace, src );
-      if (src.artifacts) {      // addArtifact needs usings for context extensions
+      if (src.artifacts) {      // addBlockArtifact needs usings for context extensions
         src.artifacts = shuffleDict( src.artifacts );
-        dictForEach( src.artifacts, a => addArtifact( a, src, prefix ) );
+        dictForEach( src.artifacts, a => addBlockArtifact( a, src, prefix ) );
       }
     }
     else if (src.definitions) {      // CSN input
       prefix = '';                   // also for addVocabulary() below
-      dictForEach( shuffleDict( src.definitions ), def => addDefinition( def, src, prefix ) );
+      dictForEach( shuffleDict( src.definitions ), def => addMainArtifact( def, src, prefix ) );
     }
     if (src.vocabularies) {
       if (!model.vocabularies)
@@ -284,7 +283,7 @@ function define( model ) {
     }
   }
 
-  function addDefinition( art, block, prefix ) {
+  function addMainArtifact( art, block, prefix ) {
     setLink( art, '_block', block );
     initExprAnnoBlock( art, block );
     art.name.id ??= prefix + pathName( art.name.path );
@@ -384,15 +383,15 @@ function define( model ) {
       $inferred: 'namespace',
     };
   }
-  function addArtifact( art, block, prefix ) {
+  function addBlockArtifact( art, block, prefix ) {
     if (art.kind === 'using')
       return;
-    addDefinition( art, block, prefix );
+    addMainArtifact( art, block, prefix );
     if (art.artifacts) {
       const p = `${ art.name.id }.`;
       // path prefixes (usings) must be added before extensions in artifacts:
       addPathPrefixes( art.artifacts, p );
-      dictForEach( art.artifacts, a => addArtifact( a, art, p ) );
+      dictForEach( art.artifacts, a => addBlockArtifact( a, art, p ) );
     }
     if (art.extensions) {       // requires using to be known!
       art.extensions.forEach( e => e.name && addExtension( e, art ) );
@@ -426,7 +425,7 @@ function define( model ) {
     // eslint-disable-next-line no-multi-assign
     ext.$effectiveSeqNo = model.$blocks[absolute] = (model.$blocks[absolute] || 0) + 1;
     const prefix = `${ absolute }.`;
-    dictForEach( ext.artifacts, a => addArtifact( a, ext, prefix ) );
+    dictForEach( ext.artifacts, a => addBlockArtifact( a, ext, prefix ) );
   }
 
   function addVocabulary( vocab, block, prefix ) {
@@ -484,7 +483,7 @@ function define( model ) {
   }
 
   // Phase 2 ("init"), top-level & main -----------------------------------------
-  // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
+  // Functions called from top-level: initNamespaceAndUsing(), initMainArtifact(),
   // initVocabulary(), initExtension()
 
   function initNamespaceAndUsing( src ) {
@@ -525,7 +524,7 @@ function define( model ) {
     }
   }
 
-  function initArtifact( art, reInit = false ) {
+  function initMainArtifact( art, reInit = false ) {
     if (!reInit)                // not for auto-exposed entity
       initArtifactParentLink( art, model.definitions );
     checkRedefinition( art );
@@ -608,7 +607,7 @@ function define( model ) {
   }
 
   // TODO: message ids
-  // Called by initArtifact() and initVocabulary() and for members
+  // Called by initMainArtifact() and initVocabulary() and for members
   function checkRedefinition( art ) {
     if (art.kind === 'annotate' || art.kind === 'extend') // move this check to call in extend.js?
       return; // extensions are merged into a super-annotate; $duplicates are only kept for LSP
@@ -983,9 +982,10 @@ function define( model ) {
           initExprForQuery( col.value, parent );
         if (col.expand || col.inline)
           initSelectItems( col, null, user ); // TODO: use col, remove 3rd param?
-      }
 
-      initCdlTypeCast( col, parent );
+        initMembers( col );      // with #13933, TODO: only for enums
+        checkCdlTypeCast( col );
+      }
     }
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
@@ -1038,13 +1038,7 @@ function define( model ) {
     return col.name.id;
   }
 
-  function initCdlTypeCast( col, parent ) {
-    if (col.val)
-      return; // e.g. '*' column
-
-    setMemberParent( col, col.name, parent );
-    initMembers( col );
-
+  function checkCdlTypeCast( col ) { // with #13933:
     // We don't allow CDL-style casts to anonymous structures.  We reject it already here
     // and not in checks.js to ensure that it's rejected in parseCdl.
     // TODO: via <guard> in CdlGrammar.g4
@@ -1052,7 +1046,7 @@ function define( model ) {
       error( 'type-invalid-cast', [ (col.elements[$location] ?? col.location), col ],
              { '#': 'to-inline-structure' } );
     }
-    else if (col.expand && (col.type || col.elements || col.items)) {
+    else if (col.expand && (col.type || col.items)) {
       const loc = (col.type?.location || col.elements?.[$location] ||
                    col.items?.location || col.location);
       error( 'type-invalid-cast', [ loc, col ], { '#': 'expand' } );
@@ -1068,7 +1062,7 @@ function define( model ) {
    *
    * Param `initExtensions` is for parse.cdl - TODO delete
    */
-  function initMembers( parent, initExtensions = false ) {
+  function initMembers( parent ) {
     const block = parent._block;
     let obj = initItemsLinks( parent, block );
     initExprAnnoBlock( parent, block );
@@ -1086,109 +1080,102 @@ function define( model ) {
         error( 'type-unexpected-on-condition', [ obj.on.location, parent ] );
         delete obj.on;          // continuation semantics: not specified
       }
-      if (targetAspect.elements)
-        initAnonymousAspect();
+      if (targetAspect.elements) // eslint-disable-next-line no-multi-assign
+        parent = obj = initAnonymousAspect( parent, obj, targetAspect );
     }
-    forEachInOrder( obj, 'elements', init );
-    forEachGeneric( obj, 'enum', init );
-    forEachInOrder( obj, 'foreignKeys', init );
-    forEachGeneric( parent, 'actions', init );
-    forEachInOrder( parent, 'params', init );
+    forEachInOrder( obj, 'elements', (...args) => initArtifact( parent, ...args ) );
+    forEachGeneric( obj, 'enum', (...args) => initArtifact( parent, ...args ) );
+    forEachInOrder( obj, 'foreignKeys', (...args) => initArtifact( parent, ...args ) );
+    forEachGeneric( parent, 'actions', (...args) => initArtifact( parent, ...args ) );
+    forEachInOrder( parent, 'params', (...args) => initArtifact( parent, ...args ) );
 
     const { returns } = parent;
     if (returns) {
       const { kind } = parent;
       returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
-      init( returns, '' );      // '' is special name for returns parameter
+      initArtifact( parent, returns, '' ); // '' is special name for returns parameter
     }
-    return;
-
-    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;
-      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 initAnonymousAspect( parent, obj, targetAspect ) {
+    // 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
+
+    targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+    setLink( targetAspect, '_block', parent._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;
     }
+    return 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 };
-        }
+  function initArtifact( parent, 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] );
       }
-      // 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;
+      else {                  // RETURNS, parser robustness
+        elem.name = { id: name, location: elem.location };
       }
+    }
 
-      const bl = elem._block || block;
-      setLink( elem, '_block', bl );
+    if (!elem._block)
+      setLink( elem, '_block', parent._block );
 
-      // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
-      setMemberParent( elem, name, parent );
-      checkRedefinition( elem );
-      initMembers( elem, initExtensions );
-      if (elem.kind === 'action' || elem.kind === 'function')
-        initBoundSelfParam( elem.params, elem._main );
+    // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
+    setMemberParent( elem, name, parent );
+    checkRedefinition( elem );
+    initMembers( elem );
+    if (elem.kind === 'action' || elem.kind === 'function')
+      initBoundSelfParam( elem.params, elem._main );
 
-      // for a correct home path, setMemberParent needed to be called
+    // 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.
-      // TODO: hm, only for inferred type - then just do not infer it in that case
-      if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
-        delete elem.type;
-        delete elem.on;
-        delete elem.target;
-      }
+    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.
+    // TODO: hm, only for inferred type - then just do not infer it in that case
+    if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
+      delete elem.type;
+      delete elem.on;
+      delete elem.target;
     }
   }
 

package/lib/compiler/extend.js

@@ -864,19 +864,18 @@ function extend( model ) {
     }
     else if (!dict?.[name]) {
       // TODO: make variant `returns` an auto-variant for ($ART) ?
-      const inReturns = parent._parent?.returns && parent._parent;
-      const art = inReturns || parent;
+      const inReturns = parent._parent?.returns;
       switch (prop) {
         case 'elements':
           if (canBeDraftMember( name, parent, draftElements ))
             break;
           notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
-                    { '#': (inReturns ? 'returns' : 'element'), art, name },
+                    { '#': (inReturns ? 'returns' : 'element'), name },
                     parent.elements );
           break;
         case 'enum':            // TODO: extra msg id?
           notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
-                    { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
+                    { '#': (inReturns ? 'enum-returns' : 'enum'), name },
                     parent.enum );
           break;
         case 'foreignKeys':
@@ -885,14 +884,14 @@ function extend( model ) {
           break;
         case 'params':
           notFound( `ext-undefined-param${ securityRelevant }`, ext.name.location, ext,
-                    { '#': 'param', art: parent, name },
+                    { '#': 'param', name },
                     parent.params );
           break;
         case 'actions':
           if (canBeDraftMember( name, parent, draftBoundActions ))
             break;
           notFound( `ext-undefined-action${ securityRelevant }`, ext.name.location, ext,
-                    { '#': 'action', art: parent, name },
+                    { '#': 'action', name },
                     parent.actions );
           break;
         default:
@@ -1213,11 +1212,9 @@ function extend( model ) {
    *
    * If not for extensions: construct === parent
    *
-   * Param `initExtensions` is for parse.cdl - TODO delete
-   *
    * TODO: separate extension!
    */
-  function initMembers( construct, parent, block, initExtensions = false ) {
+  function initMembers( construct, parent, block ) {
     // TODO: split extend from init
     const main = parent._main || parent;
     const isQueryExtension = construct.kind === 'extend' && main.query;
@@ -1347,9 +1344,12 @@ function extend( model ) {
           elem.name = { id: name, location: elem.location };
         }
       }
+
+      if (!elem._block)
+        setLink( elem, '_block', block );
       // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
-      if ((elem.kind === 'extend' || elem.kind === 'annotate') && !initExtensions) {
-        storeExtension( elem, name, prop, parent, block );
+      if ((elem.kind === 'extend' || elem.kind === 'annotate')) {
+        storeExtension( elem, name, prop, parent );
         return;
       }
       if (isQueryExtension && elem.kind === 'element') {
@@ -1359,8 +1359,6 @@ function extend( model ) {
         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 {} };`:
@@ -1368,7 +1366,7 @@ function extend( model ) {
         elem.$duplicates = null;
       setMemberParent( elem, name, parent, add && prop );
       checkRedefinition( elem );
-      initMembers( elem, elem, bl, initExtensions );
+      initMembers( elem, elem, elem._block );
       if (elem.kind === 'action' || elem.kind === 'function')
         initBoundSelfParam( elem.params, elem._main );
 
@@ -1514,7 +1512,7 @@ function extend( model ) {
    * Sets `_ancestors` links on `art`.
    *
    * TODO: try to set `_ancestors` only to entities (but beware “intermediate”
-   * non-entities).
+   * non-entities - TODO: make intermediate non-entities stop chain).
    *
    * Examples:
    *   ext === art:  `entity E : F {}`  => add elements of F to E

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, true );
+        initMembers( ext );
         extensions.push( ext );
       }
     }

package/lib/compiler/generate.js

@@ -31,7 +31,7 @@ function generate( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
-    initArtifact,
+    initMainArtifact,
     extendArtifactBefore,
     applyIncludes,
   } = model.$functions;
@@ -340,7 +340,7 @@ function generate( model ) {
     for (const orig of textElems)
       addElementToTextsEntity( orig, art, fioriEnabled, assertUniqueValue );
 
-    initArtifact( art );
+    initMainArtifact( art );
     if (art.includes) {
       // add elements `locale`, etc. which are required below.
       applyIncludes( art, art ); // TODO: rethink - can we avoid this if only new extend?
@@ -641,7 +641,7 @@ function generate( model ) {
              'An aspect $(TARGET) with an element named $(NAME) can\'t be used as target' );
       return false;
     }
-    if (model.definitions[entityName]) {
+    if (model.definitions[entityName]) { // TODO: allow a gap (namespace)?
       error( null, [ location, elem ], { art: entityName },
              // eslint-disable-next-line @stylistic/max-len
              'Target entity $(ART) can\'t be created as there is another definition with this name' );
@@ -742,7 +742,7 @@ function generate( model ) {
 
     setLink( art, '_block', model.$internal );
     model.definitions[entityName] = art;
-    initArtifact( art );
+    initMainArtifact( art );
 
     // Apply annotations to generated artifact, prepare (not apply!) element
     // annotations (remark: adding elements is not allowed for generated artifacts):

package/lib/compiler/kick-start.js

@@ -32,6 +32,9 @@ function kickStart( model ) {
    *  - service: the artifact of the embedding service
    * This function must be called ordered: parent first
    *
+   * Remark: _service links are not already set in define.js, because we might
+   * have a @cds.redirection.service in the future
+   *
    * @param {string} name Artifact name
    */
   function setAncestorsAndService( name ) {
@@ -50,16 +53,12 @@ function kickStart( model ) {
       return;
     // To be removed when nested services are allowed
     if (!isBetaEnabled( options, 'nestedServices' ) && art.kind === 'service') {
-      while (parent.kind !== 'service')
-        parent = parent._parent;
-      message( 'service-nested-service', [ art.name.location, art ], { art: parent },
+      message( 'service-nested-service', [ art.name.location, art ], { art: service },
                'A service can\'t be nested within a service $(ART)' );
     }
     else if (art.kind === 'context') {
-      while (parent.kind !== 'service')
-        parent = parent._parent;
       // TODO: remove this error
-      message( 'service-nested-context', [ art.name.location, art ], { art: parent },
+      message( 'service-nested-context', [ art.name.location, art ], { art: service },
                'A context can\'t be nested within a service $(ART)' );
     }
   }
@@ -73,7 +72,9 @@ function kickStart( model ) {
     // Service1.E = projection on E
 
     // Remark: _ancestors are also set with includes, and there also for aspects,
-    // types and events.
+    // types and events (TODO: entity only)
+    //
+    // Remark: _ancestors are also tested in populate.js for minmal exposure
     const chain = [];
     const autoexposed = annotationVal( art['@cds.autoexposed'] );
     // no need to set preferredRedirectionTarget in the while loop as we would

package/lib/compiler/populate.js

@@ -75,7 +75,7 @@ function populate( model ) {
     resolvePath,
     nestedElements,
     attachAndEmitValidNames,
-    initArtifact,
+    initMainArtifact,
     extendArtifactBefore,
     extendArtifactAfter,
   } = model.$functions;
@@ -1113,9 +1113,7 @@ function populate( model ) {
   // To avoid repeated messages: if already tried to do autoexposure, return
   // auto-exposed entity when successful, or `target` otherwise (no/failed autoexposure)
   function minimalExposure( target, service, elemScope ) {
-    const descendants = scopedExposure( target._descendants &&
-                                        target._descendants[service.name.id] ||
-                                        [],
+    const descendants = scopedExposure( target._descendants?.[service.name.id] || [],
                                         elemScope, target );
     const preferred = descendants.filter( d => annotationVal( d['@cds.redirection.target'] ) );
     const exposed = preferred.length ? preferred : descendants;
@@ -1172,7 +1170,7 @@ function populate( model ) {
       kind: 'namespace', name: { id: autoScopeName, location }, location,
     };
     model.definitions[autoScopeName] = nullScope;
-    initArtifact( nullScope );
+    initMainArtifact( nullScope );
     return nullScope;
   }
 
@@ -1207,7 +1205,6 @@ 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 - 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 );
@@ -1354,7 +1351,7 @@ function populate( model ) {
     }
     setLink( art, '_service', service );
     setLink( art, '_block', model.$internal );
-    initArtifact( art, !!autoexposed );
+    initMainArtifact( art, !!autoexposed );
     effectiveType( art );
     // TODO: try to set locations of elements locations of orig target elements
     newAutoExposed.push( art );

package/lib/compiler/resolve.js

@@ -1669,7 +1669,8 @@ function resolve( model ) {
     }
     const symbols = type && type.enum;
     if (!symbols) {
-      if (user.kind !== '$annotation') { // TODO: better type deduction for annotations
+      if ((user.kind ?? user._outer?.kind) !== '$annotation') {
+        // TODO: better type deduction for annotations
         const msg = (user.kind === 'enum') ? 'symbolDef' : type && 'invalidType';
         warning( 'ref-unexpected-enum', [ expr.location, user ],
                  { '#': msg || 'untyped', enum: sym.id, type: type || '' } );

package/lib/compiler/utils.js

@@ -285,10 +285,9 @@ function dependsOnSilent( user, art ) {
   user._deps.push( { art } );
 }
 
-function storeExtension( elem, name, prop, parent, block ) {
+function storeExtension( elem, name, prop, parent ) {
   if (prop === 'enum')
     prop = 'elements';
-  setLink( elem, '_block', block );
   const kind = `_${ elem.kind }`; // _extend or _annotate
   if (!parent[kind])
     setLink( parent, kind, {} );

package/lib/model/csnRefs.js

@@ -245,9 +245,10 @@ const referenceSemantics = {
   inline: { lexical: justDollar, dynamic: 'inline' },   // ...using baseEnv
   ref_where: { lexical: justDollar, dynamic: 'ref-target' }, // ...using baseEnv
   on: { lexical: justDollar, dynamic: 'query' }, // assoc defs, redirected to
+  // there are also 'on_join' and 'on_mixin' with default semantics
+  $calc: { lexical: justDollar, dynamic: 'query' }, // calculation for draft
   annotation: { lexical: justDollar, dynamic: 'query' }, // anno top-level `ref`
   annotationExpr: { lexical: justDollar, dynamic: 'query' }, // annotation assignment
-  // there are also 'on_join' and 'on_mixin' with default semantics
   orderBy_ref: { lexical: query => query, dynamic: 'query' },
   orderBy_expr: { lexical: query => query, dynamic: 'source' }, // ref in ORDER BY expression
   orderBy_set_ref: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
@@ -1075,6 +1076,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     if (refCtx === 'annotation' && typeof obj === 'object') {
       // we do not know yet whether the annotation value is an expression or not →
       // loop over outer array and records (structure values):
+      // TODO: add test → `@(A: [{target: ($user)}])` on query column
       if (Array.isArray( obj ) || !isAnnotationExpression( obj )) {
         obj = obj[prop];
         continue;
@@ -1164,6 +1166,9 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     else if (prop[0] === '@') {
       refCtx = 'annotation';
     }
+    else if (prop === '$calc') {
+      refCtx = '$calc';
+    }
     else if (prop !== 'xpr' && prop !== 'list') {
       // 'xpr' and 'list' do not change the ref context, all other props do:
       refCtx = prop;

package/lib/render/toSql.js

@@ -1294,11 +1294,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
-      // If the whole SET has an ORDER BY/LIMIT, wrap the part before that in parentheses
-      // (otherwise some SQL implementations (e.g. sqlite) would interpret the ORDER BY/LIMIT as belonging
-      // to the last SET argument, not to the whole SET)
       if (query.SET.orderBy || query.SET.limit) {
-        result = `(${ result })`;
         if (query.SET.orderBy) {
           const orderBy = query.SET.orderBy.map(entry => renderOrderByEntry(entry, env.withSubPath([ 'orderBy' ]))).join(', ');
           result += `\n${ env.indent }ORDER BY ${ orderBy }`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "6.5.0",
+  "version": "6.5.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",