@sap/cds-compiler 4.4.2 → 4.5.0

package/lib/json/from-csn.js

@@ -376,7 +376,7 @@ const schema = compileSchema( {
     type: object,
     optional: [ 'src', 'min', 'max' ],
     inKind: [ 'element', 'type', 'mixin' ],
-    onlyWith: [ 'target', 'targetAspect', 'id' ], // also in 'ref[]'
+    onlyWith: [ 'target', 'targetAspect', 'where' ], // also in 'ref[]'
   },
   items: {
     type: object,
@@ -1325,14 +1325,13 @@ function stringValOrNull( val, spec ) {
 
 function scalenum( val, spec ) {
   if ([ 'floating', 'variable' ].includes(val))
-    return { val, literal: 'string', location: location() };
+    return { val, literal: 'string', location: location() }; // XSN TODO: remove `literal`
   return natnum(val, spec );
 }
 
 function natnum( val, spec ) {
   if (typeof val === 'number' && val >= 0 && Number.isSafeInteger( val ))
-    //  XSN TODO: do not require literal
-    return { val, literal: 'number', location: location() };
+    return { val, location: location() };
   const loc = location(true);
   error( 'syntax-expecting-unsigned-int', loc,
          { '#': spec.msgVariant || 'csn', prop: spec.msgProp, op: '*' } );
@@ -1342,7 +1341,7 @@ function natnum( val, spec ) {
 // Use with spec.msgVariant !
 function natnumOrStar( val, spec ) {
   return (val === '*')
-    ? { val, literal: 'string', location: location() }
+    ? { val, location: location() }
     : natnum( val, spec );
 }
 

package/lib/json/to-csn.js

@@ -14,7 +14,7 @@
 const { locationString } = require('../base/messages');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { pathName } = require('../compiler/utils');
-const { CompilerAssertion } = require('../base/error');
+const { CompilerAssertion, ModelError } = require('../base/error');
 
 const compilerVersion = require('../../package.json').version;
 const creator = `CDS Compiler v${ compilerVersion }`;
@@ -93,6 +93,7 @@ const transformers = {
   cardinality,                 // also in pathItem: after 'id', before 'where'
   targetAspect,
   target,
+  $filtered: value,            // assoc+filter
   foreignKeys,
   enum: enumDict,
   items,
@@ -305,8 +306,14 @@ function csnDictionary( csn, sort, cloneOptions = false ) {
     ? proto
     : (proto) ? Object.prototype : null;
   const r = Object.create( dictProto );
-  for (const n of (sort) ? Object.keys(csn).sort() : Object.keys(csn))
-    r[n] = sortCsn( csn[n], cloneOptions );
+  for (const n of (sort) ? Object.keys(csn).sort() : Object.keys(csn)) {
+    // CSN does not allow any dictionary that are not objects.
+    // The compiler handles it, but a pre-transformed OData CSN won't trigger recompilation.
+    if (csn[n] && typeof csn[n] === 'object')
+      r[n] = sortCsn(csn[n], cloneOptions);
+    else
+      throw new ModelError(`Found non-object dictionary entry: "${ n }" of type "${ typeof csn[n] }"`);
+  }
 
   return r;
 }
@@ -1176,6 +1183,18 @@ function args( node ) {
 }
 
 function anno( node ) {
+  if (!node)
+    return true;                // `@aBool` short for `@aBool: true`
+  if (universalCsn && node.$inferred) {
+    // TODO: return undefined for all values of node.$inferred (except 'NULL')?
+    if (node.$inferred === 'prop' || node.$inferred === '$generated' || // via propagator.js
+        node.$inferred === 'parent-origin')
+      return undefined;
+    else if (node.$inferred === 'NULL')
+      return null;
+  }
+  if (node.$inferred && gensrcFlavor)
+    return undefined;
   if (node.$tokenTexts) // expressions in annotation values
     return Object.assign({ '=': node.$tokenTexts }, expression( node ));
   return value(node);

package/lib/language/errorStrategy.js

@@ -524,10 +524,14 @@ function getTokenDisplay( token, recognizer ) {
   if (!token)
     return '<EOF>';
   const t = token.type;
-  if (t === antlr4.Token.EOF || t === antlr4.Token.EPSILON )
+  if (t === antlr4.Token.EOF || t === antlr4.Token.EPSILON ) {
     return '<EOF>';
-  else if (token.text === '.')  // also for DOTbeforeBRACE
-    return "'.'";
+  }
+  else if (t === recognizer.constructor.DOTbeforeBRACE) {
+    if (recognizer.getTokenStream().LT(2).text === '{')
+      return "'.{'";
+    return "'.*'";
+  }
   return recognizer.literalNames[t] || recognizer.symbolicNames[t];
 }
 

package/lib/language/genericAntlrParser.js

@@ -8,6 +8,7 @@
 
 const antlr4 = require('antlr4');
 const { ATNState } = require('antlr4/src/antlr4/atn/ATNState');
+const { DEFAULT: CommonTokenFactory } = require('antlr4/src/antlr4/CommonTokenFactory');
 const { dictAdd, dictAddArray } = require('../base/dictionaries');
 const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
@@ -23,7 +24,7 @@ const {
 } = require('../compiler/classes');
 const { isBetaEnabled } = require('../base/model');
 const { weakLocation } = require('../base/location');
-const { normalizeNewLine } = require('./textUtils');
+const { normalizeNewLine, normalizeNumberString } = require('./textUtils');
 
 const $location = Symbol.for('cds.$location');
 
@@ -107,6 +108,8 @@ Object.assign(GenericAntlrParser.prototype, {
   fixNewKeywordPlacement,
   signedExpression,
   numberLiteral,
+  unsignedIntegerLiteral,
+  assignAnnotationValue,
   quotedLiteral,
   pathName,
   docComment,
@@ -117,13 +120,14 @@ Object.assign(GenericAntlrParser.prototype, {
   createDict,
   createArray,
   finalizeDictOrArray,
-  createPrefixOp,
+  insertSemicolon,
   setMaxCardinality,
   setNullability,
   reportDuplicateClause,
   reportUnexpectedExtension,
   reportUnexpectedSpace,
   pushIdent,
+  pushItem,
   handleComposition,
   associationInSelectItem,
   reportExpandInline,
@@ -911,10 +915,6 @@ function expressionAsAnnotationValue( assignment, cond ) {
     return;
   Object.assign(assignment, cond.cond);
   assignment.$tokenTexts = this.tokensToStringRepresentation(cond);
-  if (!this.isBetaEnabled(this.options, 'annotationExpressions')) {
-    this.error( 'syntax-unsupported-expression', [ cond.cond.location ], {},
-                'Expressions in annotation values are not supported' );
-  }
 }
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
@@ -941,12 +941,27 @@ function signedExpression( args, expr ) {
   }
 }
 
-// Return AST for number token `token` with optional token `sign`.  Represent
-// the number as number in property `val` if the number can safely be
-// represented as an integer.  Otherwise, represent the number by a string, the
-// token lexeme.
-function numberLiteral( token, sign, text = token.text ) {
+/**
+ * Return number literal (XSN) for number token `token` with optional token `sign`.
+ * Represent the number as a JS number in property `val` if the number can safely be
+ * represented as one.  Represent the number by a string, the token lexeme, if the
+ * stringified version of the number does not match the token lexeme.
+ *
+ * TODO: Always use text !== `${ num }`
+ */
+function numberLiteral( sign, text = this._input.LT(-1).text ) {
+  const token = this._input.LT(-1);
   let location = this.tokenLocation( token );
+  const nextToken = this._input.LT(1);
+  if (token.type === this.constructor.Number &&
+      token.stop + 1 === nextToken.start &&
+      (nextToken.type === this.constructor.Identifier ||
+       nextToken.type < this.constructor.Identifier && /^[a-z]+$/i.test( nextToken.text ))) {
+    // TODO: Make it an error in v5
+    this.warning('syntax-expecting-space', nextToken, {},
+                 'Expecting a space between a number and a keyword/identifier');
+  }
+
   if (sign) {
     const { endLine, endCol } = location;
     location = this.startLocation( sign );
@@ -957,17 +972,65 @@ function numberLiteral( token, sign, text = token.text ) {
   }
 
   const num = Number.parseFloat( text || '0' ); // not Number.parseInt() !
+  const normalized = normalizeNumberString(text);
+  if (normalized !== `${ num }` && normalized !== `${ sign.text }${ num }`)
+    return { literal: 'number', val: normalized, location };
+  return { literal: 'number', val: num, location };
+}
+
+/**
+ * Given `token`, return a number literal (XSN).  If the number is not an unsigned integer
+ * or it can't be represented in JS, emit an error.
+ */
+function unsignedIntegerLiteral() {
+  const token = this._input.LT(-1);
+  const location = this.tokenLocation( token );
+  const text = token.text || '0';
+  const num = Number.parseFloat( text ); // not Number.parseInt() !
   if (!Number.isSafeInteger(num)) {
-    if (sign == null) {
-      this.error( 'syntax-expecting-unsigned-int', token,
-                  { '#': !text.match(/^\d*$/) ? 'normal' : 'unsafe' } );
-    }
+    this.error( 'syntax-expecting-unsigned-int', token,
+                { '#': !text.match(/^\d*$/) ? 'normal' : 'unsafe' } );
+  }
+  else if (text.match(/^\d+[.]\d+$/)) {
+    // More restrictive check: 10.0 emits a message, because we don't expect
+    // any decimal places.
+    const dotLoc = { ...location };
+    dotLoc.col += text.indexOf('.');
+    dotLoc.endCol = dotLoc.col + 1;
+    this.info( 'syntax-ignoring-decimal', dotLoc );
+  }
+  return { literal: 'number', val: num, location };
+}
 
-    else if (text !== `${ num }`) {
-      return { literal: 'number', val: text, location };
+// Make the annotation `anno` have `value` as value.  This function is basically
+// just `Object.assign`, but we really try to represent the provided CDL number as
+// JSON number.  We give a warning if this is not possible or leads to a precision
+// loss.
+function assignAnnotationValue( anno, value ) {
+  const { val } = value;
+  if (value.literal === 'number' && typeof val !== 'number') {
+    // a number in CDL, but stored as string in `val` - due to rounding or scientific notation
+    let num = Number.parseFloat( val || '0' );
+    const inf = !Number.isFinite( num );
+    if (inf)
+      num = val;
+    if (inf || relevantDigits( val ) !== relevantDigits( num.toString() )) {
+      this.warning( 'syntax-invalid-anno-number', value.location,
+                    { '#': (inf ? 'infinite' : 'rounded' ), rawvalue: val, value: num },
+                    {
+                      std: 'Annotation number $(RAWVALUE) is put as $(VALUE) into the CSN',
+                      rounded: 'Annotation number $(RAWVALUE) is rounded to $(VALUE)',
+                      // eslint-disable-next-line max-len
+                      infinite: 'Annotation value $(RAWVALUE) is infinite as number and put as string into the CSN',
+                    } );
     }
+    value.val = num;
   }
-  return { literal: 'number', val: num, location };
+  Object.assign( anno, value );
+}
+
+function relevantDigits( val ) {
+  return val.replace( /0*(e.+)?$/i, '' ).replace( /\./, '' ).replace( /^[-+0]+/, '' );
 }
 
 // Create AST node for quoted literals like string and e.g. date'2017-02-22'.
@@ -1036,6 +1099,16 @@ function pushIdent( path, ident, prefix ) {
   }
 }
 
+function pushItem( array, val ) {
+  if (!array)
+    return;
+
+  if (val != null)
+    array.push(val);
+  else
+    array.broken = true;
+}
+
 // For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths
 function reportUnexpectedSpace( prefix = this._input.LT(-1),
                                 location = this.tokenLocation( this._input.LT(1) ) ) {
@@ -1173,14 +1246,37 @@ function finalizeDictOrArray( dict ) {
   loc.endCol = stop.stop - stop.start + stop.column + 2;
 }
 
-function createSource() {
-  return new XsnSource();
+function insertSemicolon() {
+  // hand-selected keyword list: first() set of `artifactDefOrExtend`
+  const allowedKeywords = [ this.constructor.ACTION, this.constructor.ABSTRACT,
+    this.constructor.ANNOTATE, this.constructor.ANNOTATION, this.constructor.ASPECT,
+    this.constructor.CONTEXT, this.constructor.DEFINE, this.constructor.ENTITY,
+    this.constructor.EOF, this.constructor.EVENT, this.constructor.EXTEND,
+    this.constructor.FUNCTION, this.constructor.SERVICE,
+    this.constructor.TYPE, this.constructor.VIEW, this.literalNames.indexOf( "'@'" ) ];
+
+  const currentToken = this._input.tokens[this._input.index];
+
+  if (allowedKeywords.includes(currentToken.type)) {
+    const prev = this._input.LT(-1);
+    const t = CommonTokenFactory.create(
+      currentToken.source, this.literalNames.indexOf( "';'" ),
+      '', currentToken.channel,
+      prev.stop, prev.stop,
+      prev.line, prev.column
+    );
+    t.tokenIndex = prev.tokenIndex + 1;
+    this._input.tokens.splice(t.tokenIndex, 0, t);
+
+    // Update tokenIndex: There could have been comments between two non-hidden tokens.
+    for (let tokenIndex = t.tokenIndex + 1; tokenIndex < this._input.tokens.length; tokenIndex++)
+      this._input.tokens[tokenIndex].tokenIndex += 1;
+    this._input.index = t.tokenIndex;
+  }
 }
 
-// Create AST node for prefix operator `op` and arguments `args`
-function createPrefixOp( token, args ) {
-  const op = this.valueWithTokenLocation( token.text.toLowerCase(), token );
-  return { op, args, location: this.combinedLocation( op, args[args.length - 1] ) };
+function createSource() {
+  return new XsnSource();
 }
 
 // Create AST node for binary operator `op` and arguments `args`

package/lib/language/textUtils.js

@@ -49,9 +49,25 @@ function normalizeNewLine( str ) {
   return str.replace(new RegExp(cdlNewLineRegEx, 'ug'), '\n');
 }
 
+/**
+ * Normalizes the given number (as a string):
+ *
+ *  - removes leading zeroes (`0`) to avoid accidental octal-conversion
+ *
+ * @param {string} str
+ * @return {string}
+ */
+function normalizeNumberString( str ) {
+  const num = str.replace(/^([+-]?)0+(\d)/, '$1$2');
+  if (!num.includes('.'))
+    return num;
+  return num.replace(/([.]\d)0+$/, '$1');
+}
+
 module.exports = {
   isWhitespaceOrNewLineOnly,
   isWhitespaceCharacterNoNewline,
   cdlNewLineRegEx,
   normalizeNewLine,
+  normalizeNumberString,
 };

package/lib/model/csnUtils.js

@@ -1098,7 +1098,7 @@ function copyAnnotations( fromNode, toNode, overwrite = false, excludes = {} ) {
 
   for (const anno of annotations) {
     if ((toNode[anno] === undefined || overwrite) && !excludes[anno])
-      toNode[anno] = fromNode[anno];
+      toNode[anno] = cloneAnnotationValue(fromNode[anno]);
   }
 }
 
@@ -1118,13 +1118,9 @@ function copyAnnotationsAndDoc( fromNode, toNode, overwrite = false ) {
   if (!toNode)
     return;
 
-  const annotations = Object.keys(fromNode)
-    .filter(key => key.startsWith('@') || key === 'doc');
-
-  for (const anno of annotations) {
-    if (toNode[anno] === undefined || overwrite)
-      toNode[anno] = fromNode[anno];
-  }
+  copyAnnotations(fromNode, toNode, overwrite);
+  if (toNode.doc === undefined || overwrite)
+    toNode.doc = fromNode.doc;
 }
 
 /**
@@ -1449,6 +1445,10 @@ function isAssociationOperand( arg, path, inspectRef ) {
   return art && art.target !== undefined;
 }
 
+function pathName( ref ) {
+  return ref ? ref.map( id => id?.id || id ).join( '.' ) : '';
+}
+
 module.exports = {
   getUtils,
   cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
@@ -1496,4 +1496,5 @@ module.exports = {
   cardinality2str,
   isAssociationOperand,
   isDollarSelfOrProjectionOperand,
+  pathName,
 };

package/lib/model/revealInternalProperties.js

@@ -321,8 +321,11 @@ function artifactIdentifier( node, parent ) {
     Object.defineProperty( node, '__unique_id__', { value: uniqueId-- } );
   const outerNum = node.$effectiveSeqNo || node.__unique_id__;
   let outer = outerNum != null ? `##${ outerNum }` : '';
-  if (node._outer) {            // anon aspect in targetAspect | items
-    outer = (node._outer.targetAspect === node) ? `/target${ outer }` : `/items${ outer }`;
+  if (node._outer) { // anon aspect in targetAspect | items | $calcDepElement
+    outer = (node.kind === '$annotation')
+    // eslint-disable-next-line prefer-template
+      ? `/${ quoted( '@' + node.name.id ) }`
+      : `/${ node.kind || 'items' }${ outer }`;
     node = node._outer;
   }
   if (node === parent)

package/lib/modelCompare/compare.js

@@ -190,7 +190,7 @@ function getExtensionAndMigrations(beforeModel, options, { extensions, migration
         migration.change = changedElements;
         if(!hasPrimaryKeyChange)
           forEach(changedElements, (_name, change) => {
-            if((change.old.key || change.new.key) && !change.new.target && !change.old.target) {
+            if(!change.onlyDoc && (change.old.key || change.new.key) && !change.new.target && !change.old.target) {
               // For to.hdi.migration: Just drop-create (commented out), for to.sql.migration: Handle case where we add/remove "key" keyword, no drop-create otherwise
               if(options.sqlDialect === 'hana' && options.src === 'hdi' || (!change.old.key || !change.new.key)) {
                 hasPrimaryKeyChange = true;
@@ -276,6 +276,8 @@ function getElementComparator(otherArtifact, addedElementsDict = null, changedEl
           element.$notNull = false; // Explicitly set notNull to the implicit default so we render the correct ALTER
         }
         changedElementsDict[name] = changedElement(element, otherElement);
+      } else if(docCommentChanged(element, otherElement)) {
+        changedElementsDict[name] = { ...changedElement(element, otherElement), onlyDoc: true };
       }
 
       return;
@@ -356,6 +358,9 @@ function deepEqual(a, b, include = () => true, depth = 0) {
       : a === b;
 }
 
+function docCommentChanged(element, otherElement) {
+  return element.doc && !otherElement.doc || otherElement.doc && !element.doc || element.doc && element.doc !== otherElement.doc;
+}
 
 const relevantProperties = {
   'doc': true,
@@ -364,7 +369,8 @@ const relevantProperties = {
 };
 
 /**
- * Returns whether any type parameters differ between two given elements. Ignores whether types themselves differ (`type` property).
+ * Returns whether any type parameters differ between two given elements. Ignores whether types themselves differ (`type` property) and ignores
+ * diff in doc comments.
  * @param element {object} an element
  * @param otherElement {object} another element
  * @returns {boolean}
@@ -373,7 +379,7 @@ function typeParametersChanged(element, otherElement) {
   const checked = new Set();
   for (const key in element) {
     if (Object.prototype.hasOwnProperty.call(element, key))
-      if((!key.startsWith('@') || relevantProperties[key]) && key !== 'type') {
+      if((!key.startsWith('@') || relevantProperties[key]) && key !== 'type' && key !== 'doc') {
         checked.add(key);
         if(!deepEqual(element[key], otherElement[key]))
           return true;
@@ -382,7 +388,7 @@ function typeParametersChanged(element, otherElement) {
 
   for (const key in otherElement) {
     if (Object.prototype.hasOwnProperty.call(otherElement, key))
-      if((!key.startsWith('@') || relevantProperties[key]) && key !== 'type' && !checked.has(key))
+      if((!key.startsWith('@') || relevantProperties[key]) && key !== 'type' &&  key !== 'doc' && !checked.has(key))
         return true;
   }
 

package/lib/optionProcessor.js

@@ -227,7 +227,6 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-foreign-keys')
   .option('    --odata-v2-partial-constr')
   .option('    --odata-vocabularies <list>')
-  .option('    --odata-open-type')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', ['flat', 'structured'])
   .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
@@ -260,7 +259,6 @@ optionProcessor.command('O, toOdata')
                                    (Not spec compliant and V2 only)
        --odata-vocabularies <list> JSON array of adhoc vocabulary definitions
                                    { prefix: { alias, ns, uri }, ... }
-       --odata-open-type        Renders all structured types as OpenType=true, if not annotated otherwise.
    -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toHana or "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores
@@ -305,6 +303,7 @@ optionProcessor.command('Q, toSql')
   .option('    --generated-by-comment')
   .option('    --better-sqlite-session-variables')
   .option('    --fewer-localized-views')
+  .option('    --without-hana-associations')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -360,7 +359,7 @@ optionProcessor.command('Q, toSql')
                               active if sqlDialect is \`sqlite\`
    --fewer-localized-views    If set, the backends will not create localized convenience views for
                               those views, that only have an association to a localized entity/view.
-
+   --without-hana-associations   If set, the backend will not render a "WITH ASSOCIATIONS" for sqlDialect 'hana'
 `);
 
 optionProcessor.command('toRename')

package/lib/render/toCdl.js

@@ -11,7 +11,7 @@ const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnrich
 const { isBetaEnabled } = require('../base/model');
 const { ModelError } = require('../base/error');
 const { makeMessageFunction } = require('../base/messages.js');
-const { typeParameters, specialFunctions } = require('../compiler/builtins');
+const { typeParameters, specialFunctions, xprInAnnoProperties } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
 const {
   isBuiltinType,
@@ -589,11 +589,11 @@ function csnToCdl( csn, options ) {
    * @param {CdlRenderEnvironment} env
    */
   function renderElement( elementName, element, env ) {
+    const isCalcElement = (element.value !== undefined);
     let result = renderAnnotationAssignmentsAndDocComment(element, env);
     result += env.indent;
     result += element.virtual ? 'virtual ' : '';
     result += element.key ? 'key ' : '';
-    // TODO(v5): Remove once deprecated flag for `masked` is removed.
     result += element.masked ? 'masked ' : '';
     result += quoteNonIdentifierOrKeyword(elementName, env);
     if (element.val !== undefined) { // enum value
@@ -602,13 +602,16 @@ function csnToCdl( csn, options ) {
     else if (element['#'] !== undefined) { // enum symbol reference
       result += ` = #${element['#']}`;
     }
-    else {
+    else if (!isCalcElement || !isDirectAssocOrComp(element.type)) {
+      // If the element is a calculated element _and_ a direct association or
+      // composition, we'd render `Association to F on (cond) = calcValue;` which
+      // would alter the ON-condition.
       const props = renderTypeReferenceAndProps(element, env);
       if (props !== '')
         result += ` : ${props}`;
     }
 
-    if (element.value !== undefined) { // calculated element // @ts-ignore
+    if (isCalcElement) { // calculated element // @ts-ignore
       result += ' = ';
       if (element.value.xpr && xprContainsCondition(element.value.xpr))
         result += exprRenderer.renderSubExpr(element.value, env.withSubPath([ 'value' ]));
@@ -873,7 +876,7 @@ function csnToCdl( csn, options ) {
       //       of an `annotate` statement.  That may change in the future.
       result += renderDocComment(element, env);
     }
-    // Note: parentheses are a workaround for #9015
+    // Note: parentheses are a workaround for #9015; TODO: Check & Update
     result += renderAnnotationAssignmentsAndDocComment(col, env, { parentheses: true });
     result += env.indent;
 
@@ -1316,7 +1319,7 @@ function csnToCdl( csn, options ) {
     }
 
     // Association type
-    if (type === 'cds.Association' || type === 'cds.Composition') {
+    if (isDirectAssocOrComp(type)) {
       const isComp = type === 'cds.Composition';
       // Type, cardinality and target; CAPire uses CamelCase
       result += isComp ? 'Composition' : 'Association';
@@ -1460,10 +1463,7 @@ function csnToCdl( csn, options ) {
    * @param {CdlRenderEnvironment} env
    */
   function renderAnnotationValue( annoValue, env ) {
-    // TODO: There must be at least one known expression property, otherwise
-    //       it could be `type: 'unchecked'`.
-    const isXpr = annoValue?.['='] !== undefined && (Object.keys(annoValue).length > 1) &&
-        isBetaEnabled(options, 'annotationExpressions');
+    const isXpr = annoValue?.['='] !== undefined && xprInAnnoProperties.some(xProp => annoValue[xProp] !== undefined);
     if (isXpr) {
       // Once inside an expression, we stay there.
       const xpr = exprRenderer.renderExpr(annoValue, env);
@@ -1852,7 +1852,7 @@ function csnToCdl( csn, options ) {
     name = name.substring(1);
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
-    const nameBeforeVariant = parts[0];
+    let nameBeforeVariant = parts[0];
     const variant = parts.length > 1 ? parts.slice(1).join('#') : undefined;
     const { parentheses } = config;
 
@@ -1860,8 +1860,13 @@ function csnToCdl( csn, options ) {
     if (parentheses)
       result += '(';
 
+    // if the variant is empty, render '#' as part of the name, e.g `variant !== undefined`.
+    if (variant === '')
+      nameBeforeVariant += '#';
+
     result += quoteAnnotationPathIfRequired(nameBeforeVariant, env);
-    if (variant !== undefined) {
+
+    if (variant !== undefined && variant !== '') {
       // Unfortunately, the compiler does not allow `.@` after the first variant identifier,
       // nor multiple `#`, so we're back at simple paths that are possibly quoted.
       result += `#${quotePathIfRequired(variant, env)}`;
@@ -1939,7 +1944,7 @@ function csnToCdl( csn, options ) {
       aliasOnly: x => x.as,
       enum: x => `#${x['#']}`,
       ref(x) {
-        return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
+        return `${x.param ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
       },
       windowFunction(x) {
         const funcDef = this.func(x);
@@ -2182,6 +2187,19 @@ function requiresQuotingForCdl( id, additionalKeywords ) {
     additionalKeywords.includes(id.toUpperCase());
 }
 
+/**
+ * Returns true if the given type is an association or composition,
+ * without type indirection.
+ *
+ * @param {string|string[]} type
+ * @return {boolean}
+ */
+
+function isDirectAssocOrComp( type ) {
+  type = normalizeTypeRef(type);
+  return (type === 'cds.Association' || type === 'cds.Composition');
+}
+
 const conditionOperators = [
   // Antlr rule 'condition', 'conditionAnd'
   'AND', 'OR',