@sap/cds-compiler 2.13.8 → 2.15.2

package/lib/base/message-registry.js

@@ -30,6 +30,9 @@
 
 'use strict';
 
+const { CompilerAssertion } = require("./error");
+const { createDict } = require("../utils/objectUtils");
+
 /**
  * Central register of messages and their configuration.
  * Group by id-category.
@@ -62,7 +65,7 @@ const centralMessages = {
   'assoc-as-type':  { severity: 'Error', configurableFor: 'deprecated' }, // TODO: allow more, but not all
   'def-unexpected-paramview-assoc': { severity: 'Error' },
   'def-unexpected-calcview-assoc': { severity: 'Error' },
-
+  'chained-array-of': { severity: 'Error' },
   'check-proper-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
   'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.rename' ] },
 
@@ -77,6 +80,7 @@ const centralMessages = {
   'expected-type': { severity: 'Error' },
   'ref-sloppy-type': { severity: 'Error' },
   'type-unexpected-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
+  'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'expected-actionparam-type': { severity: 'Error' },
   'ref-sloppy-actionparam-type': { severity: 'Error' },
   'expected-event-type': { severity: 'Error' },
@@ -97,6 +101,7 @@ const centralMessages = {
   'query-unexpected-assoc-hdbcds': { severity: 'Error' },
   'query-unexpected-structure-hdbcds': { severity: 'Error' },
   'query-ignoring-param-nullability': { severity: 'Info' },
+  'query-expected-identifier': { severity: 'Error' },
 
   'recalculated-localized': { severity: 'Info' }, // KEEP: Downgrade in lib/transform/translateAssocsToJoins.js
   'redirected-implicitly-ambiguous': { severity: 'Error', configurableFor: true }, // does not hurt us - TODO: ref-ambiguous-target
@@ -142,6 +147,8 @@ const centralMessages = {
   'syntax-invalid-escape': { severity: 'Error' },
   'syntax-missing-escape': { severity: 'Error' },
 
+  'syntax-expected-integer': { severity: 'Error' },
+
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
 
   'def-missing-element': { severity: 'Error' },
@@ -151,22 +158,46 @@ const centralMessages = {
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
   'odata-spec-violation-array':  { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
+  'odata-spec-violation-id': { severity: 'Error' },
   'odata-spec-violation-type': { severity: 'Error', configurableFor: [ 'to.edmx' ] },
+  'odata-spec-violation-type-unknown': { severity: 'Warning' },
   'odata-spec-violation-no-key':  { severity: 'Warning' },
   'odata-spec-violation-key-array':  { severity: 'Error' }, // more than 30 chars
   'odata-spec-violation-key-null': { severity: 'Error' }, // 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-namespace-name': { severity: 'Warning' }, // more than 30 chars
 };
 
+// Old/Deprecated message IDs that we only still use for backwards-compatibility.
+// We keep them in a separate array for easier access. No need to go through all
+// existing messages and search for the old one in `oldNames` property.
+// The keys will be added to `oldNames` of the new message, which is used for reclassification.
+const oldMessageIds = createDict({
+  'old-anno-duplicate': 'anno-duplicate', // Example
+});
+
+// Set up the old-to-new message ID mapping in the message registry.
+for (const oldName in oldMessageIds) {
+  const newName = oldMessageIds[oldName];
+  if (centralMessages[oldName])
+    throw new CompilerAssertion(`Mapping from ${oldName} not possible: ID is still used in message registry.`);
+  if (!centralMessages[newName])
+    throw new CompilerAssertion(`Mapping from ${oldName} to new message ID ${newName} does not exist!`);
+
+  if (!centralMessages[newName].oldNames)
+    centralMessages[newName].oldNames = [ oldName ];
+  else
+    centralMessages[newName].oldNames.push(oldName);
+}
+
+
 // For messageIds, where no text has been provided via code (central def)
 const centralMessageTexts = {
   'anno-duplicate': 'Duplicate assignment with $(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-ellipsis-layers': 'No base annotation available to apply $(CODE)',
-  'missing-type-parameter': 'Missing value for type parameter $(NAME) in reference to type $(ID)',
+  'chained-array-of': '"Array of"/"many" must not be chained with another "array of"/"many" inside a service',
   'syntax-csn-expected-object': 'Expected object for property $(PROP)',
   'syntax-csn-expected-column': 'Expected object or string \'*\' for property $(PROP)',
   'syntax-csn-expected-natnum': 'Expected non-negative number for property $(PROP)',
@@ -204,6 +235,16 @@ const centralMessageTexts = {
     std: 'Missing escape. Replace $(CODE) with $(NEWCODE)',
     placeholder: 'Placeholders are not supported. Replace $(CODE) with $(NEWCODE)',
   },
+  'syntax-expected-integer': {
+    std: 'A safe integer is expected here',
+    normal: 'An integer number is expected here',
+    unsafe: 'The provided integer is too large',
+  },
+  'syntax-duplicate-argument': {
+    std: 'Unexpected argument $(CODE)',
+    unknown: 'Unknown argument $(CODE)',
+    duplicate: 'Duplicate argument $(CODE)',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -213,7 +254,8 @@ const centralMessageTexts = {
   // TODO: proposal 'No definition found for $(NAME)',
   'ref-undefined-element': {
     std: 'Element $(ART) has not been found',
-    element: 'Artifact $(ART) has no element $(MEMBER)'
+    element: 'Artifact $(ART) has no element $(MEMBER)',
+    aspect: 'Element $(ID) has not been found in the anonymous target aspect'
   },
   'ref-unknown-var': {
     std: 'Replacement $(ID) not found'
@@ -231,6 +273,19 @@ const centralMessageTexts = {
     param: 'Unexpected $(KEYWORD) for the type of a parameter definition',
     select: 'Unexpected $(KEYWORD) for type references in queries',
   },
+
+  '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': {
+    std: 'Too many arguments for type $(ART)',
+    type: 'Unexpected argument $(PROP) for type $(ART) with base type $(TYPE)',
+    builtin: 'Unexpected argument $(PROP) for type $(ART)',
+    'non-scalar': 'Only scalar types can have arguments',
+    max: 'Expecting argument $(PROP) for type $(TYPE) to not exceed $(NUMBER)',
+    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)',
+  },
+
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
   'anno-undefined-def': 'Artifact $(ART) has not been found',
   'anno-undefined-art': 'No artifact has been found with name $(NAME)',
@@ -296,6 +351,10 @@ const centralMessageTexts = {
     std: 'Ignoring nullability constraint on parameter when generating SAP HANA CDS view',
     sql: 'Ignoring nullability constraint on parameter when generating SQL view'
   },
+  'query-expected-identifier': {
+    std: 'Expected identifier for select item',
+    assoc: 'Expected identifier as the association\'s name',
+  },
 
   'ref-sloppy-type': 'A type or an element is expected here',
   'ref-sloppy-actionparam-type': 'A type, an element, or a service entity is expected here',
@@ -312,11 +371,16 @@ const centralMessageTexts = {
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
 
   // OData version dependent messages
-  'odata-spec-violation-array': 'Unexpected array type for $(API)',
-  'odata-spec-violation-param' : 'Expected parameter to be typed with either scalar or structured type for $(API)',
-  'odata-spec-violation-returns': 'Expected $(KIND) to return one or many values of scalar, complex, entity or view type for $(API)',
-  'odata-spec-violation-assoc': 'Unexpected association in structured type for $(API)',
-  'odata-spec-violation-constraints': 'Partial referential constraints produced for $(API)',
+  'odata-spec-violation-array': 'Unexpected array type for OData $(VERSION)',
+  'odata-spec-violation-param' : 'Expected parameter to be typed with either scalar or structured type for OData $(VERSION)',
+  'odata-spec-violation-returns': 'Expected $(KIND) to return one or many values of scalar, complex, entity or view type for OData $(VERSION)',
+  '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',
+    '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'
+  },
   // version independent messages
   'odata-spec-violation-key-array': {
     std: 'Unexpected array type for element $(NAME)',
@@ -331,21 +395,30 @@ 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': 'Expected element to have a 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)',
+    facet: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
+  },
   'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(KIND)',
-  'odata-spec-violation-namespace': 'Expected service name not to be one of the reserved names $(NAMES)',
+  'odata-spec-violation-namespace': {
+    std: 'Expected service name not to be one of the reserved names $(NAMES)',
+    length: 'Expected service name not to exceed 511 characters',
+  },
   // Other odata/edm errors
   'odata-definition-exists': {
     std: 'Entity can\'t be created due to name collision with existing definition $(NAME)',
     proxy: 'No proxy entity created due to name collision with existing definition $(NAME) of kind $(KIND)'
-  }
+  },
+  'odata-navigation': 'No OData navigation property generated, target $(TARGET) is outside of service $(SERVICE)'
 }
 
 /**
  * Configuration for a message in the central message register.
  *
  * @typedef {object} MessageConfig
- * @property {CSN.MessageSeverity} severity Default severity for the message.
+ * @property {MessageSeverity} severity Default severity for the message.
  * @property {string[]|'deprecated'|true} [configurableFor]
  *        Whether the error can be reclassified to a warning or lower.
  *        If not `true` then an array is expected with specified modules in which the error is downgradable.
@@ -356,6 +429,8 @@ const centralMessageTexts = {
  * @property {boolean} [throughMessageCall]
  *        If set, it means that a message-id was added to the registry in test-mode through a `message.<severity>()`
  *        call.  Used for ensuring that all calls with the same message-id have the same severity.
+ * @property {string[]} [oldNames] Aliases for the message id. Used for reclassification as well as "explain" messages.
+ *                                 Don't set this property directly! Append to object oldMessageIds instead!
  */
 
