@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/api/main.js

@@ -26,10 +26,7 @@ const baseError = lazyload('../base/error');
 const csnToEdm = lazyload('../edm/csn2edm');
 const trace = lazyload('./trace');
 const cloneCsn = lazyload('../model/cloneCsn');
-
-const { forEach, forEachKey } = require('../utils/objectUtils');
-const { makeMessageFunction } = require('../base/messages');
-const { sortCsnForTests } = require('../model/cloneCsn');
+const objectUtils = lazyload('../utils/objectUtils');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -59,18 +56,18 @@ const warnAboutMismatchOdata = [ 'odataVersion' ];
 function attachTransformerCharacteristics( csn, transformation, options,
                                            relevantOptionNames, optionalOptionNames = [] ) {
   const relevant = {};
-  for (const name of relevantOptionNames ) {
+  for (const name of relevantOptionNames) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
 
-  for (const name of optionalOptionNames ) {
+  for (const name of optionalOptionNames) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
 
   // eslint-disable-next-line sonarjs/no-empty-collection
-  for (const name of relevantGeneralOptions ) {
+  for (const name of relevantGeneralOptions) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
@@ -142,7 +139,7 @@ function isPreTransformed( csn, transformation ) {
 function odataInternal( csn, internalOptions, messageFunctions ) {
   internalOptions.transformation = 'odata';
   let oDataCsn = forOdataNew.transform4odataWithCsn(csn, internalOptions, messageFunctions);
-  oDataCsn = sortCsnForTests(oDataCsn, internalOptions);
+  oDataCsn = cloneCsn.sortCsnForTests(oDataCsn, internalOptions);
   messageFunctions.setModel(oDataCsn);
   attachTransformerCharacteristics(oDataCsn, 'odata', internalOptions, relevantOdataOptions, warnAboutMismatchOdata);
   return oDataCsn;
@@ -273,13 +270,12 @@ function forHdbcds( csn, options, messageFunctions ) {
  *
  * @param {CSN.Model} csn Plain input CSN
  * @param {EffectiveCsnOptions} options Options
+ * @param {EffectiveCsnOptions} internalOptions Options that were already processed
  * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed
  * @private
  */
-function forEffective( csn, options, messageFunctions ) {
-  const internalOptions = prepareOptions.for.effective(options);
-  internalOptions.transformation = 'effective';
+function forEffectiveInternal( csn, options, internalOptions, messageFunctions ) {
   messageFunctions.setOptions( internalOptions );
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
@@ -294,6 +290,40 @@ function forEffective( csn, options, messageFunctions ) {
   return cloneCsn.sortCsnForTests(eCsn, internalOptions);
 }
 
+/**
+ * SEAL CSN transformation
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {EffectiveCsnOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} CSN transformed
+ * @private
+ */
+function forSeal( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.seal(options);
+  internalOptions.transformation = 'effective';
+  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+}
+
+/**
+ * Effective CSN transformation
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {EffectiveCsnOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} CSN transformed
+ * @private
+ */
+function forEffective( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.effective(options);
+  internalOptions.transformation = 'effective';
+  // for.effective is still beta mode
+  if (!baseModel.isBetaEnabled(options, 'effectiveCsn'))
+    throw new baseError.CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
+
+  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+}
+
 /**
  * Process the given CSN into SQL.
  *
@@ -352,7 +382,7 @@ function hdi( csn, options, messageFunctions ) {
     const sqlArtifactsWithCSNNamesToSort = Object.create(null);
     const sqlArtifactsNotToSort = Object.create(null);
 
-    forEach(flat, (key) => {
+    objectUtils.forEach(flat, (key) => {
       const artifactNameLikeInCsn = key.replace(/\.[^/.]+$/, '');
       nameMapping[artifactNameLikeInCsn] = key;
       if (key.endsWith('.hdbtable') || key.endsWith('.hdbview'))
@@ -370,7 +400,7 @@ function hdi( csn, options, messageFunctions ) {
       }, Object.create(null));
 
     // now add the not-sorted stuff, like indices
-    forEach(sqlArtifactsNotToSort, (key) => {
+    objectUtils.forEach(sqlArtifactsNotToSort, (key) => {
       sorted[remapName(key, sqlCSN, k => !k.endsWith('.hdbindex'))] = sqlArtifactsNotToSort[key];
     });
 
@@ -392,7 +422,7 @@ function hdi( csn, options, messageFunctions ) {
 function remapNames( dict, csn, filter ) {
   const result = Object.create(null);
 
-  forEach(dict, (key, value) => {
+  objectUtils.forEach(dict, (key, value) => {
     const name = remapName(key, csn, filter);
     result[name] = value;
   });
@@ -540,7 +570,7 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
   const createAndAlterSqls = [];
   // Turn the structured result into just a flat dictionary of "artifact name": "sql"
   const flatSqlDict = Object.values(hdbkinds).reduce((prev, curr) => {
-    forEach(curr, (name, value) => {
+    objectUtils.forEach(curr, (name, value) => {
       prev[name] = value;
     });
     return prev;
@@ -629,9 +659,9 @@ function hdiMigration( csn, options, messageFunctions, beforeImage ) {
  */
 function createSqlDefinitions( hdbkinds, afterImage ) {
   const result = [];
-  forEach(hdbkinds, (kind, artifacts) => {
+  objectUtils.forEach(hdbkinds, (kind, artifacts) => {
     const suffix = `.${ kind }`;
-    forEach(artifacts, (name, sqlStatement) => {
+    objectUtils.forEach(artifacts, (name, sqlStatement) => {
       if ( kind !== 'hdbindex' )
         result.push({ name: getFileName(name, afterImage), suffix, sql: sqlStatement });
       else
@@ -649,7 +679,7 @@ function createSqlDefinitions( hdbkinds, afterImage ) {
  */
 function createSqlDeletions( deletions, beforeImage ) {
   const result = [];
-  forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
+  objectUtils.forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
   return result;
 }
 /**
@@ -661,7 +691,7 @@ function createSqlDeletions( deletions, beforeImage ) {
  */
 function createSqlMigrations( migrations, afterImage ) {
   const result = [];
-  forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
+  objectUtils.forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
   return result;
 }
 
@@ -682,6 +712,10 @@ function hdbcds( csn, options, messageFunctions ) {
   internalOptions.transformation = 'hdbcds';
   messageFunctions.setOptions( internalOptions );
 
+  // no "isBetaEnabled", because this warning must also appear with "deprecated" flags
+  if (internalOptions.betaMode || internalOptions.beta?.v5preview)
+    messageFunctions.warning('api-deprecated-v5', null, null);
+
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
       '#': 'forbidden',
@@ -1012,10 +1046,10 @@ function preparedCsnToEdmAll( csn, options, messageFunctions ) {
  */
 function flattenResultStructure( toProcess ) {
   const result = {};
-  forEach(toProcess, (fileType, artifacts) => {
+  objectUtils.forEach(toProcess, (fileType, artifacts) => {
     if (fileType === 'messages')
       return;
-    forEach(artifacts, (filename) => {
+    objectUtils.forEach(artifacts, (filename) => {
       result[`${ filename }.${ fileType }`] = artifacts[filename];
     });
   });
@@ -1039,14 +1073,15 @@ module.exports = {
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
   for_effective: publishCsnProcessor(forEffective, 'for.effective'),
+  for_seal: publishCsnProcessor(forSeal, 'for.seal'),
 
   /* Deprecated, will be removed in cds-compiler@v5 */ // TODO(v5): Remove
   preparedCsnToEdmx(csn, service, options) {
-    preparedCsnToEdmx(csn, service, options, makeMessageFunction( csn, options, 'to.edmx' ));
+    preparedCsnToEdmx(csn, service, options, messages.makeMessageFunction( csn, options, 'to.edmx' ));
   },
   /* Deprecated, will be removed in cds-compiler@v5 */ // TODO(v5): Remove
   preparedCsnToEdm(csn, service, options) {
-    preparedCsnToEdm(csn, service, options, makeMessageFunction( csn, options, 'to.edm' ));
+    preparedCsnToEdm(csn, service, options, messages.makeMessageFunction( csn, options, 'to.edm' ));
   },
 };
 
@@ -1160,7 +1195,7 @@ function checkOutdatedOptions( options, messageFunctions ) {
     });
   }
 
-  forEachKey(options.variableReplacements || {}, (name) => {
+  objectUtils.forEachKey(options.variableReplacements || {}, (name) => {
     if (!name.startsWith('$') && name !== 'user' && name !== 'locale') {
       messageFunctions.error('api-invalid-variable-replacement', null, {
         '#': 'noDollar', option: 'variableReplacements', code: '$', name,

package/lib/api/options.js

@@ -52,6 +52,8 @@ const publicOptionsNewAPI = [
   // for.effective
   'resolveSimpleTypes',
   'resolveProjections',
+  'remapOdataAnnotations',
+  'keepLocalized',
 ];
 
 // Internal options used for testing/debugging etc.
@@ -214,12 +216,21 @@ module.exports = {
     effective: (options) => {
       const hardOptions = {};
       const defaultOptions = {
-        sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true,
+        sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true, remapOdataAnnotations: false, keepLocalized: false,
       };
       const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming' ], 'for.effective');
 
       return Object.assign({}, processed);
     },
+    seal: (options) => {
+      const hardOptions = {
+        sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true, keepLocalized: false,
+      };
+      const defaultOptions = { remapOdataAnnotations: true };
+      const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming' ], 'for.effective');
+
+      return Object.assign({}, processed);
+    },
     java: options => translateOptions(options, { sqlMapping: 'plain' }, {}, undefined, undefined, 'for.java'),
   },
   overallOptions, // exported for testing

package/lib/api/validate.js

@@ -140,17 +140,13 @@ const allCombinationValidators = {
     if (options.sqlDialect && options.sqlMapping && options.sqlDialect !== 'hana' && [ 'quoted', 'hdbcds' ].includes(options.sqlMapping))
       message.error('api-invalid-combination', null, { '#': 'sql-dialect-and-naming', name: options.sqlDialect, prop: options.sqlMapping });
   },
-  'sql-dialect-and-localized': (options, message) => {
-    if (options.fewerLocalizedViews && options.sqlDialect === 'hana' && (options.withHanaAssociations || options.withHanaAssociations === undefined))
-      message.error('api-invalid-combination', null, { '#': 'sql-dialect-and-localized', option: 'fewerLocalizedViews', value: 'hana' });
-  },
   'beta-no-test': (options, message) => {
     if (options.beta && !options.testMode)
       message.warning('api-unexpected-combination', null, { '#': 'beta-no-test', option: 'beta' });
   },
 };
 
-const alwaysRunValidators = [ 'beta-no-test', 'sql-dialect-and-localized' ];
+const alwaysRunValidators = [ 'beta-no-test' ];
 
 /**
  * Run the validations for each option.

package/lib/base/builtins.js

@@ -4,6 +4,32 @@
 // 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.
  *
@@ -80,6 +106,7 @@ function isAnnotationExpression( val ) {
 }
 
 module.exports = {
+  propagationRules,
   xprInAnnoProperties,
   functionsWithoutParens,
   isInReservedNamespace,

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,6 +162,7 @@ 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 },
@@ -230,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',
@@ -251,7 +258,6 @@ 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': {
@@ -284,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',
@@ -291,8 +298,9 @@ 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) can\'t be rewritten due to $(ELEMREF)',
+    unsupported: 'Assign a value for $(ANNO); the value inherited from $(ART) can\'t be rewritten due to unsupported $(ELEMREF)',
+    param: 'Assign a value for $(ANNO); the value inherited from $(ART) can\'t be rewritten due to parameter reference $(ELEMREF)',
   },
 
   'chained-array-of': '"Array of"/"many" must not be chained with another "array of"/"many" inside a service',
@@ -568,13 +576,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'
@@ -585,6 +597,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',
@@ -705,6 +718,8 @@ const centralMessageTexts = {
     min: 'Expecting argument $(PROP) for type $(TYPE) to be greater than or equal to $(NUMBER)',
     'incorrect-type': 'Expected $(NAMES) for argument $(PROP), but found $(CODE)',
   },
+  'type-unexpected-foreign-keys': 'A managed aspect composition can\'t have a foreign keys specification. Use composition-of-entity or remove foreign keys',
+  'type-unexpected-on-condition': 'A managed aspect composition can\'t have a specified ON-condition. Use composition-of-entity or remove the ON-condition',
 
   'type-invalid-items': {
     std: 'Unexpected $(PROP)', // unused
@@ -721,7 +736,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': {
@@ -864,7 +879,7 @@ const centralMessageTexts = {
     sub: 'Expecting an entity as target; a target aspect can\'t be specified for a sub element',
   },
   'ref-invalid-include': {
-    std: 'A type, entity, aspect or event with direct elements is expected here',
+    std: 'An explicitly structured entity, type, aspect, or event is expected here',
     bare : 'An aspect without elements is expected here',
     param: 'A type, entity, aspect or event without parameters is expected here',
   },
@@ -907,8 +922,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',
@@ -1032,10 +1047,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': {
@@ -1051,7 +1066,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)',
@@ -1148,13 +1163,14 @@ 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': {
-    'std': 'Expected one qualified type name for $(OP) in $(ANNO)'
+    'std': 'Expected one qualified type name for $(OP) in $(ANNO)',
+    'edm': 'Expected a qualified EDM type name for $(OP) in $(ANNO) but found $(TYPE)'
   },
   'odata-anno-xpr-args': {
     'std': 'Unexpected arguments for $(OP) in $(ANNO)',
@@ -1169,14 +1185,15 @@ const centralMessageTexts = {
   'odata-anno-xpr-ref': {
     'std': '$(ANNO) can\'t be propagated to $(NAME) because path $(ELEMREF) is not resolvable via type reference $(CODE)',
     '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',
+    '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': '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)',
+    '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

package/lib/base/messages.js

@@ -82,6 +82,23 @@ function isDowngradable( messageId, moduleName, options ) {
     : configurableFor && (configurableFor !== 'deprecated' || isDeprecatedEnabled( options, 'downgradableErrors' ));
 }
 
+/**
+ * Returns a marker for messages strings indicating whether the message can be downgraded
+ * or whether it will be an error in the next cds-compiler release.
+ *
+ * @returns {string}
+ */
+function severityChangeMarker(msg, config) {
+  const severity = msg.severity || 'Error';
+  if (config.moduleForMarker) {
+    if (severity === 'Error' && isDowngradable(msg.messageId, config.moduleForMarker, {}))
+      return '‹↓›';
+    if (msg.messageId && centralMessages[msg.messageId]?.errorFor?.includes('v5'))
+      return '‹↑›';
+  }
+  return '';
+}
+
 /**
  * Class for combined compiler errors.  Additional members:
  * - `messages`: array of compiler messages (CompileMessage)
@@ -100,8 +117,6 @@ class CompilationError extends Error {
     this.code = 'ERR_CDS_COMPILATION_FAILURE';
     this.messages = [ ...messages ].sort(compareMessageSeverityAware);
 
-    // TODO: remove this bin/cdsc.js specifics
-    Object.defineProperty( this, 'hasBeenReported', { value: false, configurable: true, writable: true, enumerable: false } );
     // property `model` is only set with options.attachValidNames:
     Object.defineProperty( this, 'model', { value: model || undefined, configurable: true } );
   }
@@ -176,8 +191,14 @@ class CompileMessage {
     // this.error = null;
   }
 
-  toString() {                  // should have no argument...
-    return messageString( this, undefined, true ); // no message-id before finalization!
+  toString() {
+    // Used by cds-dk in their own `toString` wrapper.
+    return messageString( this, {
+      normalizeFilename: false,
+      noMessageId: true, // no message-id before finalization!
+      noHome: false,
+      module: null,
+    });
   }
 }
 
@@ -869,7 +890,7 @@ function transformElementRef( arg ) {
     return quoted( arg );
   // Can be used by CSN backends or compiler to create a simple path such as E:elem
   return quoted(
-    (arg.param ? ':' : '') +
+    ((arg.scope === 'param' || arg.param) ? ':' : '') +
     ref.map(
       item => (typeof item !== 'string'
                ? `${ item.id }${item.args ? '(…)' : ''}${item.where ? '[…]' : ''}`
@@ -997,12 +1018,17 @@ function replaceInString( text, params ) {
  * @param {boolean} [config.noMessageId]
  *     If true, will _not_ show the message ID (+ explanation hint) in the output.
  *
+ * @param {boolean} [config.idInBrackets]
+ *     If true, the message ID (if there is one and noMessageId is falsey) will be put in brackets.
+ *     This will be the default in cds-compiler v5.
+ *
  * @param {boolean} [config.noHome]
  *     If true, will _not_ show message's semantic location.
  *
- * @param {string} [config.module]
+ * @param {string} [config.moduleForMarker]
  *     If set, downgradable error messages will get a '‹↓›' marker, depending on whether
- *     the message can be downgraded for the given module.
+ *     the message can be downgraded for the given module.  A `‹↑›` is used if the message
+ *     will be an error in the next major cds-compiler release.
  *
  * @returns {string}
  */
@@ -1013,19 +1039,22 @@ function messageString( err,  config ) {
       normalizeFilename: arguments[1],
       noMessageId: arguments[2],
       noHome: arguments[3],
-      module: arguments[4],
+      moduleForMarker: arguments[4],
     };
   }
+  config.moduleForMarker ??= config.module; // v4.8.0 or earlier compatibility
 
   const location = (err.$location?.file ? `${ locationString( err.$location, config.normalizeFilename ) }: ` : '');
   const severity = err.severity || 'Error';
-  const downgradable = severity === 'Error' && config.module &&
-    isDowngradable(err.messageId, config.module, {}) ? '‹↓›' : '';
+  const downgradable = severityChangeMarker(err, config);
   // even with noHome, print err.home if the location is weak
   const home = !err.home || config.noHome && err.$location?.endLine ? '' : ` (in ${ err.home })`;
-  // TODO: the plan was with brackets = `Error[ref-undefined-def]`
-  const id = err.messageId && !config.noMessageId ? ` ${ err.messageId }` : '';
-  return `${ location }${ severity }${ downgradable }${ id }: ${ err.message }${ home }`;
+
+  let msgId = ''; // TODO(v5): Use brackets only
+  if (err.messageId && !config.noMessageId)
+    msgId = (config.idInBrackets) ? `[${err.messageId}]` : ` ${err.messageId}`;
+
+  return `${ location }${ severity }${ downgradable }${ msgId }: ${ err.message }${ home }`;
 }
 
 /**
@@ -1065,9 +1094,10 @@ function messageHash( msg ) {
  * @param {boolean} [config.hintExplanation]
  *     If true, messages with explanations will get a "…" marker.
  *
- * @param {string} [config.module]
+ * @param {string} [config.moduleForMarker]
  *     If set, downgradable error messages will get a '‹↓›' marker, depending on whether
- *     the message can be downgraded for the given module.
+ *     the message can be downgraded for the given module.  A `‹↑›` is used if the message
+ *     will be an error in the next major cds-compiler release.
  *
  * @param {Record<string, string>} [config.sourceMap]
  *     A dictionary of filename<->source-code entries.  You can pass the `fileCache` that is used
@@ -1095,12 +1125,13 @@ function messageHash( msg ) {
 function messageStringMultiline( err, config = {} ) {
   colorTerm.changeColorMode(config ? config.color : 'auto');
 
+  config.moduleForMarker ??= config.module; // v4.8.0 or earlier compatibility
+
   const explainHelp = (config.hintExplanation && hasMessageExplanation(err.messageId)) ? '…' : '';
   const home = !err.home ? '' : (`at ${ err.home }`);
   const severity = err.severity || 'Error';
-  const downgradable = config.module && severity === 'Error' &&
-    isDowngradable(err.messageId, config.module, {}) ? '‹↓›' : '';
-  const msgId = (err.messageId && !config.noMessageId) ? `[${ err.messageId }${downgradable}${ explainHelp }]` : '';
+  const downgradable = severityChangeMarker(err, config);
+  const msgId = (err.messageId && !config.noMessageId) ? `${downgradable}[${ err.messageId }${ explainHelp }]` : '';
 
   let location = '';
   let context = '';
@@ -1590,7 +1621,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (!currentThing)
     return result;
 
-  let selectDepth = (csnPath[0] !== 'extensions') ? queryDepthForMessage(csnPath, model, currentThing) : null;
+  const selectDepth = (csnPath[0] !== 'extensions') ? queryDepthForMessage(csnPath, model, currentThing) : null;
 
   // Artifact ref -------------------------------------
 
@@ -1759,7 +1790,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
         if (index >= csnPath.length)
           continue; // no column name
 
-        let elementHierarchy = [];
+        const elementHierarchy = [];
 
         // Concat column+expand/inline to get a name similar to elements.
         do {