@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/base/messages.js

@@ -10,7 +10,7 @@ const { isDeprecatedEnabled } = require('./model');
 const { centralMessages, centralMessageTexts, oldMessageIds } = require('./message-registry');
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
 const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
-const { CompilerAssertion } = require("./error");
+const { CompilerAssertion } = require('./error');
 
 const fs = require('fs');
 const path = require('path');
@@ -95,8 +95,8 @@ class CompilationError extends Error {
    * @memberOf CompilationError
    */
   constructor(messages, model, text, ...args) {
-    super( text || 'CDS compilation failed\n' + messages.map( m => m.toString() ).join('\n'),
-          // @ts-ignore Error does not take more arguments according to TypeScript...
+    super( text || `CDS compilation failed\n${ messages.map( m => m.toString() ).join('\n') }`,
+      // @ts-ignore Error does not take more arguments according to TypeScript...
            ...args );
     this.messages = messages;
 
@@ -105,11 +105,13 @@ class CompilationError extends Error {
     // property `model` is only set with options.attachValidNames:
     Object.defineProperty( this, 'model', { value: model || undefined, configurable: true } );
   }
+
   toString() {                  // does not really help -> set message
     return this.message.includes('\n')
       ? this.message
-      : this.message + '\n' + this.messages.map( m => m.toString() ).join('\n');
+      : `${ this.message }\n${ this.messages.map( m => m.toString() ).join('\n') }`;
   }
+
   /**
    * @deprecated Use `.messages` instead.
    */
@@ -143,8 +145,11 @@ class CompileMessage {
     this.home = home;  // semantic location, e.g. 'entity:"E"/element:"x"'
     this.severity = severity;
     Object.defineProperty( this, 'messageId', { value: id } );
-    // this.messageId = id;  // ids not yet finalized
     Object.defineProperty( this, '$module', { value: moduleName, configurable: true } );
+    // Uncomment when running TypeScript linter
+    // this.messageId = id;
+    // this.$module = moduleName;
+    // this.error = null;
   }
 
   toString() {                  // should have no argument...
@@ -182,8 +187,8 @@ function reclassifiedSeverity( msg, options, moduleName, deprecatedDowngradable
   if (spec.severity === 'Error') {
     const { configurableFor } = spec;
     if (!(Array.isArray( configurableFor )
-          ? configurableFor.includes( moduleName )
-          : configurableFor && (configurableFor !== 'deprecated' || deprecatedDowngradable)))
+      ? configurableFor.includes( moduleName )
+      : configurableFor && (configurableFor !== 'deprecated' || deprecatedDowngradable)))
       return 'Error';
   }
   else {
@@ -198,7 +203,7 @@ function reclassifiedSeverity( msg, options, moduleName, deprecatedDowngradable
   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]))
+    const oldName = spec.oldNames.find((name => options.severities[name]));
     newSeverity = options.severities[oldName];
   }
   return normalizedSeverity( newSeverity ) || spec.severity;
@@ -207,7 +212,7 @@ function reclassifiedSeverity( msg, options, moduleName, deprecatedDowngradable
 function normalizedSeverity( severity ) {
   if (typeof severity !== 'string')
     return (severity == null) ? null : 'Error';
-  let s = severitySpecs[ severity.toLowerCase() ];
+  const s = severitySpecs[severity.toLowerCase()];
   return s ? s.name : 'Error';
 }
 
@@ -322,12 +327,19 @@ function makeMessageFunction( model, options, moduleName = null ) {
   reclassifyMessagesForModule();
 
   return {
-    message, error, warning, info, debug, messages,
-    throwWithError, throwWithAnyError,
-    callTransparently, moduleName,
+    message,
+    error,
+    warning,
+    info,
+    debug,
+    messages,
+    throwWithError,
+    throwWithAnyError,
+    callTransparently,
+    moduleName,
   };
 
-  function _message(id, location, textOrArguments, severity, texts = null) {
+  function _message( id, location, textOrArguments, severity, texts = null ) {
     _validateFunctionArguments(id, location, textOrArguments, severity, texts);
 
     // Special case for _info, etc.: textOrArguments may be a string.
@@ -348,7 +360,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
 
     if (id) {
       if (options.testMode && !options.$recompile)
-        _check$Consistency( id, moduleName, severity, texts, options )
+        _check$Consistency( id, moduleName, severity, texts, options );
       msg.severity = reclassifiedSeverity(msg, options, moduleName, deprecatedDowngradable );
     }
 
@@ -364,33 +376,34 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * Validate the arguments for the message() function. This is needed during the transition
    * to the new makeMessageFunction().
    */
-  function _validateFunctionArguments(id, location, textArguments, severity, texts) {
+  function _validateFunctionArguments( id, location, textArguments, severity, texts ) {
     if (!options.testMode)
       return;
 
     if (id !== null && typeof id !== 'string')
-      _expectedType('id', id, 'string')
+      _expectedType('id', id, 'string');
 
     if (location !== null && location !== undefined && !Array.isArray(location) && typeof location !== 'object')
-      _expectedType('location', location, 'XSN/CSN location, CSN path')
+      _expectedType('location', location, 'XSN/CSN location, CSN path');
 
     if (severity != null && typeof severity !== 'string')
-      _expectedType('severity', severity, 'string')
+      _expectedType('severity', severity, 'string');
 
-    const isShortSignature = (typeof textArguments === 'string') // textArguments => texts
+    const isShortSignature = (typeof textArguments === 'string'); // textArguments => texts
 
     if (isShortSignature) {
       if (texts)
         throw new CompilerAssertion('No "texts" argument expected because text was already provided as third argument.');
-    } else {
+    }
+    else {
       if (textArguments !== undefined && typeof textArguments !== 'object')
-        _expectedType('textArguments', textArguments, 'object')
+        _expectedType('textArguments', textArguments, 'object');
       if (texts !== undefined && typeof texts !== 'object' && typeof texts !== 'string')
-        _expectedType('texts', texts, 'object or string')
+        _expectedType('texts', texts, 'object or string');
     }
 
-    function _expectedType(field, value, type) {
-      throw new CompilerAssertion(`Invalid argument type for ${ field }! Expected ${ type } but got ${ typeof value }. Do you use the old function signature?`);
+    function _expectedType( field, val, type ) {
+      throw new CompilerAssertion(`Invalid argument type for ${ field }! Expected ${ type } but got ${ typeof val }. Do you use the old function signature?`);
     }
   }
 
@@ -401,27 +414,27 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * @param {any} location
    * @returns {[CSN.Location, string, string]} Location, semantic location and definition.
    */
-  function _normalizeMessageLocation(location) {
+  function _normalizeMessageLocation( location ) {
     if (!location)
       // e.g. for general messages unrelated to code
-      return [ null, null, null ]
+      return [ null, null, null ];
 
     if (typeof location === 'object' && !Array.isArray(location))
       // CSN.Location (with line/endLine, col/endCol)
-      return [ location, location.home || null, null ]
+      return [ location, location.home || null, null ];
 
     const isCsnPath = (typeof location[0] === 'string'); // could be `definitions`, `extensions`, ....
     if (isCsnPath) {
       return [
         findNearestLocationForPath( model, location ),
-        constructSemanticLocationFromCsnPath( location, model ),
-        location[1] // location[0] is 'definitions'
+        constructSemanticLocationFromCsnPath( model, options, location ),
+        location[1], // location[0] is 'definitions'
       ];
     }
 
     let semanticLocation = location[1] ? homeName( location[1], false ) : null;
     if (location[2]) // optional suffix
-      semanticLocation += '/' + location[2]
+      semanticLocation += `/${ location[2] }`;
 
     const definition = location[1] ? homeName( location[1], true ) : null;
 
@@ -443,7 +456,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * @param {object} [textArguments] Text parameters that are replaced in the texts.
    * @param {string|object} [texts]
    */
-  function message(id, location, textArguments = null, texts = null) {
+  function message( id, location, textArguments = null, texts = null ) {
     if (!id)
       throw new CompilerAssertion('A message id is missing!');
     if (!centralMessages[id])
@@ -455,7 +468,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * Create a compiler error message.
    * @see message()
    */
-  function error(id, location, textOrArguments = null, texts = null) {
+  function error( id, location, textOrArguments = null, texts = null ) {
     return _message(id, location, textOrArguments, 'Error', texts);
   }
 
@@ -463,7 +476,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * Create a compiler warning message.
    * @see message()
    */
-  function warning(id, location, textOrArguments = null, texts = null) {
+  function warning( id, location, textOrArguments = null, texts = null ) {
     return _message(id, location, textOrArguments, 'Warning', texts);
   }
 
@@ -471,7 +484,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * Create a compiler info message.
    * @see message()
    */
-  function info(id, location, textOrArguments = null, texts = null) {
+  function info( id, location, textOrArguments = null, texts = null ) {
     return _message(id, location, textOrArguments, 'Info', texts);
   }
 
@@ -479,7 +492,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * Create a compiler debug message (usually not shown).
    * @see message()
    */
-  function debug(id, location, textOrArguments = null, texts = null) {
+  function debug( id, location, textOrArguments = null, texts = null ) {
     return _message(id, location, textOrArguments, 'Debug', texts);
   }
 
@@ -533,7 +546,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    * @param  {...any} args
    * @returns {CompileMessage[]}
    */
-  function callTransparently(callback, ...args) {
+  function callTransparently( callback, ...args ) {
     const backup = messages;
     messages = [];
     callback(...args);
@@ -552,7 +565,7 @@ function _check$Init( options ) {
     test$severities = Object.create(null);
   if (!test$texts) {
     test$texts = Object.create(null);
-    for (const [id, texts] of Object.entries( centralMessageTexts ))
+    for (const [ id, texts ] of Object.entries( centralMessageTexts ))
       test$texts[id] = (typeof texts === 'string') ? { std: texts } : { ...texts };
   }
 }
@@ -574,12 +587,13 @@ function _check$Init( options ) {
  * @private
  */
 function _check$Consistency( id, moduleName, severity, texts, options ) {
-  if (id.length > 30 && !centralMessages[id])
-    throw new CompilerAssertion( `The message ID "${id}" has more than 30 chars and must be listed centrally` );
+  // TODO: replace by linter?
+  if (id.length > 32 && !centralMessages[id])
+    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
-       Object.entries( (typeof texts === 'string') ? { std: texts } : texts || {} ))
+  for (const [ variant, text ] of
+    Object.entries( (typeof texts === 'string') ? { std: texts } : texts || {} ))
     _check$Texts( id, variant, text );
 }
 
@@ -602,19 +616,19 @@ function _check$Severities( id, moduleName, severity ) {
     if (!expected)
       test$severities[id] = severity;
     else if (expected !== severity)
-      throw new CompilerAssertion( `Inconsistent severity: Expecting "${expected}" from previous call, not "${severity}" for message ID "${id}"` );
+      throw new CompilerAssertion( `Inconsistent severity: Expecting "${ 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
   if (!isDowngradable( id, moduleName, true )) { // always an error in module
     if (severity !== 'Error')
-      throw new CompilerAssertion( `Inconsistent severity: Expecting "Error", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
+      throw new CompilerAssertion( `Inconsistent severity: Expecting "Error", not "${ severity }" for message ID "${ id }" in module "${ moduleName }"` );
   }
   else if (spec.severity === 'Error') {
-    throw new CompilerAssertion( `Inconsistent severity: Expecting the use of function message() when message ID "${id}" is a configurable error in module "${moduleName}"` );
+    throw new CompilerAssertion( `Inconsistent severity: Expecting the use of function message() when message ID "${ id }" is a configurable error in module "${ moduleName }"` );
   }
   else if (spec.severity !== severity) {
-    throw new CompilerAssertion( `Inconsistent severity: Expecting "${spec.severity}", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
+    throw new CompilerAssertion( `Inconsistent severity: Expecting "${ spec.severity }", not "${ severity }" for message ID "${ id }" in module "${ moduleName }"` );
   }
 }
 
@@ -627,51 +641,55 @@ function _check$Severities( id, moduleName, severity ) {
  *
  * @param {string} id
  * @param {string} prop
- * @param {string} value
+ * @param {string} val
  * @private
  */
-function _check$Texts( id, prop, value ) {
+function _check$Texts( id, prop, val ) {
   if (!test$texts[id])
     test$texts[id] = Object.create(null);
   const expected = test$texts[id][prop];
   if (!expected)
-    test$texts[id][prop] = value;
-  else if (expected !== value)
-    throw new CompilerAssertion( `Different texts for the same message ID. Expecting "${expected}", not "${value}" for ID "${id}" and text variant "${prop}"`);
+    test$texts[id][prop] = val;
+  else if (expected !== val)
+    throw new CompilerAssertion( `Different texts for the same message ID. Expecting “${ expected }”, not “${ val }” for ID “${ id }” and text variant “${ prop }”`);
 }
 
 const quote = {            // could be an option in the future
   double: p => `“${ p }”`, // for names, including annotation names (with preceeding `@`)
-  single: p => `‘${ p }’`, // for other things cited from the model
-  angle:  p => `‹${ p }›`, // for tokens like ‹Identifier›, and similar
-  number: p => p,          // for numbers like 42
-  upper:  p => p.toUpperCase(), // for keywords reported by ANTLR, use prop.single in v4
-}
+  single: p => `‘${ p }’`, // for other things cited from or expected in the model
+  angle: p => `‹${ p }›`, // for tokens like ‹Identifier›, and similar
+  direct: p => p,          // e.g. for numbers _not cited from or expected in_ the source
+  upper: p => p.toUpperCase(), // for keywords reported by ANTLR, use prop.single in v4
+};
 
 const paramsTransform = {
   // simple convenience:
   name: quoted,
   id: quoted,
   alias: quoted,
-  anno: a => (a.charAt(0) === '@' ? quote.double( a ) : quote.double( '@' + a )),
-  annos: anno => anno.map(paramsTransform.anno).join(', '),
-  delimited: n => '![' + n + ']', // TODO: use quote.single around?
+  anno,
+  annos: transformManyWith( anno ),
+  delimited: n => quote.single( `![${ n }]` ), // represent as delimited id (TODO: double-']')
   file: quote.single,
+  option: quote.single,
   prop: quote.single,
   siblingprop: quote.single,
   parentprop: quote.single,
   otherprop: quote.single,
   code: quote.single,
   newcode: quote.single,
-  kind: quote.angle,            // consider using text variants instead
-  keyword: quote.upper,
+  kind: quote.single,
+  meta: quote.angle,
+  keyword,
   // more complex convenience:
   names: transformManyWith( quoted ),
-  number: quote.number,
-  line: quote.number,
-  col: quote.number,
-  value: n => (typeof n !== 'number' ? quote.single( n ) : quote.number( n )),
-  othervalue: n => (typeof n !== 'number' ? quote.single( n ) : quote.number( n )),
+  number: quote.single,         // number cited from source or expected in source
+  count: quote.direct,
+  line: quote.direct,
+  col: quote.direct,
+  value,
+  rawvalues: transformManyWith( quote.single ),  // no 'double' quotes for strings
+  othervalue: value,
   art: transformArg,
   service: transformArg,
   sorted_arts: transformManyWith( transformArg, true ),
@@ -679,6 +697,7 @@ const paramsTransform = {
   source: transformArg,
   elemref: transformElementRef,
   type: transformArg,
+  othertype: transformArg,
   offending: tokenSymbol,
   op: quote.single,
   expecting: transformManyWith( tokenSymbol ),
@@ -687,13 +706,53 @@ const paramsTransform = {
   version: quote.single, // TODO delete: just use for OData $(VERSION), with version: 2.0
 };
 
+function anno( name ) {
+  return (name.charAt(0) === '@') ? quote.double( name ) : quote.double( `@${ name }` );
+}
+
+function value( val ) {
+  switch (typeof val) {
+    case 'number':
+    case 'boolean':
+    case 'bigint':
+    case 'undefined': {
+      return quote.single( val );
+    }
+    case 'string': {
+      // TODO: should we also shorten the string if too long?
+      return (!val ||
+              Number.parseFloat( val ).toString() === val ||
+              // with quotes (TODO: use `…` with escape chars):
+              /'/.test( val ))  // sync ')
+        ? quote.single( `'${ val.replace(/'/g, '\'\'') }'` )
+        : quote.single( val );
+    }
+    case 'object': {
+      return (val)
+        ? quote.angle( Array.isArray( val ) ? 'array' : 'object' )
+        : quote.single( val );
+    }
+    default:
+      return quote.angle( typeof val );
+  }
+}
+
+const keywordRepresentations = {
+  association: 'Association',
+  composition: 'Composition',
+};
+function keyword( val ) {
+  const v = val.toLowerCase();
+  return quote.single( keywordRepresentations[v] || v );
+}
+
 function ignoreTextTransform() {
   return null;
 }
 
 function transformManyWith( t, sorted ) {
   return function transformMany( many, r, args, texts ) {
-    const prop = ['none','one','two'][ many.length ];
+    const prop = [ 'none', 'one', 'two' ][many.length];
     const names = many.map(t);
     if (sorted)
       names.sort();
@@ -707,7 +766,9 @@ function transformManyWith( t, sorted ) {
 }
 
 function quoted( name ) {
-  return (name) ? quote.double( name ) : quote.angle( '?' ); // TODO: failure in --test-mode, then remove
+  if (typeof name === 'string')
+    return quote.double( name );
+  throw new CompilerAssertion( `Expecting a string, not ${ name }` );
 }
 
 function tokenSymbol( token ) {
@@ -715,21 +776,20 @@ function tokenSymbol( token ) {
     return quote.upper( token );
   else if (token.match( /^[A-Z][a-z]/ )) // Number, Identifier, ...
     return quote.angle( token );
-  if (token.startsWith("'") && token.endsWith("'")) // operator token symbol
+  if (token.startsWith('\'') && token.endsWith('\'')) // operator token symbol
     return quote.single( token.slice( 1, -1 ));
   else if (token === '<EOF>')
     return quote.angle( 'EOF' );
-  else
-    return quote.single( token ); // should not happen
+  return quote.single( token ); // should not happen
 }
 
 /**
  * Transform an element reference (/path), e.g. on-condition path.
  */
-function transformElementRef(arg) {
+function transformElementRef( arg ) {
   if (arg.ref) {
     // Can be used by CSN backends to create a simple path such as E:elem
-    return quoted(arg.ref.map(ref => {
+    return quoted(arg.ref.map((ref) => {
       if (ref.id) {
         // Indicate that the path has a filter.
         if (ref.where)
@@ -754,16 +814,16 @@ function transformArg( arg, r, args, texts ) {
   if (arg.ref) {
     // Can be used by CSN backends to create a simple path such as E:elem
     if (arg.ref.length > 1)
-      return quoted(arg.ref[0] + ':' + arg.ref.slice(1).join('.'));
+      return quoted(`${ arg.ref[0] }:${ arg.ref.slice(1).join('.') }`);
     return quoted(arg.ref);
   }
-  let name = arg.name;
+  const { name } = arg;
   if (!name)
     return quoted( name );
-  let prop = ['element','param','action','alias'].find( p => name[p] );
+  const prop = [ 'element', 'param', 'action', 'alias' ].find( p => name[p] );
   if (!prop || !texts[prop] )
     return shortArtName( arg );
-  r['#'] = texts[ name.$variant ] && name.$variant || prop; // text variant (set by searchName)
+  r['#'] = texts[name.$variant] && name.$variant || prop; // text variant (set by searchName)
   r.member = quoted( name[prop] );
   return artName( arg, prop );
 }
@@ -778,7 +838,7 @@ function searchName( art, id, variant ) {
   if (!variant) {
     // used to mention the "effective" type in the message, not the
     // originally provided one (TODO: mention that in the message text)
-    let type = art._effectiveType && art._effectiveType.kind !== 'undefined' ? art._effectiveType : art;
+    const type = art._effectiveType && art._effectiveType.kind !== 'undefined' ? art._effectiveType : art;
     if (type.elements) {        // only mentioned elements
       art = type.target && type.target._artifact || type;
       variant = 'element';
@@ -787,42 +847,45 @@ function searchName( art, id, variant ) {
       variant = 'absolute';
     }
   }
-  let prop = nameProp[variant] || variant;
-  let name = Object.assign( { $variant: variant }, (art._artifact||art).name );
-  name[prop] = (name[prop]) ? name[prop] + '.' + id : id || '?';
+  const prop = nameProp[variant] || variant;
+  const name = Object.assign( { $variant: variant }, (art._artifact || art).name );
+  name[prop] = name[prop] ? `${ name[prop] }.${ id }` : id || '?';
   return { name, kind: art.kind };
 }
 
 function messageText( texts, params, transform ) {
   if (typeof texts === 'string')
     texts = { std: texts };
-  let args = {};
-  for (let p in params) {
-    let t = transform && transform[p] || paramsTransform[p];
-    args[p] = (t) ? t( params[p], args, params, texts ) : params[p];
+  const args = {};
+  for (const p in params) {
+    if (params[p] !== undefined) {
+      const t = transform && transform[p] || paramsTransform[p];
+      args[p] = (t) ? t( params[p], args, params, texts ) : params[p];
+    }
   }
-  let variant = args['#'];
-  return replaceInString( variant && texts[ variant ] || texts.std, args );
+  const variant = args['#'];
+  return replaceInString( variant && texts[variant] || texts.std, args );
 }
 
 function replaceInString( text, params ) {
   const usedParams = [ '#', '$reviewed' ];
-  let pattern = /\$\(([A-Z_]+)\)/g;
-  let parts = [];
+  const pattern = /\$\(([A-Z_]+)\)/g;
+  const parts = [];
   let start = 0;
   for (let p = pattern.exec( text ); p; p = pattern.exec( text )) {
-    let prop = p[1].toLowerCase();
+    const prop = p[1].toLowerCase();
     parts.push( text.substring( start, p.index ),
                 (prop in params ? params[prop] : p[0]) );
     usedParams.push(prop);
     start = pattern.lastIndex;
   }
   parts.push( text.substring( start ) );
-  let remain = (params['#']) ? [] : Object.keys( params ).filter( n => !usedParams.includes(n) );
-  return (remain.length)
-         ? parts.join('') + '; ' +
-           remain.map( n => n.toUpperCase() + ' = ' + params[n] ).join(', ')
-         : parts.join('');
+  const remain = (params['#']) ? [] : Object.keys( params ).filter( n => !usedParams.includes(n) );
+  if (remain.length) {
+    const remains  = remain.map( n => `${ n.toUpperCase() } = ${ params[n] }` ).join(', ');
+    return `${ parts.join('') }; ${ remains }`;
+  }
+  return parts.join('');
 }
 
 /**
@@ -830,6 +893,8 @@ function replaceInString( text, params ) {
  * @returns {CSN.Location}
  */
 function weakLocation( loc ) {
+  if (!loc)
+    return {};
   // no endLine/endCol
   return { file: loc.file, line: loc.line, col: loc.col };
 }
@@ -848,14 +913,14 @@ function weakLocation( loc ) {
  */
 function messageString( err, normalizeFilename, noMessageId, noHome ) {
   return (err.$location && err.$location.file
-          ? locationString( err.$location, normalizeFilename ) + ': '
-          : '') +
+    ? `${ locationString( err.$location, normalizeFilename ) }: `
+    : '') +
          (err.severity || 'Error') +
          // TODO: use [message-id]
-         (err.messageId && !noMessageId ? ' ' + err.messageId + ': ' : ': ') +
+         (err.messageId && !noMessageId ? ` ${ err.messageId }: ` : ': ') +
          err.message +
          // even with noHome, print err.home if the location is weak
-         (!err.home || noHome && err.$location && err.$location.endLine ? '' : ' (in ' + err.home + ')');
+         (!err.home || noHome && err.$location && err.$location.endLine ? '' : ` (in ${ err.home })`);
 }
 
 /**
@@ -865,11 +930,11 @@ function messageString( err, normalizeFilename, noMessageId, noHome ) {
  * @param {CompileMessage} msg
  * @returns {string} can be used to uniquely identify a message
  */
-function messageHash(msg) {
+function messageHash( msg ) {
   // parser messages do not provide semantic location, therefore we need to use the file location
-  if(!msg.home)
+  if (!msg.home)
     return messageString(msg);
-  const copy = {...msg};
+  const copy = { ...msg };
   // Note: This is a hack. deduplicateMessages() would otherwise remove
   //       all but one message about duplicated artifacts.
   if (!msg.messageId || !msg.messageId.includes('duplicate'))
@@ -905,25 +970,26 @@ function messageStringMultiline( err, config = {} ) {
 
   const explainHelp = (config.hintExplanation && hasMessageExplanation(err.messageId)) ? '…' : '';
   const msgId = (err.messageId && !config.noMessageId) ? `[${ err.messageId }${ explainHelp }]` : '';
-  const home = !err.home ? '' : ('at ' + err.home);
+  const home = !err.home ? '' : (`at ${ err.home }`);
   const severity = err.severity || 'Error';
 
   let location = '';
   if (err.$location && err.$location.file) {
-    location += locationString( err.$location, config.normalizeFilename )
+    location += locationString( err.$location, config.normalizeFilename );
     if (home)
-      location += ', '
+      location += ', ';
+  }
+  else if (!home) {
+    return `${ colorTerm.severity(severity, severity + msgId) } ${ err.message }`;
   }
-  else if (!home)
-    return colorTerm.severity(severity, severity + msgId) + ' ' + err.message;
 
   let lineSpacer = '';
   if (config.withLineSpacer) {
-    let additionalIndent = err.$location ? `${ err.$location.endLine || err.$location.line || 1 }`.length : 1;
+    const additionalIndent = err.$location ? `${ err.$location.endLine || err.$location.line || 1 }`.length : 1;
     lineSpacer = `\n  ${ ' '.repeat( additionalIndent ) }|`;
   }
 
-  return colorTerm.severity(severity, severity + msgId) + ': ' + err.message + lineSpacer + '\n  ' + location + home;
+  return `${ colorTerm.severity(severity, severity + msgId) }: ${ err.message }${ lineSpacer }\n  ${ location }${ home }`;
 }
 
 /**
@@ -944,23 +1010,23 @@ function messageStringMultiline( err, config = {} ) {
  *                                          unset.
  * @returns {string}
  */
-function messageContext(sourceLines, err, config) {
+function messageContext( sourceLines, err, config ) {
   colorTerm.changeColorMode(config ? config.color : 'auto');
   const MAX_COL_LENGTH = 100;
 
   const loc = err.$location;
-  if (!loc || !loc.line) {
+  if (!loc || !loc.line)
     return '';
-  }
+
 
   // Lines are 1-based, we need 0-based ones for arrays
   const startLine = loc.line - 1;
   const endLine = loc.endLine ? loc.endLine - 1 : startLine;
 
   // check that source lines exists
-  if (typeof sourceLines[startLine] !== 'string' || typeof sourceLines[endLine] !== 'string') {
+  if (typeof sourceLines[startLine] !== 'string' || typeof sourceLines[endLine] !== 'string')
     return '';
-  }
+
 
   const digits = String(endLine + 1).length;
   const severity = err.severity || 'Error';
@@ -977,7 +1043,7 @@ function messageContext(sourceLines, err, config) {
   /** Only print N lines even if the error spans more lines. */
   const maxLine = Math.min((startLine + 2), endLine);
 
-  let msg = indent + '|\n';
+  let msg = `${ indent }|\n`;
 
   // print source line(s)
   for (let line = startLine; line <= maxLine; line++) {
@@ -986,8 +1052,8 @@ function messageContext(sourceLines, err, config) {
     if (sourceCode.length >= MAX_COL_LENGTH)
       sourceCode = sourceCode.slice(0, MAX_COL_LENGTH);
     // Only prepend space if the line contains any sources.
-    sourceCode = sourceCode.length ? ' ' + sourceCode : '';
-    msg +=  ' ' + String(line + 1).padStart(digits, ' ') + ' |' + sourceCode + '\n';
+    sourceCode = sourceCode.length ? ` ${ sourceCode }` : '';
+    msg += ` ${ String(line + 1).padStart(digits, ' ') } |${ sourceCode }\n`;
   }
 
   if (startLine === endLine && loc.col > 0) {
@@ -997,14 +1063,14 @@ function messageContext(sourceLines, err, config) {
     // Indicate that the error is further to the right.
     if (endColumn === MAX_COL_LENGTH)
       highlighter = highlighter.replace('  ^', '..^');
-    msg += indent + '| ' + colorTerm.severity(severity, highlighter);
-
-  } else if (maxLine !== endLine) {
+    msg += `${ indent }| ${ colorTerm.severity(severity, highlighter) }`;
+  }
+  else if (maxLine !== endLine) {
     // error spans more lines which we don't print
-    msg +=  indent + '| ...';
-
-  } else {
-    msg +=  indent + '|';
+    msg += `${ indent }| ...`;
+  }
+  else {
+    msg += `${ indent }|`;
   }
 
   return msg;
@@ -1033,13 +1099,14 @@ function compareMessage( a, b ) {
              // TODO: severities?
              c( a.message, b.message ) );
   }
-  else if (!aFile && !bFile)
+  else if (!aFile && !bFile) {
     return ( c( homeSortName( a ), homeSortName( b ) ) ||
              c( a.message, b.message ) );
-  else if (!aFile)
+  }
+  else if (!aFile) {
     return (a.messageId && a.messageId.startsWith( 'api-' )) ? -1 : 1;
-  else
-    return (b.messageId && b.messageId.startsWith( 'api-' )) ? 1 : -1;
+  }
+  return (b.messageId && b.messageId.startsWith( 'api-' )) ? 1 : -1;
 
   function c( x, y ) {
     return (x === y) ? 0 : (x > y) ? 1 : -1;
@@ -1068,9 +1135,8 @@ function compareMessageSeverityAware( a, b ) {
  */
 function homeSortName( { home, messageId } ) {
   if (!home)
-    return (messageId && /^(syntax|api)-/.test( messageId ) ? ' ' + messageId : '~')
-  else
-    return home.substring( home.indexOf(':') ); // i.e. starting with the ':', is always there
+    return (messageId && /^(syntax|api)-/.test( messageId ) ? ` ${ messageId }` : '~');
+  return home.substring( home.indexOf(':') ); // i.e. starting with the ':', is always there
 }
 
 /**
@@ -1087,22 +1153,24 @@ function homeSortName( { home, messageId } ) {
  * @param {CompileMessage[]} messages
  */
 function deduplicateMessages( messages ) {
+  // sort messages to make it processing sequence independent which messages (with
+  // which $location!) wins
+  messages.sort(compareMessage);
   const seen = new Map();
   for (const msg of messages) {
     const hash = messageHash(msg);
 
     if (!seen.has(hash)) {
       seen.set(hash, msg);
-
-    } else if (msg.$location) {
+    }
+    else if (msg.$location) {
       const existing = seen.get(hash);
       // If this messages has an end but the existing does not, then the new message is more precise.
       // If both messages do (or don't) have an endLine, then compare them based on their location.
       // Assume that a message is more precise if it comes later (i.e. may be included in the other).
       if (msg.$location.endLine && !existing.$location.endLine ||
-         (!msg.$location.endLine === !existing.$location.endLine && compareMessage(msg, existing) > 0)) {
+         (!msg.$location.endLine === !existing.$location.endLine && compareMessage(msg, existing) > 0))
         seen.set(hash, msg);
-      }
     }
   }
 
@@ -1119,21 +1187,21 @@ function shortArtName( art ) {
 }
 
 function artName( art, omit ) {
-  let name = art.name;
-  let r = (name.absolute) ? [ quoted( name.absolute ) ] : [];
+  const { name } = art;
+  const r = (name.absolute) ? [ quoted( name.absolute ) ] : [];
   if (name.select && name.select > 1 || name.select != null && art.kind !== 'element') // Yes, omit select:1 for element - TODO: re-check
     r.push( (art.kind === 'extend' ? 'block:' : 'query:') + name.select ); // TODO: rename to 'select:1' and consider whether there are more selects
   if (name.action && omit !== 'action')
-    r.push( memberActionName(art) + ':' + quoted( name.action ) );
+    r.push( `${ memberActionName(art) }:${ quoted( name.action ) }` );
   if (name.alias && art.kind !== '$self')
-    r.push( (art.kind === 'mixin' ? 'mixin:' : 'alias:') + quoted( name.alias ) )
+    r.push( (art.kind === 'mixin' ? 'mixin:' : 'alias:') + quoted( name.alias ) );
   if (name.param != null && omit !== 'param')
-    r.push( name.param ? 'param:' + quoted( name.param ) : 'returns' ); // TODO: join
+    r.push( name.param ? `param:${ quoted( name.param ) }` : 'returns' ); // TODO: join
   if (name.element && omit !== 'element')
     // r.push( `${ art.kind }: ${ quoted( name.element )}` ); or even better element:"assoc"/key:"i" same with enum
     r.push( (art.kind === 'enum' ? 'enum:' : 'element:') + quoted( name.element ) );
   if (art.kind === '$self')
-    r.push( 'alias:' + quoted( name.alias ) ) // should be late due to $self in anonymous aspect
+    r.push( `alias:${ quoted( name.alias ) }` ); // should be late due to $self in anonymous aspect
   return r.join('/');
 }
 
@@ -1155,9 +1223,9 @@ function homeName( art, absoluteOnly ) {
   else if (art.kind === 'source' || !art.name) // error reported in parser or on source level
     return null;
   else if (art.kind === 'using')
-    return 'using:' + quoted( art.name.id );
+    return `using:${ quoted( art.name.id ) }`;
   else if (art.kind === 'extend' || art.kind === 'annotate')
-    return !absoluteOnly && homeNameForExtend ( art );
+    return !absoluteOnly && homeNameForExtend( art );
   else if (art.name._artifact)             // block, extend, annotate
     return homeName( art.name._artifact, absoluteOnly ); // use corresponding definition
   else if (absoluteOnly)
@@ -1165,7 +1233,7 @@ function homeName( art, absoluteOnly ) {
   let main = art._main || art;
   while (main._outer)           // anonymous aspect
     main = main._outer._main;
-  return main.kind + ':' + artName( art );
+  return `${ main.kind }:${ artName( art ) }`;
 }
 
 // The "home" for extensions is handled differently because `_artifact` is not
@@ -1174,24 +1242,24 @@ function homeNameForExtend( art ) {
   const kind = art.kind || 'extend';
   // TODO: fix the following - do like in collectArtifactExtensions() or
   //       basically resolveUncheckedPath()
-  const absoluteName = art.name.id != null ? art.name.id :
-    (!art.name.element && art.name.absolute || art.name.path && art.name.path.map(s => s && s.id).join('.'));
+  const absoluteName = art.name.id != null ? art.name.id
+    : (!art.name.element && art.name.absolute || art.name.path && art.name.path.map(s => s && s.id).join('.'));
 
   // Surrounding parent may be another extension.
   const parent = art._parent;
   if (!parent && art.name.absolute)
-    return kind + ':' + artName(removeBlock(art));
+    return `${ kind }:${ artName(removeBlock(art)) }`;
   else if (!parent)
-    return kind + ':' + quoted(absoluteName);
+    return `${ kind }:${ quoted(absoluteName) }`;
 
   if (art.name.param && parent.params) {
     const fakeArt = { kind: 'param', name: { param: absoluteName } };
-    return homeNameForExtend(parent) + '/' + artName(fakeArt);
+    return `${ homeNameForExtend(parent) }/${ artName(fakeArt) }`;
   }
   else if (art.name.action && parent.actions) {
     const type = art.name._artifact?.kind || 'action';
     const fakeArt = { kind: type, name: { action: absoluteName }, _main: art.name._artifact?._main };
-    return homeNameForExtend(parent) + '/' + artName(fakeArt);
+    return `${ homeNameForExtend(parent) }/${ artName(fakeArt) }`;
   }
   else if (parent.enum || parent.elements || parent.returns?.elements) {
     // For enum, extensions may store them in `elements`, i.e. don't differ between enum/elements,
@@ -1204,21 +1272,21 @@ function homeNameForExtend( art ) {
     while (parentOfElementChain.name?.element && parentOfElementChain._parent)
       parentOfElementChain = parentOfElementChain._parent;
 
-    return homeNameForExtend(parentOfElementChain) + '/' + artName(fakeArt);
+    return `${ homeNameForExtend(parentOfElementChain) }/${ artName(fakeArt) }`;
   }
   // This case should not happen, but just in case
-  return kind + ':' + artName(parent);
+  return `${ kind }:${ artName(parent) }`;
 
   /**
    * Remove `select` from the 'art's name to avoid `block:1` in artName().
    * @TODO: Refactor homeNameForExtend (and possibly artName) to get rid of this function
-   **/
-  function removeBlock(obj) {
+   * */
+  function removeBlock( obj ) {
     return { ...obj, name: { ...obj.name, select: null } };
   }
 }
 
-function constructSemanticLocationFromCsnPath(csnPath, model) {
+function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (!model)
     return null;
   // Copy because this function shift()s from the path.
@@ -1231,8 +1299,8 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
   if (csnPath[0] === 'extensions') {
     const ext = model.extensions && model.extensions[csnPath[1]] || {};
     if (ext.annotate)
-      return 'annotate:' + quoted(ext.annotate);
-    return 'extend:' + quoted(ext.extend);
+      return `annotate:${ quoted(ext.annotate) }`;
+    return `extend:${ quoted(ext.extend) }`;
   }
 
   let { query } = analyseCsnPath(csnPath, model, false);
@@ -1245,7 +1313,7 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
     ? currentThing.kind
     : (dictName === 'vocabularies'
       ? 'annotation'
-      : 'artifact') }:${ _quoted(artifactName) }`;
+      : 'artifact') }:${ quoted(artifactName) }`;
 
   if (!currentThing)
     return result;
@@ -1265,6 +1333,7 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
   let inColumn = false;
   let inMixin = false;
   let inItems = false;
+  let currentAnno = null;
 
   // for top level actions
   if (currentThing.kind === 'action')
@@ -1275,7 +1344,7 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
       inCsnDict = true;
       switch (step) {
         case 'elements':
-          if (!inElement){
+          if (!inElement) {
             inElement = true;
             // do not print intermediate items
             inItems = false;
@@ -1378,13 +1447,13 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
     else if ( inKeys || inColumn) {
       if (typeof step === 'number') {
         if (currentThing.as)
-          result += `:${ _quoted(currentThing.as) }`;
+          result += `:${ quoted(currentThing.as) }`;
         else if (inRef)
-          result +=  `:${ _quoted(currentThing) }`;
+          result += `:${ quoted(currentThing) }`;
         else if (currentThing.ref)
-          result += `:${ _quoted(currentThing.ref.map(r => r.id ? r.id : r).join('.')) }`;
+          result += `:${ quoted(currentThing.ref.map(r => (r.id ? r.id : r)).join('.')) }`;
         else
-          return'';
+          return '';
 
         break;
       }
@@ -1406,11 +1475,17 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
 
       inCsnDict = false;
     }
+    else if (step[0] === '@') {
+      currentAnno = step;
+      break; // we don't go inside annotation values
+    }
   }
   if ( inItems )
     result += `${ element() }/items`;
   else if ( inElement )
     result += element();
+  if ( currentAnno )
+    result += `/${ quoted(currentAnno) }`;
   return result;
 
   function select() {
@@ -1418,27 +1493,29 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
     s += query.isOnlySelect ? '' : `:${ query.depth }`;
     return s;
   }
-  function selectAndMixin(name) {
-    return `${ select() }/mixin:${ _quoted(name) }`;
+  function selectAndMixin( name ) {
+    return `${ select() }/mixin:${ quoted(name) }`;
   }
   function element() {
-    return `/element:${ _quoted(elements.join('.')) }`;
+    return `/element:${ quoted(elements.join('.')) }`;
   }
-  function param(name) {
-    return `/param:${ _quoted(name) }`;
+  function param( name ) {
+    return `/param:${ quoted(name) }`;
   }
-  function func(name) {
-    return `/function:${ _quoted(name) }`;
+  function func( name ) {
+    if (currentThing?.kind)
+      return `/${ currentThing.kind }:${ quoted(name) }`;
+    return `/action:${ quoted(name) }`;
   }
-  function elementAndEnum(name) {
-    return `${ element() }/enum:${ _quoted(name) }`;
+  function elementAndEnum( name ) {
+    return `${ element() }/enum:${ quoted(name) }`;
   }
 
   /**
    * Traverse rootQuery until targetQuery is found and count the depth,
    * check if targetQuery is only select in entity.
    */
-  function queryDepth(rootQuery, targetQuery) {
+  function queryDepth( rootQuery, targetQuery ) {
     let targetQueryDepth = 1;
     let totalQueryDepth = 0;
 
@@ -1455,11 +1532,6 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
   }
 }
 
-
-function _quoted( name ) {
-  return (name) ? `"${ name.replace( /"/g, '""' ) }"` : '<?>'; // sync ";
-}
-
 /**
  * Get the explanation string for the given message-id.
  * Ensure to have called hasMessageExplanation() before.
@@ -1469,9 +1541,9 @@ function _quoted( name ) {
  * @throws May throw an ENOENT error if the file cannot be found.
  * @see hasMessageExplanation()
  */
-function explainMessage(messageId) {
+function explainMessage( messageId ) {
   messageId = oldMessageIds[messageId] || messageId;
-  const filename = path.join(__dirname, '..', '..', 'share', 'messages', `${messageId}.md`);
+  const filename = path.join(__dirname, '..', '..', 'share', 'messages', `${ messageId }.md`);
   return fs.readFileSync(filename, 'utf8');
 }
 
@@ -1483,7 +1555,7 @@ function explainMessage(messageId) {
  * @param {string} messageId
  * @returns {boolean}
  */
-function hasMessageExplanation(messageId) {
+function hasMessageExplanation( messageId ) {
   const id = oldMessageIds[messageId] || messageId || false;
   return id && _messageIdsWithExplanation.includes(id);
 }