@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/base/builtins.js

@@ -0,0 +1,116 @@
+'use strict';
+
+// Model agnostic builtins.
+// It should not contain any specific to XSN, i.e. neither XSN structures
+// nor any other XSN properties.
+
+/**
+ * Map of propagation rules for annotations.
+ * Does not include rules for standard propagation of annotations or other properties.
+ *
+ * @type {Record<string, string>}
+ */
+const propagationRules = {
+  __proto__: null,
+  '@Analytics.hidden': 'never',
+  '@Analytics.visible': 'never',
+  '@cds.autoexpose': 'onlyViaArtifact',
+  '@cds.autoexposed': 'never',
+  '@cds.external': 'never',
+  '@cds.persistence.calcview': 'never',
+  '@cds.persistence.exists': 'never',
+  '@cds.persistence.skip': 'notWithPersistenceTable',
+  '@cds.persistence.table': 'never',
+  '@cds.persistence.udf': 'never',
+  '@cds.redirection.target': 'never',
+  '@com.sap.gtt.core.CoreModel.Indexable': 'never',
+  '@fiori.draft.enabled': 'onlyViaArtifact',
+  '@sql.append': 'never',
+  '@sql.prepend': 'never',
+  '@sql.replace': 'never',
+}
+
+/**
+ * Checks whether the given absolute path is inside a reserved namespace.
+ *
+ * @param {string} absolute
+ * @returns {boolean}
+ */
+function isInReservedNamespace( absolute ) {
+  return absolute === 'cds' || absolute.startsWith( 'cds.' ) &&
+    !absolute.match( /^cds\.foundation(\.|$)/ ) &&
+    !absolute.match( /^cds\.outbox(\.|$)/ ) && // Requested by Node runtime
+    !absolute.match( /^cds\.xt(\.|$)/ ); // Requested by Mtx
+}
+
+/**
+ * Tell if a type is (directly) a builtin type
+ * Note that in CSN builtins are not in the definition of the model, so we can only
+ * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
+ * are directly in 'cds', but not for example in 'cds.foundation'.
+ *
+ * @param {string|object} type
+ * @returns {boolean}
+ */
+function isBuiltinType( type ) {
+  type = typeof type === 'string' ? type : type?.ref?.[0];
+  return type && isInReservedNamespace( type );
+}
+
+const magicVariables = [
+  '$user',
+  '$at',
+  '$valid',
+  '$now',
+  '$tenant',
+  '$session',
+];
+
+/**
+ * Tell if a name is a magic variable
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isMagicVariable( name ) {
+  return typeof name === 'string' && magicVariables.includes(name);
+}
+
+/**
+ * Properties that are required next to `=` to make an annotation value an actual expression
+ * and not some foreign structure.
+ *
+ * @type {string[]}
+ */
+const xprInAnnoProperties = [
+  'ref', 'xpr', 'list', 'literal', 'val',
+  '#', 'func', 'args', 'SELECT', 'SET',
+  'cast',
+];
+
+/**
+ * Functions without parentheses in CDL (common standard SQL-92 functions)
+ * (do not add more - make it part of the SQL renderer to remove parentheses for
+ * other funny SQL functions like CURRENT_UTCTIMESTAMP).
+ */
+const functionsWithoutParens = [
+  'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
+  'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
+];
+
+/**
+ * Return whether JSON object `val` is a representation for an annotation expression
+ */
+function isAnnotationExpression( val ) {
+  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
+}
+
+module.exports = {
+  propagationRules,
+  xprInAnnoProperties,
+  functionsWithoutParens,
+  isInReservedNamespace,
+  isBuiltinType,
+  isMagicVariable,
+  isAnnotationExpression,
+}

