@sap/cds-compiler 4.7.4 → 4.8.0

package/lib/base/location.js

@@ -1,10 +1,85 @@
 'use strict';
 
 // This file contains functions related to XSN/CSN-location objects,
-// but not semantic locations (which are message-specific),
+// and the class definition for semantic locations
 
 const { copyPropIfExist } = require('../utils/objectUtils');
-const { CsnLocation } = require('../compiler/classes');
+
+class Location {
+  file;
+  line;
+  col;
+  endLine;
+  endCol;
+  constructor(file, line, col, endLine, endCol) {
+    this.file = file;
+    this.line = line;
+    this.col = col;
+    this.endLine = endLine;
+    this.endCol = endCol;
+  }
+}
+
+class SemanticLocation {
+  mainKind;
+  absolute;
+  action;
+  param;
+  select;
+  mixin;
+  element = [];
+  suffix;
+  innerKind;
+
+  toString() {
+    return semanticLocationString( this );
+  }
+}
+
+function semanticLocationString( name, extended = false ) {
+  const parts = [ `${ name.mainKind }:“${ name.absolute }”` ];
+  if (name.action != null)
+    parts.push( `“action:${ name.action }”` );
+  if (name.param != null)
+    parts.push( name.param ? `param:“${ name.param }”` : 'returns' );
+  if (name.select != null)
+    parts.push( name.select ? `select:${ name.select }` : 'select' );
+  if (name.mixin != null) {
+    const prop = (name.innerKind === 'alias') ? 'alias' : 'mixin';
+    parts.push( `${ prop }:${ stringOrRaw( name.mixin ) }` );
+  }
+  const { element, innerKind } = name;
+  if (element.length) {
+    const append = innerKind === 'item' || innerKind === 'aspect';
+    const prop = !append && innerKind || !innerKind && name.select != null && 'column';
+    if (!prop || append) {
+      parts.push( `element:${ stringOrRaw( element ) }` );
+      if (append)
+        parts.push( innerKind );
+    }
+    else if (prop === 'column') {
+      const pos = extended ? -1
+        : element.findIndex( ( e, idx ) => idx && typeof e !== 'string' );
+      parts.push( `column:${ stringOrRaw( pos > 0 ? element.slice( 0, pos ) : element ) }` );
+    }
+    else {
+      if (element.length > 1)
+        parts.push( `element:${ stringOrRaw( element.slice( 0, -1 ) ) }` );
+      parts.push( `${ innerKind }:“${ element[element.length - 1] }”` );
+    }
+  }
+  if (name.suffix)
+    parts.push( name.suffix );
+  return parts.join( '/' );
+}
+
+function stringOrRaw( val ) {
+  if (!Array.isArray( val ))
+    return (typeof val === 'string') ? `“${ val }”` : val;
+  return val.every( e => typeof e === 'string' ) // && no '.' ?
+    ? `“${ val.join( '.' ) }”`
+    : val.map( stringOrRaw ).join( '→' ); // for XSN output, is sliced otherwise
+}
 
 /**
  * Create a location with properties `file`, `line` and `col` from argument
@@ -42,7 +117,7 @@ function combinedLocation( start, end ) {
  */
 function emptyLocation( filename ) {
   return {
-    __proto__: CsnLocation.prototype,
+    __proto__: Location.prototype,
     file: filename,
     line: 1,
     col: 1,
@@ -62,7 +137,7 @@ function emptyLocation( filename ) {
  */
 function emptyWeakLocation( filename ) {
   return {
-    __proto__: CsnLocation.prototype,
+    __proto__: Location.prototype,
     file: filename,
     line: 1,
     col: 1,
@@ -72,12 +147,12 @@ function emptyWeakLocation( filename ) {
 }
 
 /**
- * @param {CsnLocation} loc
- * @returns {CsnLocation}
+ * @param {Location} loc
+ * @returns {Location}
  */
 function weakLocation( loc ) {
   return (!loc?.endLine) ? loc : {
-    __proto__: CsnLocation.prototype,
+    __proto__: Location.prototype,
     file: loc.file,
     line: loc.line,
     col: loc.col,
@@ -96,8 +171,8 @@ function weakLocation( loc ) {
  * a double-click on the _last_ identifier token of the reference jumps to the artifact
  * represented by the complete reference.
  *
- * @param {CsnLocation} loc
- * @returns {CsnLocation}
+ * @param {Location} loc
+ * @returns {Location}
  */
 function weakRefLocation( ref ) {
   if (!ref)
@@ -105,7 +180,7 @@ function weakRefLocation( ref ) {
   const { path } = ref;
   const loc = path?.length ? path[path.length - 1].location : ref.location;
   return (!loc?.endLine) ? loc : {
-    __proto__: CsnLocation.prototype,
+    __proto__: Location.prototype,
     file: loc.file,
     line: loc.line,
     col: loc.col,
@@ -115,12 +190,12 @@ function weakRefLocation( ref ) {
 }
 
 /**
- * @param {CsnLocation} loc
- * @returns {CsnLocation}
+ * @param {Location} loc
+ * @returns {Location}
  */
 function weakEndLocation( loc ) {
   return loc && {
-    __proto__: CsnLocation.prototype,
+    __proto__: Location.prototype,
     file: loc.file,
     line: loc.endLine,
     col: loc.endCol && loc.endCol - 1,
@@ -203,7 +278,7 @@ function dictLocation( dict, extraLocation ) {
     const lineB = (b.endLine || b.line);
     return (lineA > lineB || (lineA === lineB && (a.endCol || a.col) > (b.endCol || b.col)) ? a : b);
   });
-  return new CsnLocation( min.file, min.line, min.col, max.endLine, max.endCol );
+  return new Location( min.file, min.line, min.col, max.endLine, max.endCol );
 }
 
 function _objLocations( obj ) {
@@ -211,6 +286,8 @@ function _objLocations( obj ) {
 }
 
 module.exports = {
+  Location,
+  SemanticLocation,
   combinedLocation,
   emptyLocation,
   emptyWeakLocation,

package/lib/base/message-registry.js

@@ -162,31 +162,32 @@ const centralMessages = {
 
   'type-unsupported-precision-change': { severity: 'Error' },
   'type-unsupported-key-change': { severity: 'Error', configurableFor: true },
+  'type-missing-enum-value': { severity: 'Warning', errorFor: [ 'v5' ] },
 
   'def-missing-element': { severity: 'Error' },
-
+  'def-expected-structured': { severity: 'Warning', configurableFor: true, errorFor: [ 'v5' ] },
   'def-unsupported-calc-elem': { severity: 'Error', configurableFor: true },
 
   'def-invalid-key-cardinality': { severity: 'Error' },
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-array': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-array': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-assoc': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-assoc': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
   'odata-spec-violation-id': { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-namespace': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-namespace': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-param': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-param': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-returns': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-returns': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
   'odata-spec-violation-type': { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-type-unknown': { severity: 'Warning' },
-  'odata-spec-violation-no-key':  { severity: 'Warning' },
+  'odata-spec-violation-type-unknown': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] },
+  'odata-spec-violation-no-key':  { severity: 'Warning', configurableFor: true, errorFor: ['v5'] },
   'odata-spec-violation-key-array':  { severity: 'Error', configurableFor: true }, // more than 30 chars
   'odata-spec-violation-key-null': { severity: 'Error', configurableFor: true }, // more than 30 chars
-  'odata-spec-violation-key-type': { severity: 'Warning' }, // more than 30 chars
-  'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-key-type': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
+  'odata-spec-violation-property-name': { severity: 'Warning', configurableFor: true, errorFor: ['v5'] }, // more than 30 chars
   'odata-anno-preproc': { severity: 'Warning' },
   'odata-anno-dict': { severity: 'Warning' },
   'odata-anno-vocref': { severity: 'Warning' },
@@ -251,6 +252,7 @@ const centralMessageTexts = {
     'valid-structured': 'Structured OData is only supported with OData version v4',
     'sql-dialect-and-naming': 'sqlDialect $(NAME) can\'t be combined with sqlMapping $(PROP)',
     'sql-dialect-and-localized':  'Option $(OPTION) can\'t be combined with SQL dialect $(VALUE) or the to.hdi()/to.hdbcds() backend',
+    'tenant-and-naming': 'Option $(OPTION) can\'t be combined with sqlMapping $(PROP) - expected sqlMapping $(VALUE)'
   },
   'api-unexpected-combination': {
     std: 'Unexpected option combination: $(OPTION) and $(PROP)', // unused
@@ -631,7 +633,6 @@ const centralMessageTexts = {
     expr: 'Associations can\'t be used as values in expressions',
     'expr-comp': 'Compositions can\'t be used as values in expressions',
     'assoc-stored': 'Associations and compositions can\'t be used as values in stored calculated elements',
-    cast: 'Casting to an association is not supported',
 
     'managed-filter': 'Unexpected managed association $(NAME) in filter expression of $(ID)',
     'unmanaged-filter': 'Unexpected unmanaged association $(NAME) in filter expression of $(ID)'
@@ -688,7 +689,10 @@ const centralMessageTexts = {
   'type-unexpected-assoc': {
     std: 'An unmanaged association can\'t be used as type',
   },
-
+  'type-missing-enum-value': {
+    std: 'Missing value for non-string enum element $(NAME)',
+    numeric: 'Missing value for numeric enum element $(NAME)',
+  },
   'type-missing-argument': 'Missing value for argument $(NAME) in reference to type $(ID)',
   'type-ignoring-argument': 'Too many arguments for type $(ART)',
   'type-unexpected-argument': {
@@ -803,6 +807,8 @@ const centralMessageTexts = {
     'texts-aspect-locale': 'Element $(ELEMREF) of $(ART) must be of type $(TYPE) or $(OTHERTYPE)',
   },
 
+  'def-expected-structured': 'Events must either be structured or be projections',
+
   'duplicate-definition': {
     std: 'Duplicate definition of $(NAME)',
     absolute: 'Duplicate definition of artifact $(NAME)',
@@ -829,10 +835,13 @@ const centralMessageTexts = {
     $self: 'Can\'t refer to the query\'s own elements',
   },
   'ref-invalid-override': {
-    std: 'Overridden element of include must not change element structure', // unused
+    std: 'Overridden element of include must not change its type drastically', // unused
     'new-not-structured': 'Expected element $(NAME) to be structured, because it overrides the included element from $(ART)',
     'old-not-structured': 'Expected element $(NAME) to be scalar, because it overrides the included element from $(ART)',
-    missing: 'Expected element $(ID) to have at least all the same sub-elements as included artifacts, but it is missing $(NAME)'
+    missing: 'Expected element $(ID) to have at least all the same sub-elements as included artifacts, but it is missing $(NAME)',
+
+    'new-not-target': 'Expected element $(NAME) to be an association, because it overrides the included element from $(ART)',
+    'old-not-target': 'Expected element $(NAME) not to be an association, because it overrides the included element from $(ART)',
   },
 
   'ref-expecting-assoc': 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition, found $(TYPE)',
@@ -974,7 +983,8 @@ const centralMessageTexts = {
     'from-structure':  'Structured elements can\'t be cast to a different type',
     'expr-to-structure': 'Can\'t cast an expression to a structured type',
     'val-to-structure': 'Can\'t cast $(VALUE) to a structured type',
-    'from-assoc': 'Invalid type cast on an association'
+    'from-assoc': 'Invalid type cast on an association',
+    'assoc': 'Can\'t cast to an association',
   },
 
   // -----------------------------------------------------------------------------------
@@ -997,6 +1007,21 @@ const centralMessageTexts = {
     publishingFilter: 'Can\'t publish managed association $(ID) with filter, as it must have at least one foreign key',
   },
 
+  // tenenat isolation via discriminator column:
+  'tenant-invalid-alias-name': {
+    std: 'Can\'t have a table alias named $(NAME) in a tenant-dependent entity',
+    implicit: 'Provide an explicit table alias name; do not use $(NAME)',
+    mixin: 'Can\'t define a mixin named $(NAME) in a tenant-dependent entity',
+  },
+  'tenant-invalid-composition': {
+    std: 'Can\'t define a composition of a tenant-independent entity $(TARGET) in a tenant-dependent entity',
+    type: 'Can\'t use type $(TYPE) with a composition of a tenant-independent entity in a tenant-dependent entity',
+  },
+  'tenant-invalid-target': {
+    std: 'Can\'t define an association to a tenant-dependent entity $(TARGET) in a tenant-independent entity',
+    type: 'Can\'t use type $(TYPE) with an association to a tenant-dependent entity in a tenant-independent entity',
+  },
+
   // -----------------------------------------------------------------------------------
   // OData Message section starts here
   // -----------------------------------------------------------------------------------
@@ -1125,6 +1150,7 @@ const centralMessageTexts = {
     'notadynexpr': '$(OP) is not a renderable dynamic expression in $(ANNO)',
     'use': 'Function $(OP) is not a renderable dynamic expression in $(ANNO), please use $(CODE) instead',
     'canonfuncalias': 'Expected function name $(CODE) to be of the form $(META).$(OTHERMETA) for $(OP) in $(ANNO)',
+    'unexpected': 'Unexpected expression in $(ANNO)',
   }
   ,
   'odata-anno-xpr-type': {
@@ -1136,30 +1162,21 @@ const centralMessageTexts = {
     'atleast': 'Expected at least $(COUNT) argument(s) for $(OP) in $(ANNO)',
     'atmost': 'Expected at most $(COUNT) argument(s) for $(OP) in $(ANNO)',
     'wrongcount': 'Expected exactly one $(PROP) for $(OP) in $(ANNO)',
-    'wrongref': 'Unexpected arguments or filters in $(ELEMREF) in $(ANNO)',
     'wrongval': 'Unexpected value for $(OP) in $(ANNO)',
     'wrongval_meta': 'Expected value for $(OP) to be a $(META) in $(ANNO)',
     'wrongval_meta_list': 'Expected value for $(OP) to be a $(META) or $(RAWVALUES) in $(ANNO)',
   },
   'odata-anno-xpr-ref': {
     'std': '$(ANNO) can\'t be propagated to $(NAME) because path $(ELEMREF) is not resolvable via type reference $(CODE)',
-    'flatten_builtin': 'Expected path $(ELEMREF) in $(ANNO) to resolve to a builtin type while flattening $(NAME)',
-    'notaparam': 'Unexpected path $(ELEMREF) for parameter entity in $(ANNO)',
-    'notaneelement': 'Unexpected path $(ELEMREF) for type entity in $(ANNO)'
-  },
-  // tenenat isolation via discriminator column:
-  'tenant-invalid-alias-name': {
-    std: 'Can\'t have a table alias named $(NAME) in a tenant-dependent entity',
-    implicit: 'Provide an explicit table alias name; do not use $(NAME)',
-    mixin: 'Can\'t define a mixin named $(NAME) in a tenant-dependent entity',
-  },
-  'tenant-invalid-composition': {
-    std: 'Can\'t define a composition of a tenant-independent entity $(TARGET) in a tenant-dependent entity',
-    type: 'Can\'t use type $(TYPE) with a composition of a tenant-independent entity in a tenant-dependent entity',
-  },
-  'tenant-invalid-target': {
-    std: 'Can\'t define an association to a tenant-dependent entity $(TARGET) in a tenant-independent entity',
-    type: 'Can\'t use type $(TYPE) with an association to a tenant-dependent entity in a tenant-independent entity',
+    'args': 'Unexpected arguments or filters in $(ELEMREF) in $(ANNO)',
+    'flatten_builtin': 'Expected path $(ELEMREF) in $(ANNO) to end with a leaf element while flattening $(NAME)',
+    'flatten_builtin_type': 'Expected path $(ELEMREF) in $(ANNO) to end with a leaf element while flattening',
+    'invalid': 'Invalid path $(ELEMREF) in $(ANNO)',
+    // genericTranslation
+    'notaparam': 'Element path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a parameter entity',
+    'notaneelement': 'Parameter path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a type entity',
+    'notrendered': 'Path step $(COUNT) of $(ELEMREF) in $(ANNO) refers to an unrendered propery in the OData API',
+    'tomany': 'Unexpected to-many transition in path step $(COUNT) of $(ELEMREF) in $(ANNO)',
   },
   // -----------------------------------------------------------------------------------
   // OData Message section ends here, no messages below this line

package/lib/base/messages.js

@@ -5,8 +5,8 @@
 'use strict';
 
 const { term } = require('../utils/term');
-const { locationString } = require('./location');
-const { isDeprecatedEnabled } = require('./model');
+const { Location, locationString } = require('./location');
+const { isDeprecatedEnabled, isBetaEnabled } = require('./model');
 const { centralMessages, centralMessageTexts, oldMessageIds } = require('./message-registry');
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
 const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
@@ -17,7 +17,6 @@ const { cdlNewLineRegEx } = require('../language/textUtils');
 const fs = require('fs');
 const path = require('path');
 const { inspect } = require('util')
-const { CsnLocation } = require('../compiler/classes');
 
 // term instance for messages
 const colorTerm = term();
@@ -74,6 +73,9 @@ function isDowngradable( messageId, moduleName, options ) {
     return false;
   if (msg.severity !== 'Error')
     return true;
+  // v5 messages are downgradable (except if errorFor also contains the current module).
+  if (msg.errorFor && msg.errorFor.includes('v5'))
+    return true;
   const { configurableFor } = msg;
   return (Array.isArray( configurableFor ))
     ? configurableFor.includes( moduleName )
@@ -88,11 +90,12 @@ function isDowngradable( messageId, moduleName, options ) {
 class CompilationError extends Error {
   /**
    * @param {CompileMessage[]} messages
+   * @param {boolean} [dontSerializeMessages] If true, compiler messages are NOT part of the errors message text.
    * @param {XSN.Model} [model] the XSN model, only to be set with options.attachValidNames
    */
-  constructor(messages, model) {
-    // TODO(v5): Don't store stringified messages.
-    super( `CDS compilation failed\n${messages?.map( m => m.toString() ).join('\n') || ''}` );
+  constructor(messages, model, dontSerializeMessages) {
+    const msg = !dontSerializeMessages && messages?.map( m => m.toString() ).join('\n') || '';
+    super( `CDS compilation failed\n${msg}` );
     /** @since v4.0.0 */
     this.code = 'ERR_CDS_COMPILATION_FAILURE';
     this.messages = [ ...messages ].sort(compareMessageSeverityAware);
@@ -113,6 +116,27 @@ class CompilationError extends Error {
     return this.stack || this.message;
   }
 
+  /**
+   * Called when the exception is printed, e.g. when it is not caught.
+   * To give users a bit of information what went wrong, return stringified
+   * error messages.  But only errors to avoid spamming users.
+   *
+   * Compiler consumers should catch compilation errors and properly handle
+   * them by printing messages themselves.
+   *
+   * @returns {string}
+   */
+  toString() {
+    let messages = [ 'CDS compilation failed' ];
+    if (this.messages) {
+      messages = messages.concat(this.messages
+        .filter(msg => msg.severity === 'Error')
+        .map( m => m.toString())
+      );
+    }
+    return messages.join('\n');
+  }
+
   /**
    * @deprecated Use `.messages` instead.
    */
@@ -140,7 +164,7 @@ class CompileMessage {
    */
   constructor(location, msg, severity = 'Error', id = null, home = null, moduleName = null) {
     this.message = msg;
-    this.$location = { __proto__: CsnLocation.prototype, ...location, address: undefined };
+    this.$location = { __proto__: Location.prototype, ...location, address: undefined };
     this.validNames = null;
     this.home = home;  // semantic location, e.g. 'entity:"E"/element:"x"'
     this.severity = severity;
@@ -183,18 +207,28 @@ const severitySpecs = {
  */
 function reclassifiedSeverity( msg, options, moduleName ) {
   const spec = centralMessages[msg.messageId] || { severity: msg.severity, configurableFor: null, errorFor: null };
+  let severity = spec.severity;
+
   if (spec.severity === 'Error') {
     if (!isDowngradable(msg.messageId, moduleName, options))
       return 'Error';
   }
   else {
     const { errorFor } = spec;
-    if (Array.isArray( errorFor ) && errorFor.includes( moduleName ))
-      return 'Error';
+    if (Array.isArray( errorFor )) {
+      if (errorFor.includes(moduleName))
+        return 'Error';
+
+      if (errorFor.includes('v5') && isBetaEnabled(options, 'v5preview')) {
+        severity = 'Error';
+        if (!isDowngradable(msg.messageId, moduleName, options))
+          return severity;
+      }
+    }
   }
 
   if (!options.severities)
-    return spec.severity;
+    return severity;
 
   let newSeverity = options.severities[msg.messageId];
   // The user could have specified a severity through an old message ID.
@@ -202,7 +236,7 @@ function reclassifiedSeverity( msg, options, moduleName ) {
     const oldName = spec.oldNames.find((name => options.severities[name]));
     newSeverity = options.severities[oldName];
   }
-  return normalizedSeverity( newSeverity ) || spec.severity;
+  return normalizedSeverity( newSeverity ) || severity;
 }
 
 function normalizedSeverity( severity ) {
@@ -333,6 +367,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     callTransparently,
     moduleName,
     setModel,
+    setOptions,
   };
 
   function _message( id, location, textOrArguments, severity, texts = null ) {
@@ -352,7 +387,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     if (options.internalMsg)
       msg.error = new Error( 'stack' );
     if (definition)
-      msg.$location.address = { definition };
+      msg.$location.address = { definition }; // TODO: remove
 
     if (id) {
       if (options.testMode && !options.$recompile)
@@ -406,6 +441,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
   /**
    * Normalize the given location. Location may be a CSN path, XSN/CSN location or an
    * array of the form `[CSN.Location, XSN user, suffix]`.
+   * TODO: normalize to [ Location, SemanticLocation ]
    *
    * @param {any} location
    * @returns {[CSN.Location, string, string]} Location, semantic location and definition.
@@ -428,6 +464,9 @@ function makeMessageFunction( model, options, moduleName = null ) {
       ];
     }
 
+    if (location[1]?.mainKind)
+      return [ location[0], location[1].toString(), null ];
+
     let semanticLocation = location[1] ? homeName( location[1], false ) : null;
     if (location[2]) { // optional suffix, e.g. annotation
       semanticLocation += `/${ (typeof location[2] === 'string') ? location[2]: homeName(location[2]) }`;
@@ -494,8 +533,10 @@ function makeMessageFunction( model, options, moduleName = null ) {
   }
 
   function throwWithError() {
-    if (hasNewError)
-      throw new CompilationError( messages, options.attachValidNames && model );
+    if (hasNewError) {
+      const dontSerializeMessages = isBetaEnabled(options, 'v5preview');
+      throw new CompilationError(messages, options.attachValidNames && model, dontSerializeMessages);
+    }
   }
 
   /**
@@ -510,8 +551,10 @@ function makeMessageFunction( model, options, moduleName = null ) {
     if (!messages || !messages.length)
       return;
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
-    if (hasError( messages, moduleName, options ))
-      throw new CompilationError( messages, options.attachValidNames && model );
+    if (hasError( messages, moduleName, options )) {
+      const dontSerializeMessages = isBetaEnabled(options, 'v5preview');
+      throw new CompilationError(messages, options.attachValidNames && model, dontSerializeMessages);
+    }
   }
 
   /**
@@ -561,6 +604,18 @@ function makeMessageFunction( model, options, moduleName = null ) {
   function setModel( _model ) {
     model = _model;
   }
+
+  /**
+   * Change the options used to determine message severities.
+   * This is necessary if you change `options.severities`, as otherwise they may not be picked up.
+   *
+   * @param {CSN.Model} _model
+   */
+  function setOptions( _options ) {
+    options = _options;
+  }
+
+
 }
 
 /**

package/lib/base/model.js

@@ -29,7 +29,6 @@ const availableBetaFlags = {
   annotationExpressions: true,
   odataPathsInAnnotationExpressions: true,
   odataAnnotationExpressions: true,
-  assocsWithParams: true, // beta, because runtimes don't support it, yet.
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
   enableUniversalCsn: true,
@@ -39,7 +38,6 @@ const availableBetaFlags = {
   effectiveCsn: true,
   tenantVariable: true,
   calcAssoc: true,
-  vectorType: true,
   v5preview: true,
   // disabled by --beta-mode
   nestedServices: false,

package/lib/checks/actionsFunctions.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isBuiltinType } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct this value needs to be provided!

package/lib/checks/elements.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const {
-  forEachMember, forEachMemberRecursively, isBuiltinType, cardinality2str,
+  forEachMember, forEachMemberRecursively, cardinality2str,
 } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { isGeoTypeName } = require('../compiler/builtins');
 const { setProp } = require('../base/model');
 // Only to be used with validator.js - a correct `this` value needs to be provided!

package/lib/checks/enricher.js

@@ -6,7 +6,7 @@
 
 const { csnRefs } = require('../model/csnRefs');
 const { setProp } = require('../base/model');
-const { xprInAnnoProperties } = require('../compiler/builtins');
+const { isAnnotationExpression } = require('../base/builtins');
 
 /**
  * The following properties are attached as non-enumerable where appropriate:
@@ -96,7 +96,7 @@ function enrichCsn( csn, options ) {
    */
   function annotation( _parent, _prop, node ) {
     if (options.enrichAnnotations) {
-      if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
+      if (isAnnotationExpression(node)) {
         standard(_parent, _prop, node);
       }
       else if (node && typeof node === 'object') {

package/lib/checks/queryNoDbArtifacts.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('../model/csnUtils');
+const { hasAnnotationValue, isPersistedOnDatabase } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { requireForeignKeyAccess } = require('./onConditions');
 const { pathId } = require('../model/csnRefs');
 

package/lib/checks/utils.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isBuiltinType } = require('../model/csnUtils');
+const { isBuiltinType } = require('../base/builtins');
 const { RelationalOperators } = require('../transform/transformUtils');
 /**
  * Prepare the ref steps so that they are loggable