-module.exports = { centralMessages, centralMessageTexts };
+module.exports = { centralMessages, centralMessageTexts, oldMessageIds };

package/lib/base/messages.js

@@ -7,10 +7,11 @@
 const { term } = require('../utils/term');
 const { locationString } = require('./location');
 const { isDeprecatedEnabled } = require('./model');
-const { centralMessages, centralMessageTexts } = require('./message-registry');
+const { centralMessages, centralMessageTexts, oldMessageIds } = require('./message-registry');
 const { copyPropIfExist } = require('../utils/objectUtils');
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
 const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
+const { CompilerAssertion } = require("./error");
 
 const fs = require('fs');
 const path = require('path');
@@ -24,7 +25,8 @@ let test$severities = null;
 let test$texts = null;
 
 /**
- * Returns true if at least one of the given messages is of severity "Error"
+ * Returns true if at least one of the given messages is of severity "Error".
+ *
  * @param {CSN.Message[]} messages
  * @returns {boolean}
  */
@@ -34,7 +36,8 @@ function hasErrors( messages ) {
 
 /**
  * Returns true if at least one of the given messages is of severity "Error"
- * and *cannot* be reclassified to a warning.
+ * and *cannot* be reclassified to a warning for the given module.
+ * Won't detect already downgraded messages.
  *
  * @param {CSN.Message[]} messages
  * @param {string} moduleName
@@ -122,7 +125,7 @@ class CompileMessage {
    * Creates an instance of CompileMessage.
    * @param {any} location Location of the message
    * @param {string} msg The message text
-   * @param {CSN.MessageSeverity} [severity='Error'] Severity: Debug, Info, Warning, Error
+   * @param {MessageSeverity} [severity='Error'] Severity: Debug, Info, Warning, Error
    * @param {string} [id] The ID of the message - visible as property messageId
    * @param {any} [home]
    * @param {string} [moduleName] Name of the module that created this message
@@ -141,7 +144,7 @@ class CompileMessage {
       Object.defineProperty( this, 'messageId', { value: id } );
       // this.messageId = id;  // ids not yet finalized
     if (moduleName)
-      Object.defineProperty( this, '$module', { value: moduleName } );
+      Object.defineProperty( this, '$module', { value: moduleName, configurable: true } );
   }
 
   toString() {                  // should have no argument...
@@ -184,7 +187,7 @@ const severitySpecs = {
 };
 
 /**
- * Reclassify the given message's severity using:
+ * Get the reclassified severity of the given message using:
  *
  *  1. The specified severity: either centrally provided or via the input severity
  *     - when generally specified as 'Error', immediately return 'Error'
@@ -195,17 +198,14 @@ const severitySpecs = {
  *     been returned according to 1, return the severity according to the user wishes.
  *  3. Otherwise, use the specified severity.
  *
- * @param {string} id
- * @param {CSN.MessageSeverity} severity
- * @param {object} severities
+ * @param {object} msg The CompileMessage.
+ * @param {CSN.Options} options
  * @param {string} moduleName
- * @returns {CSN.MessageSeverity}
- *
- * TODO: we should pass options as usual
- * TODO: should be part of the returned function
+ * @param {boolean} deprecatedDowngradable
+ * @returns {MessageSeverity}
  */
-function reclassifiedSeverity( id, severity, severities, moduleName, deprecatedDowngradable ) {
-  const spec = centralMessages[id] || { severity };
+function reclassifiedSeverity(msg, options, moduleName, deprecatedDowngradable ) {
+  const spec = centralMessages[msg.messageId] || { severity: msg.severity, configurableFor: null, errorFor: null };
   if (spec.severity === 'Error') {
     const { configurableFor } = spec;
     if (!(Array.isArray( configurableFor )
@@ -218,7 +218,17 @@ function reclassifiedSeverity( id, severity, severities, moduleName, deprecatedD
     if (Array.isArray( errorFor ) && errorFor.includes( moduleName ))
       return 'Error';
   }
-  return normalizedSeverity( severities[id] ) || spec.severity;
+
+  if (!options.severities)
+    return spec.severity;
+
+  let newSeverity = options.severities[msg.messageId];
+  // The user could have specified a severity through an old message ID.
+  if (!newSeverity && spec.oldNames) {
+    const oldName = spec.oldNames.find((name => options.severities[name]))
+    newSeverity = options.severities[oldName];
+  }
+  return normalizedSeverity( newSeverity ) || spec.severity;
 }
 
 function normalizedSeverity( severity ) {
@@ -228,24 +238,6 @@ function normalizedSeverity( severity ) {
   return s ? s.name : 'Error';
 }
 
-/**
- * Reclassifies all messages according to the current module.
- * This is required because if throwWithError() throws and the message's
- * severities has `errorFor` set, then the message may still appear to be a warning.
- *
- * TODO: this actually likely needs to be called by the backend module at the beginning!
- *
- * @param {CSN.Message[]} messages
- * @param {object} severities
- * @param {string} moduleName
- */
-function reclassifyMessagesForModule(messages, severities, moduleName, deprecatedDowngradable) {
-  for (const msg of messages) {
-    if (msg.messageId && msg.severity !== 'Error')
-      msg.severity = reclassifiedSeverity(msg.messageId, msg.severity, severities, moduleName, deprecatedDowngradable);
-  }
-}
-
 /**
  * Compare two severities.  Returns 0 if they are the same, and <0 if
  * `a` has a lower `level` than `b` according to {@link severitySpecs},
@@ -253,8 +245,8 @@ function reclassifyMessagesForModule(messages, severities, moduleName, deprecate
  *
  *   compareSeverities('Error', 'Info')  =>  Error < Info  =>  -1
  *
- * @param {CSN.MessageSeverity} a
- * @param {CSN.MessageSeverity} b
+ * @param {MessageSeverity} a
+ * @param {MessageSeverity} b
  * @see severitySpecs
  */
 function compareSeverities( a, b ) {
@@ -289,10 +281,9 @@ function searchForLocation( model, csnPath ) {
 
 /**
  * Create the `message` functions to emit messages.
- * See internalDoc/ReportingMessages.md for detail
  *
  * @example
- * ```
+ * ```js
  *   const { createMessageFunctions } = require(‘../base/messages’);
  *   function module( …, options ) {
  *     const { message, info, throwWithError } = createMessageFunctions( options, moduleName );
@@ -308,14 +299,14 @@ function searchForLocation( model, csnPath ) {
  * @param {object} [model=null] the CSN or XSN model, used for convenience
  */
 function createMessageFunctions( options, moduleName, model = null ) {
-  return makeMessageFunction( model, options, moduleName, true );
+  return makeMessageFunction( model, options, moduleName );
 }
 
 /**
  * Create the `message` function to emit messages.
  *
  * @example
- * ```
+ * ```js
  *   const { makeMessageFunction } = require(‘../base/messages’);
  *   function module( …, options ) {
  *     const { message, info, throwWithError } = makeMessageFunction( model, options, moduleName );
@@ -329,15 +320,13 @@ function createMessageFunctions( options, moduleName, model = null ) {
  * @param {object} model
  * @param {CSN.Options} [options]
  * @param {string} [moduleName]
- * @param {boolean} [throwOnlyWithNew=false] behave like createMessageFunctions
  */
-function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNew = false ) {
+function makeMessageFunction( model, options, moduleName = null ) {
   // ensure message consistency during runtime with --test-mode
   if (options.testMode)
     _check$Init( options );
 
   const hasMessageArray = !!options.messages;
-  const severities = options.severities || {};
   const deprecatedDowngradable = isDeprecatedEnabled( options, 'downgradableErrors' );
   /**
    * Array of collected compiler messages. Only use it for debugging. Will not
@@ -346,10 +335,17 @@ function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNe
    * @type {CSN.Message[]}
    */
   let messages = options.messages || [];
+  /**
+   * Whether an error was emitted in the module. Also includes reclassified errors.
+   * @type {boolean}
+   */
   let hasNewError = false;
+
+  reclassifyMessagesForModule();
+
   return {
     message, error, warning, info, debug, messages,
-    throwWithError: (throwOnlyWithNew ? throwWithError : throwWithAnyError),
+    throwWithError, throwWithAnyError,
     callTransparently, moduleName,
   };
 
@@ -361,11 +357,6 @@ function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNe
       texts = { std: textOrArguments };
       textOrArguments = {};
     }
-    if (id) {
-      if (options.testMode && !options.$recompile)
-        _check$Consistency( id, moduleName, severity, texts, options )
-      severity = reclassifiedSeverity( id, severity, severities, moduleName, deprecatedDowngradable );
-    }
 
     const [ fileLocation, semanticLocation, definition ] = _normalizeMessageLocation(location);
     const text = messageText( texts || centralMessageTexts[id], textOrArguments );
@@ -377,6 +368,12 @@ function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNe
     if (definition)
       msg.$location.address = { definition };
 
+    if (id) {
+      if (options.testMode && !options.$recompile)
+        _check$Consistency( id, moduleName, severity, texts, options )
+      msg.severity = reclassifiedSeverity(msg, options, moduleName, deprecatedDowngradable );
+    }
+
     messages.push( msg );
     hasNewError = hasNewError || msg.severity === 'Error' &&
       !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
@@ -406,7 +403,7 @@ function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNe
 
     if (isShortSignature) {
       if (texts)
-        throw new Error('No "texts" argument expected because text was already provided as third argument.');
+        throw new CompilerAssertion('No "texts" argument expected because text was already provided as third argument.');
     } else {
       if (textArguments !== undefined && typeof textArguments !== 'object')
         _expectedType('textArguments', textArguments, 'object')
@@ -415,7 +412,7 @@ function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNe
     }
 
     function _expectedType(field, value, type) {
-      throw new Error(`Invalid argument type for ${ field }! Expected ${ type } but got ${ typeof value }. Do you use the old function signature?`);
+      throw new CompilerAssertion(`Invalid argument type for ${ field }! Expected ${ type } but got ${ typeof value }. Do you use the old function signature?`);
     }
   }
 
@@ -470,9 +467,9 @@ function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNe
    */
   function message(id, location, textArguments = null, texts = null) {
     if (!id)
-      throw new Error('A message id is missing!');
+      throw new CompilerAssertion('A message id is missing!');
     if (!centralMessages[id])
-      throw new Error(`Message id '${ id }' is missing an entry in the central message register!`);
+      throw new CompilerAssertion(`Message id '${ id }' is missing an entry in the central message register!`);
     return _message(id, location, textArguments, null, texts);
   }
 
@@ -524,12 +521,31 @@ function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNe
   function throwWithAnyError() {
     if (!messages || !messages.length)
       return;
-    reclassifyMessagesForModule( messages, severities, moduleName ); // TODO: no, at the beginning of the module
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
     if (hasError( messages, moduleName ))
       throw new CompilationError( messages, options.attachValidNames && model );
   }
 
+  /**
+   * Reclassifies all messages according to the current module.
+   * This is required because if throwWithError() throws and the message's
+   * severities has `errorFor` set, then the message may still appear to be a warning.
+   */
+  function reclassifyMessagesForModule() {
+    for (const msg of messages) {
+      if (msg.messageId && msg.severity !== 'Error') {
+        const severity = reclassifiedSeverity(msg, options, moduleName, deprecatedDowngradable);
+        if (severity !== msg.severity) {
+          msg.severity = severity;
+          // Re-set the module regardless of severity, since we reclassified it.
+          Object.defineProperty( msg, '$module', { value: moduleName, configurable: true } );
+          hasNewError = hasNewError || severity === 'Error' &&
+            !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
+        }
+      }
+    }
+  }
+
   /**
    * Collects all messages during the call of the callback function instead of
    * storing them in the model. Returns the collected messages.
@@ -565,7 +581,7 @@ function _check$Init( options ) {
 
 function _check$Consistency( id, moduleName, severity, texts, options ) {
   if (id.length > 30 && !centralMessages[id])
-    throw new Error( `The message ID "${id}" has more than 30 chars and must be listed centrally` );
+    throw new CompilerAssertion( `The message ID "${id}" has more than 30 chars and must be listed centrally` );
   if (!options.severities)
     _check$Severities( id, moduleName || '?', severity );
   for (const [variant, text] of
@@ -582,20 +598,19 @@ function _check$Severities( id, moduleName, severity ) {
     if (!expected)
       test$severities[id] = severity;
     else if (expected !== severity)
-      throw new Error( `Expecting severity "${expected}" from previous call, not "${severity}" for message ID "${id}"` );
+      throw new CompilerAssertion( `Expecting severity "${expected}" from previous call, not "${severity}" for message ID "${id}"` );
     return;
   }
   // now try whether the message could be something less than an Error in the module due to user wishes
-  const user = reclassifiedSeverity( id, null, { [id]: 'Info' }, moduleName, false );
-  if (user === 'Error') {       // always an error in module
+  if (!isDowngradable( id, moduleName )) { // always an error in module
     if (severity !== 'Error')
-      throw new Error( `Expecting severity "Error", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
+      throw new CompilerAssertion( `Expecting severity "Error", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
   }
   else if (spec.severity === 'Error') {
-    throw new Error( `Expecting the use of function message() when message ID "${id}" is a configurable error in module "${moduleName}"` );
+    throw new CompilerAssertion( `Expecting the use of function message() when message ID "${id}" is a configurable error in module "${moduleName}"` );
   }
   else if (spec.severity !== severity) {
-    throw new Error( `Expecting severity "${spec.severity}", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
+    throw new CompilerAssertion( `Expecting severity "${spec.severity}", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
   }
 }
 
@@ -606,7 +621,7 @@ function _check$Texts( id, prop, value ) {
   if (!expected)
     test$texts[id][prop] = value;
   else if (expected !== value)
-    throw new Error( `Expecting text "${expected}", not "${value}" for message ID "${id}" and text variant "${prop}"`);
+    throw new CompilerAssertion( `Expecting text "${expected}", not "${value}" for message ID "${id}" and text variant "${prop}"`);
 }
 
 const quote = {                 // could be an option in the future
@@ -649,6 +664,7 @@ const paramsTransform = {
   expecting: transformManyWith( tokenSymbol ),
   // msg: m => m,
   $reviewed: ignoreTextTransform,
+  version: quote.meta,
 };
 
 function ignoreTextTransform() {
@@ -813,7 +829,7 @@ function messageString( err, normalizeFilename, noMessageId, noHome ) {
   return (err.$location && err.$location.file
           ? locationString( err.$location, normalizeFilename ) + ': '
           : '') +
-         (err.severity||'Error') +
+         (err.severity || 'Error') +
          // TODO: use [message-id]
          (err.messageId && !noMessageId ? ' ' + err.messageId + ': ' : ': ') +
          err.message +
@@ -1395,6 +1411,7 @@ function _quoted( name ) {
 
 /**
  * Get the explanation string for the given message-id.
+ * Ensure to have called hasMessageExplanation() before.
  *
  * @param {string} messageId
  * @returns {string}
@@ -1402,18 +1419,22 @@ function _quoted( name ) {
  * @see hasMessageExplanation()
  */
 function explainMessage(messageId) {
+  messageId = oldMessageIds[messageId] || messageId;
   const filename = path.join(__dirname, '..', '..', 'share', 'messages', `${messageId}.md`);
   return fs.readFileSync(filename, 'utf8');
 }
 
 /**
  * Returns true if the given message has an explanation file.
+ * Takes into account changed message ids, i.e. looks up if the new
+ * message id has an explanation.
  *
  * @param {string} messageId
  * @returns {boolean}
  */
 function hasMessageExplanation(messageId) {
-  return messageId && _messageIdsWithExplanation.includes(messageId);
+  const id = oldMessageIds[messageId] || messageId || false;
+  return id && _messageIdsWithExplanation.includes(id);
 }
 
 /**

package/lib/base/optionProcessorHelper.js

@@ -339,7 +339,11 @@ function createOptionProcessor() {
         // No more options after '--'
         seenDashDash = true;
       }
+      else if (!seenDashDash && arg.startsWith('--')) {
+        i += processOption(i);
+      }
       else if (!seenDashDash && arg.startsWith('-')) {
+        splitSingleLetterOption(argv, i); // `-ab` -> `-a -b`
         i += processOption(i);
       }
       else {
@@ -640,6 +644,21 @@ function createOptionProcessor() {
   }
 }
 
+/**
+ * Splits `-abc` into `-a -b -c`. Does this in-place on argv.
+ *
+ * @param {string[]} argv Argument array
+ * @param {number} i Current option index.
+ */
+function splitSingleLetterOption(argv, i) {
+  const arg = argv[i];
+  if (arg.length > 2) { // must be at least `-ab`.
+    const rest = argv.slice(i + 1);
+    argv.length = i; // trim array
+    argv.push(...arg.split('').slice(1).map(a => `-${a}`), ...rest);
+  }
+}
+
 /**
  * Return a camelCase name "fooBar" for a long option "--foo-bar"
  */