package/lib/base/keywords.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { functionsWithoutParens } = require('../compiler/builtins');
+const { functionsWithoutParens } = require('./builtins');
 
 module.exports = {
   // CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
@@ -207,6 +207,7 @@ module.exports = {
     'ABAP_TIME',
     'ABAP_XSTRING',
     'ABS',
+    'ABSOLUTE',
     'ACOS',
     'ADD_DAYS',
     'ADD_MONTHS',
@@ -529,6 +530,7 @@ module.exports = {
     'RAW',
     'RDICT',
     'REAL',
+    'REAL_VECTOR',
     'RECORD_COMMIT_TIMESTAMP',
     'RECORD_COUNT',
     'RECORD_ID',
@@ -579,6 +581,7 @@ module.exports = {
     'ST_ALPHASHAPEAGGR',
     'ST_ALPHASHAPEAREAAGGR',
     'ST_ALPHASHAPEEDGEAGGR',
+    'ST_ASESRIJSON',
     'ST_ASGEOJSON',
     'ST_ASMVT',
     'ST_ASSVGAGGR',
@@ -828,6 +831,7 @@ module.exports = {
     'SIMILAR',
     'SOME',
     'SYMMETRIC',
+    'SYSTEM_USER',
     'TABLE',
     'TABLESAMPLE',
     'THEN',

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

@@ -64,8 +64,10 @@ const centralMessages = {
   'ext-undefined-param':   { severity: 'Warning' },
   'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
   'anno-unexpected-localized-skip': { severity: 'Error', configurableFor: true },
+  'anno-unexpected-mixin': { severity: 'Warning', errorFor: [ 'v5' ] },
 
   'name-invalid-dollar-alias': { severity: 'Error', configurableFor: true },
+  'name-deprecated-$self': { severity: 'Warning', errorFor: [ 'v5' ], configurableFor: true },
 
   'type-invalid-items': { severity: 'Error' }, // not supported yet
   'assoc-as-type':  { severity: 'Error' }, // TODO: allow more, but not all
@@ -84,6 +86,7 @@ const centralMessages = {
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
+  'ref-deprecated-self-element': { severity: 'Warning', configurableFor: true, errorFor: [ 'v5' ] },
   'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
   'ref-invalid-include': { severity: 'Error' },
@@ -159,34 +162,36 @@ const centralMessages = {
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
+  'syntax-ignoring-anno': { severity: 'Warning', errorFor: [ 'v5' ] },
 
   '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' },
@@ -229,6 +234,9 @@ for (const oldName in oldMessageIds) {
 // If you change it, keep in sync with scripts/eslint/rules/message-text.js
 
 const centralMessageTexts = {
+  'api-deprecated-v5': {
+    std: 'Support for generating hdbcds output is deprecated with @sap/cds-compiler v5 and later'
+  },
   'api-invalid-option': {
     std: 'Invalid option $(NAME)!',
     deprecated: 'Option $(NAME) is no longer supported! Use latest API options instead',
@@ -250,7 +258,7 @@ const centralMessageTexts = {
     std: 'Invalid option combination found: $(OPTION) and $(PROP)', // unused
     '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
@@ -282,6 +290,7 @@ const centralMessageTexts = {
   'anno-unstable-array': 'Unstable order of array items due to repeated assignments for $(ANNO)',
   'anno-mismatched-ellipsis': 'An array with $(CODE) can only be used if there is an assignment below with an array value',
   'anno-unexpected-ellipsis': 'No base annotation available to apply $(CODE)',
+  'anno-unexpected-mixin': 'Unexpected annotation on mixin definition',
 
   'anno-unexpected-localized-skip': {
     std: 'Compiler generated entity $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped',
@@ -289,8 +298,8 @@ const centralMessageTexts = {
   },
 
   'anno-missing-rewrite': {
-    std: 'Assign a value for $(ANNO), the value inherited from $(ART) would contain invalid references like $(ELEMREF)',
-    unrelated: 'Assign a value for $(ANNO), the value inherited from $(ART) would contain references like $(ELEMREF) to unrelated elements',
+    std: 'Assign a value for $(ANNO); the value inherited from $(ART) would contain invalid or unrelated references like $(ELEMREF)',
+    unsupported: 'Assign a value for $(ANNO); the value inherited from $(ART) can\'t be rewritten due to unsupported $(ELEMREF)',
   },
 
   'chained-array-of': '"Array of"/"many" must not be chained with another "array of"/"many" inside a service',
@@ -566,13 +575,17 @@ const centralMessageTexts = {
     entity: 'Entity $(ART) has no parameter $(ID)',
     action: 'Action $(ART) has no parameter $(ID)',
   },
-  'ref-undefined-art': 'No artifact has been found with name $(ART)',
+  'ref-undefined-art': {
+    std: 'No artifact has been found with name $(ART)',
+    namespace: 'No artifact has been found with name $(ART) which can be extended with annotations',
+    localized: 'Can\'t extend localized definitions, only annotate them using an $(KEYWORD) statement',
+  },
   // TODO: proposal 'No definition found for $(NAME)',
   'ref-undefined-element': {
     std: 'Element $(ART) has not been found',
     element: 'Artifact $(ART) has no element $(MEMBER)',
     target: 'Target entity $(ART) has no element $(ID)',
-    aspect: 'Element $(ID) has not been found in the anonymous target aspect', // TODO: still?
+    aspect: 'Element $(ID) has not been found in the anonymous target aspect',
     query: 'The current query has no element $(ART)',
     alias: 'Element $(ART) has not been found in the sub query for alias $(ALIAS)',
     virtual: 'Element $(ART) has not been found. Use $(CODE) to add virtual elements in queries'
@@ -583,6 +596,7 @@ const centralMessageTexts = {
     target: 'Target entity $(ART) has no element $(ID)',
     query: 'The current query has no element $(ART)',
     alias: 'Element $(ART) has not been found in the sub query for alias $(ALIAS)',
+    aspect: 'Element $(ID) has not been found in the anonymous target aspect',
   },
   'ref-undefined-var': {
     std: 'Variable $(ID) has not been found',
@@ -631,7 +645,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 +701,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': {
@@ -717,7 +733,7 @@ const centralMessageTexts = {
     'targetAspect': 'Unexpected $(KEYWORD) on composition of aspect'
   },
 
-  'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
+  'anno-builtin': 'Builtin types should not be annotated nor extended. Use custom type instead',
   'ext-undefined-def': 'Artifact $(ART) has not been found',
   'ext-undefined-art': 'No artifact has been found with name $(ART)',
   'ext-undefined-element': {
@@ -803,6 +819,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 +847,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)',
@@ -898,8 +919,8 @@ const centralMessageTexts = {
   },
 
   'query-undefined-element': {
-    std: 'Target $(TARGET) of $(NAME) is missing element $(ID); please use $(KEYWORD) with an explicit ON-condition',
-    redirected: 'Target $(TARGET) of $(NAME) is missing element $(ID); please add an ON-condition to $(KEYWORD)',
+    std: 'Target $(TARGET) of $(NAME) is missing element $(ID); use $(KEYWORD) with an explicit ON-condition',
+    redirected: 'Target $(TARGET) of $(NAME) is missing element $(ID); add an ON-condition to $(KEYWORD)',
   },
   'query-unexpected-assoc-hdbcds': 'Publishing a managed association in a view is not possible for “hdbcds” naming mode',
   'query-unexpected-structure-hdbcds': 'Publishing a structured element in a view is not possible for “hdbcds” naming mode',
@@ -974,7 +995,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 +1019,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
   // -----------------------------------------------------------------------------------
@@ -1007,10 +1044,10 @@ const centralMessageTexts = {
   'odata-spec-violation-assoc': 'Unexpected association in structured type for OData $(VERSION)',
   'odata-spec-violation-constraints': 'Partial referential constraints produced for OData $(VERSION)',
   'odata-spec-violation-id': {
-    std: 'Expected EDM name $(ID) to start with a letter or underscore, followed by at most 127 letters, underscores or digits',
+    std: 'Expected EDM name $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
     'v2firstchar': 'Unexpected first character $(PROP) of EDM Name $(ID) for OData $(VERSION)',
-    'qualifier': 'Expected annotation qualifier $(ID) to start with a letter or underscore, followed by at most 127 letters, underscores or digits',
-    'vocrefalias': 'Expected value $(VALUE) of vocabulary reference attribute $(ID) to start with a letter or underscore, followed by at most 127 letters, underscores or digits'
+    'qualifier': 'Expected annotation qualifier $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
+    'vocrefalias': 'Expected value $(VALUE) of vocabulary reference attribute $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
   },
   // version independent messages
   'odata-spec-violation-key-array': {
@@ -1026,7 +1063,7 @@ const centralMessageTexts = {
     scalar: 'Unexpected $(TYPE) mapped to $(ID) as type for key element' // flat
   },
   'odata-spec-violation-no-key': 'Expected entity to have a primary key',
-  'odata-spec-violation-type-unknown': 'Unknown Edm Type $(TYPE)',
+  'odata-spec-violation-type-unknown': 'Unknown EDM Type $(TYPE)',
   'odata-spec-violation-type': {
     std: 'Expected element to have a type',
     incompatible: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
@@ -1123,8 +1160,9 @@ const centralMessageTexts = {
   'odata-anno-xpr': {
     'std': 'unused',
     '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',
+    'use': 'Function $(OP) is not a renderable dynamic expression in $(ANNO), 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 +1174,22 @@ 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 in a scalar typed leaf element while flattening $(NAME)',
+    'flatten_builtin_type': 'Expected path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element while flattening',
+    'invalid': 'Invalid path $(ELEMREF) in $(ANNO)',
+    // genericTranslation
+    'notaparam': 'EDM Element path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a parameter entity',
+    'notaneelement': 'EDM Parameter path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a type entity',
+    'notrendered': 'EDM Path step $(COUNT) of $(ELEMREF) in $(ANNO) refers to an unrendered property in the OData API',
+    'magic': 'Unexpected magic variable $(ELEMREF) in $(ANNO)',
+    'bparam_v2': 'Unexpected explicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
   },
   // -----------------------------------------------------------------------------------
   // OData Message section ends here, no messages below this line