@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/base/message-registry.js

@@ -45,6 +45,7 @@ const centralMessages = {
   'anno-definition':        { severity: 'Warning' },
   'anno-duplicate':         { severity: 'Error', configurableFor: true }, // does not hurt us
   'anno-duplicate-unrelated-layer': { severity: 'Error', configurableFor: true }, // does not hurt us
+  'anno-unstable-array': { severity: 'Warning' },
   'anno-invalid-sql-element': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-struct': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-kind': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
@@ -67,7 +68,7 @@ const centralMessages = {
   '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' ] },
+  'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
 
   'expr-no-filter': { severity: 'Error', configurableFor: 'deprecated' },
 
@@ -80,6 +81,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-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'expected-actionparam-type': { severity: 'Error' },
   'ref-sloppy-actionparam-type': { severity: 'Error' },
@@ -112,10 +114,11 @@ const centralMessages = {
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
-  'ref-unknown-var': { severity: 'Info' },
+  'ref-unknown-var': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: true }, // does not hurt us
   'ref-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
+  'ref-expected-element': { severity: 'Error' },
 
   'rewrite-key-not-covered-explicit': { severity: 'Error', configurableFor: 'deprecated' },
   'rewrite-key-not-covered-implicit': { severity: 'Error', configurableFor: 'deprecated' },
@@ -128,14 +131,15 @@ const centralMessages = {
   'service-nested-context': { severity: 'Error', configurableFor: true }, // does not hurt compile, TODO
   'service-nested-service': { severity: 'Error', configurableFor: 'deprecated' }, // not supported yet
 
-  'syntax-anno-after-enum':   { severity: 'Error', configurableFor: true }, // does not hurt
-  'syntax-anno-after-params': { severity: 'Error', configurableFor: true }, // does not hurt
-  'syntax-anno-after-struct': { severity: 'Error', configurableFor: true }, // does not hurt
-  'syntax-csn-expected-cardinality': { severity: 'Error' }, // TODO: more than 30 chars
-  'syntax-csn-expected-length': { severity: 'Error' },
-  'syntax-csn-expected-translation': { severity: 'Error' }, // TODO: more than 30 chars
-  'syntax-csn-required-subproperty': { severity: 'Error' }, // TODO: more than 30 chars
-  'syntax-csn-unexpected-property': { severity: 'Error', configurableFor: true }, // is the removed
+  // 'syntax-duplicate-annotate' came late with v3 - make it configurable as
+  // fallback, but then parse.cdl is not supposed to work correctly (it can
+  // then either issue an error or produce a CSN missing some annotations):
+  'syntax-duplicate-annotate': { severity: 'Error', configurableFor: true },
+  'syntax-expected-cardinality': { severity: 'Error' },
+  'syntax-expected-length': { severity: 'Error' },
+  'syntax-expected-translation': { severity: 'Error' },
+  'syntax-required-subproperty': { severity: 'Error' },
+  'syntax-unexpected-property': { severity: 'Error', configurableFor: true }, // is the removed
   'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
   'syntax-fragile-alias': { severity: 'Error', configurableFor: true },
   'syntax-fragile-ident': { severity: 'Error', configurableFor: true },
@@ -148,6 +152,8 @@ const centralMessages = {
   'syntax-missing-escape': { severity: 'Error' },
 
   'syntax-expected-integer': { severity: 'Error' },
+  'syntax-invalid-masked': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
 
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
 
@@ -174,6 +180,15 @@ const centralMessages = {
 // 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
+
+  // These IDs are used by large stakeholders.  If we change them, we should
+  // be backward-compatible.
+  // 'redirected-to-complex': 'TODO',
+  // 'wildcard-excluding-one': 'TODO',
+  // 'wildcard-excluding-many': 'TODO',
+  // 'assoc-outside-service': 'TODO',
+  // 'redirected-to-same': 'TODO',
+  // 'query-navigate-many': 'TODO',
 });
 
 // Set up the old-to-new message ID mapping in the message registry.
@@ -194,34 +209,50 @@ for (const oldName in oldMessageIds) {
 // For messageIds, where no text has been provided via code (central def)
 const centralMessageTexts = {
   'api-invalid-option': {
-    std: 'Option $(NAME) is deprecated! Use SNAPI options instead',
-    magicVars: 'Option “magicVars” is deprecated! Use “variableReplacements” instead. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
+    std: 'Option $(NAME) is no longer supported! Use SNAPI options instead',
+    magicVars: 'Option “magicVars” is no longer supported! Use “variableReplacements” instead. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
     user: 'Option “variableReplacements” expects “$user” instead of “user”. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
     locale: 'Option “variableReplacements” expects “$user.locale” instead of “locale”. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
     'noDollar': 'Option “variableReplacements” does not know $(NAME). Did you forget a leading “$”?'
   },
 
   'anno-duplicate': 'Duplicate assignment with $(ANNO)',
+  'anno-duplicate-unrelated-layer': 'Duplicate assignment with $(ANNO)',
+  'anno-unstable-array': 'Unstable order of array items due to repeated assignments for $(ANNO) in unrelated layers',
   '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)',
   '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)',
-  'syntax-csn-expected-cardinality': 'Expected non-negative number or string \'*\' for property $(PROP)',
-  'syntax-csn-expected-reference': 'Expected non-empty string or object for property $(PROP)',
-  'syntax-csn-expected-term': 'Expected non-empty string or object for property $(PROP)',
-  'syntax-anno-after-struct': 'Avoid annotation assignments after structure definitions',
-  'syntax-anno-after-enum': 'Avoid annotation assignments after enum definitions',
-  'syntax-anno-after-params': 'Avoid annotation assignments after parameters',
+
+  'name-duplicate-element': {
+    'std': 'Generated element $(NAME) conflicts with another element',
+    'flatten-element-gen': 'Generated element $(NAME) conflicts with other generated element',
+    'flatten-element-exist': 'Flattened name of structured element conflicts with existing element $(NAME)',
+    'flatten-fkey-gen': 'Duplicate definition of foreign key element $(NAME) for association $(ART)',
+    'flatten-fkey-exists': 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element',
+  },
+
+  'syntax-anno-ignored': {
+    std: 'Annotations can\'t be used at prefix references',
+    doc: 'Doc comments can\'t be used at prefix references',
+  },
+  'syntax-unexpected-ellipsis': {
+    std: 'Expected no more than one $(CODE)',
+    'nested-array': 'Unexpected $(CODE) in nested array'
+  },
+  'syntax-expected-object': 'Expected object for property $(PROP)',
+  'syntax-expected-column': 'Expected object or string \'*\' for property $(PROP)',
+  'syntax-expected-natnum': 'Expected non-negative number for property $(PROP)',
+  'syntax-expected-cardinality': 'Expected non-negative number or string \'*\' for property $(PROP)',
+  'syntax-expected-reference': 'Expected non-empty string or object for property $(PROP)',
+  'syntax-expected-term': 'Expected non-empty string or object for property $(PROP)',
   'syntax-dollar-ident': {
     std: 'An artifact starting with $(NAME) might shadow a special variable - replace by another name',
     $tableAlias: 'A table alias name starting with $(NAME) might shadow a special variable - replace by another name',
     $tableImplicit: 'The resulting table alias starts with $(NAME) and might shadow a special variable - specify another name with $(KEYWORD)',
     mixin: 'A mixin name starting with $(NAME) might shadow a special variable - replace by another name' ,
   },
-  'syntax-csn-expected-length': {
+  'syntax-expected-length': {
     std: 'Expected array in $(PROP) to have at least $(N) items',
     one: 'Expected array in $(PROP) to have at least one item',
     suffix: 'With sibling property $(OTHERPROP), expected array in $(PROP) to have at least one item',
@@ -253,6 +284,26 @@ const centralMessageTexts = {
     unknown: 'Unknown argument $(CODE)',
     duplicate: 'Duplicate argument $(CODE)',
   },
+  'syntax-duplicate-annotate': 'You can\'t refer to $(NAME) repeatedly with property $(PROP) in the same annotate statement',
+  'syntax-duplicate-extend': {
+    std: 'You can\'t define and refer to $(NAME) repeatedly in the same extend statement',
+    define: 'You can\'t refer to $(NAME) in the same extend statement where it was defined',
+    extend: 'You can\'t refer to $(NAME) repeatedly in the same extend statement',
+  },
+  'syntax-invalid-literal': {
+    'std': 'Invalid literal',
+    'uneven-hex': 'A binary literal must have an even number of characters',
+    'invalid-hex': 'A binary literal must only contain characters 0-9, a-f and A-F',
+    'time': 'Expected time\'hh:mm:ss\' where hh, mm and the optional ss are numbers',
+    'date': 'Expected date\'YYYY-MM-DD\' where YYYY, MM and DD are numbers',
+    'timestamp': 'Expected timestamp\'YYYY-MM-DD hh:mm:ss.u…u\' where YYYY, MM, DD, hh, mm, ss and u are numbers (optional 1-7×u)',
+  },
+  'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
+  'syntax-unexpected-vocabulary': {
+    std: 'Annotations can\'t be defined inside contexts or services',
+    service: 'Annotations can\'t be defined inside services',
+    context: 'Annotations can\'t be defined inside contexts',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -266,7 +317,7 @@ const centralMessageTexts = {
     aspect: 'Element $(ID) has not been found in the anonymous target aspect'
   },
   'ref-unknown-var': {
-    std: 'Replacement $(ID) not found'
+    std: 'No replacement found for special variable $(ID)'
   },
   'ref-unexpected-draft-enabled': 'Composition in draft-enabled entity can\'t lead to another entity with $(ANNO)',
   'ref-rejected-on': {
@@ -274,12 +325,17 @@ const centralMessageTexts = {
     mixin: 'Do not refer to a mixin like $(ID) in the explicit ON of a redirection',
     alias: 'Do not refer to a source element (via table alias $(ID)) in the explicit ON of a redirection',
   },
+  'ref-expected-element': {
+    std: 'Expected element reference',
+    magicVar: 'Only elements of magic variable $(ID) can be selected',
+  },
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
     type: 'Unexpected $(KEYWORD) in type of a type definition',
     event: 'Unexpected $(KEYWORD) for the type of an event',
     param: 'Unexpected $(KEYWORD) for the type of a parameter definition',
     select: 'Unexpected $(KEYWORD) for type references in queries',
+    annotation: '$(KEYWORD) can\'t be used in annotation definitions',
   },
 
   'type-missing-argument': 'Missing value for argument $(NAME) in reference to type $(ID)',
@@ -419,7 +475,11 @@ const centralMessageTexts = {
     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)'
+  'odata-navigation': {
+    std: 'No OData navigation property generated, target $(TARGET) is outside of service $(SERVICE)',
+    oncond: 'No OData navigation property generated for association with arbitrary ON condition and target $(TARGET) outside of service $(SERVICE)'
+  },
+  'odata-parameter-order': 'Unexpected mandatory after optional parameter',
 }
 
 /**
@@ -431,7 +491,7 @@ const centralMessageTexts = {
  *        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.
  *        Only has an effect if default severity is 'Error'.
- *        'deprecated': severity can only be changed with deprecated.downgradableErrors.
+ *        'deprecated': severity can only be changed with deprecated._downgradableErrors.
  *        TODO: Value `true` is temporary. Use an array instead.
  * @property {string[]} [errorFor] Array of module names where the message shall be reclassified to an error.
  * @property {boolean} [throughMessageCall]

package/lib/base/messages.js

@@ -8,7 +8,6 @@ const { term } = require('../utils/term');
 const { locationString } = require('./location');
 const { isDeprecatedEnabled } = require('./model');
 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");
@@ -27,7 +26,7 @@ let test$texts = null;
 /**
  * Returns true if at least one of the given messages is of severity "Error".
  *
- * @param {CSN.Message[]} messages
+ * @param {CompileMessage[]} messages
  * @returns {boolean}
  */
 function hasErrors( messages ) {
@@ -39,7 +38,7 @@ function hasErrors( messages ) {
  * and *cannot* be reclassified to a warning for the given module.
  * Won't detect already downgraded messages.
  *
- * @param {CSN.Message[]} messages
+ * @param {CompileMessage[]} messages
  * @param {string} moduleName
  * @returns {boolean}
  */
@@ -135,7 +134,7 @@ class CompileMessage {
   constructor(location, msg, severity = 'Error', id = null, home = null, moduleName = null) {
     this.message = msg;
     this.location = location;
-    this.$location = dollarLocation( this.location );
+    this.$location = { ...this.location, address: undefined };
     this.validNames = null;
     if (home)                   // semantic location, e.g. 'entity:"E"/element:"x"'
       this.home = home;
@@ -152,33 +151,6 @@ class CompileMessage {
   }
 }
 
-/**
- * Temporary v1 function to convert an "old-style" location to "new-style".
- *
- * @param {CSN.Location} location
- * @return {CSN.Location}
- * @todo Remove
- */
-function dollarLocation( location ) {
-  const file  = location && location.file || undefined;
-  if (!file)
-    return {};
-  const loc = {
-    file,
-    line: location.line,
-    col: location.col,
-    address: undefined,
-  };
-  copyPropIfExist(location, 'endLine', loc);
-  copyPropIfExist(location, 'endCol', loc);
-  // TODO:
-  // return {
-  //   ...location,
-  //   address: undefined,
-  // };
-  return loc;
-}
-
 const severitySpecs = {
   error: { name: 'Error', level: 0 },
   warning: { name: 'Warning', level: 1 },
@@ -257,14 +229,16 @@ function compareSeverities( a, b ) {
 }
 
 /**
- * @todo This was copied from somewhere just to make CSN paths work.
+ * Find the nearest $location for the given CSN path in the model.
+ * If the path does not exist, the parent is used, and so on.
+ *
  * @param {CSN.Model} model
  * @param {CSN.Path} csnPath
+ * @returns {CSN.Location | null}
  */
-function searchForLocation( model, csnPath ) {
+function findNearestLocationForPath( model, csnPath ) {
   if (!model)
     return null;
-  // Don't display a location if we cannot find one!
   let lastLocation = null;
   /** @type {object} */
   let currentStep = model;
@@ -319,20 +293,23 @@ function createMessageFunctions( options, moduleName, model = null ) {
  * ```
  * @param {object} model
  * @param {CSN.Options} [options]
- * @param {string} [moduleName]
+ * @param {string|null} [moduleName]
  */
 function makeMessageFunction( model, options, moduleName = null ) {
-  // ensure message consistency during runtime with --test-mode
-  if (options.testMode)
+  if (options.testMode) {
+    // ensure message consistency during runtime with --test-mode
     _check$Init( options );
+    if (!options.messages)
+      throw new CompilerAssertion('makeMessageFunction() expects options.messages to exist in testMode!');
+  }
 
   const hasMessageArray = !!options.messages;
-  const deprecatedDowngradable = isDeprecatedEnabled( options, 'downgradableErrors' );
+  const deprecatedDowngradable = isDeprecatedEnabled( options, '_downgradableErrors' );
   /**
    * Array of collected compiler messages. Only use it for debugging. Will not
    * contain the messages created during a `callTransparently` call.
    *
-   * @type {CSN.Message[]}
+   * @type {CompileMessage[]}
    */
   let messages = options.messages || [];
   /**
@@ -361,7 +338,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     const [ fileLocation, semanticLocation, definition ] = _normalizeMessageLocation(location);
     const text = messageText( texts || centralMessageTexts[id], textOrArguments );
 
-    /** @type {CSN.Message} */
+    /** @type {CompileMessage} */
     const msg = new CompileMessage( fileLocation, text, severity, id, semanticLocation, moduleName );
     if (options.internalMsg)
       msg.error = new Error( 'stack' );
@@ -432,10 +409,10 @@ function makeMessageFunction( model, options, moduleName = null ) {
       // CSN.Location (with line/endLine, col/endCol)
       return [ location, location.home || null, null ]
 
-    const isCsnPath = (typeof location[0] === 'string');
+    const isCsnPath = (typeof location[0] === 'string'); // could be `definitions`, `extensions`, ....
     if (isCsnPath) {
       return [
-        searchForLocation( model, location ),
+        findNearestLocationForPath( model, location ),
         constructSemanticLocationFromCsnPath( location, model ),
         location[1] // location[0] is 'definitions'
       ];
@@ -553,7 +530,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    *
    * @param {Function} callback
    * @param  {...any} args
-   * @returns {CSN.Message[]}
+   * @returns {CompileMessage[]}
    */
   function callTransparently(callback, ...args) {
     const backup = messages;
@@ -579,6 +556,22 @@ function _check$Init( options ) {
   }
 }
 
+/**
+ * Check the consistency of the given message and run some basic lint checks.  These include:
+ *
+ *  - Long message IDs must be listed centrally.
+ *  - Messages with the same ID must have the same severity (in a module).
+ *  - Messages with the same ID must have the same message texts.
+ *    This ensures that $(PLACEHOLDERS) are used and that we don't accidentally
+ *    use the same ID for different meanings, i.e. texts.
+ *
+ * @param {string} id
+ * @param {string} moduleName
+ * @param {string} severity
+ * @param {string|object} texts
+ * @param {CSN.Options} 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` );
@@ -589,6 +582,16 @@ function _check$Consistency( id, moduleName, severity, texts, options ) {
     _check$Texts( id, variant, text );
 }
 
+/**
+ * Check the consistency of the message severity for the given message ID.
+ * Messages with the same ID must have the same severity (in a module).
+ * Non-downgradable errors must never be called with a lower severity.
+ *
+ * @param {string} id
+ * @param {string} moduleName
+ * @param {string} severity
+ * @private
+ */
 function _check$Severities( id, moduleName, severity ) {
   if (!severity)                // if just used message(), we are automatically consistent
     return;
@@ -598,22 +601,34 @@ function _check$Severities( id, moduleName, severity ) {
     if (!expected)
       test$severities[id] = severity;
     else if (expected !== severity)
-      throw new CompilerAssertion( `Expecting severity "${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 )) { // always an error in module
     if (severity !== 'Error')
-      throw new CompilerAssertion( `Expecting severity "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( `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( `Expecting severity "${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}"` );
   }
 }
 
+/**
+ * Check the consistency of the message text for the given message ID.
+ *
+ * Messages with the same ID must have the same message texts.
+ * This ensures that $(PLACEHOLDERS) are used and that we don't accidentally
+ * use the same ID for different meanings, i.e. texts.
+ *
+ * @param {string} id
+ * @param {string} prop
+ * @param {string} value
+ * @private
+ */
 function _check$Texts( id, prop, value ) {
   if (!test$texts[id])
     test$texts[id] = Object.create(null);
@@ -621,7 +636,7 @@ function _check$Texts( id, prop, value ) {
   if (!expected)
     test$texts[id][prop] = value;
   else if (expected !== value)
-    throw new CompilerAssertion( `Expecting text "${expected}", not "${value}" for message ID "${id}" and text variant "${prop}"`);
+    throw new CompilerAssertion( `Different texts for the same message ID. Expecting "${expected}", not "${value}" for ID "${id}" and text variant "${prop}"`);
 }
 
 const quote = {                 // could be an option in the future
@@ -819,7 +834,7 @@ function weakLocation( loc ) {
  * Example:
  *   <source>.cds:3:11: Error message-id: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
  *
- * @param {CSN.Message} err
+ * @param {CompileMessage} err
  * @param {boolean} [normalizeFilename]
  * @param {boolean} [noMessageId]
  * @param {boolean} [noHome]
@@ -841,7 +856,7 @@ function messageString( err, normalizeFilename, noMessageId, noHome ) {
  * Return message hash which is either the message string without the file location,
  * or the full message string if no semantic location is provided.
  *
- * @param {CSN.Message} msg
+ * @param {CompileMessage} msg
  * @returns {string} can be used to uniquely identify a message
  */
 function messageHash(msg) {
@@ -867,7 +882,7 @@ function messageHash(msg) {
  *   <source>.cds:3:11, at entity:“E”/element:“e”
  * ```
  *
- * @param {CSN.Message} err
+ * @param {CompileMessage} err
  * @param {object} [config = {}]
  * @param {boolean} [config.normalizeFilename] Replace windows `\` with forward slashes `/`.
  * @param {boolean} [config.noMessageId]
@@ -915,7 +930,7 @@ function messageStringMultiline( err, config = {} ) {
  *
  * @param {string[]} sourceLines The source code split up into lines, e.g. by `splitLines(src)`
  *                               from `lib/utils/file.js`
- * @param {CSN.Message} err Error object containing all details like line, message, etc.
+ * @param {CompileMessage} err Error object containing all details like line, message, etc.
  * @param {object} [config = {}]
  * @param {boolean | 'auto'} [config.color] If true, ANSI escape codes will be used for coloring the `^`.  If false, no
  *                                          coloring will be used.  If 'auto', we will decide based on certain factors such
@@ -994,8 +1009,8 @@ function messageContext(sourceLines, err, config) {
  * larger than `b`, and -1 if `a` is smaller than `b`. Messages without a location
  * are considered larger than messages with a location.
  *
- * @param {CSN.Message} a
- * @param {CSN.Message} b
+ * @param {CompileMessage} a
+ * @param {CompileMessage} b
  */
 function compareMessage( a, b ) {
   const aFile = a.$location && a.$location.file;
@@ -1029,8 +1044,8 @@ function compareMessage( a, b ) {
  * location and severity, >0 if `a` is larger than `b`, and <0 if `a` is smaller
  * than `b`. See `compareSeverities()` for how severities are compared.
  *
- * @param {CSN.Message} a
- * @param {CSN.Message} b
+ * @param {CompileMessage} a
+ * @param {CompileMessage} b
  */
 function compareMessageSeverityAware( a, b ) {
   const c = compareSeverities(a.severity, b.severity);
@@ -1042,12 +1057,13 @@ function compareMessageSeverityAware( a, b ) {
  * Messages without semantic locations are considered smaller (for syntax errors)
  * and (currently - should not happen in v2) larger for other messages.
  *
- * @param {CSN.Message} msg
+ * @param {CompileMessage} msg
  */
 function homeSortName( { home, messageId } ) {
-  return (!home)
-    ? (messageId && /^(syntax|api)-/.test( messageId ) ? ' ' + messageId : '~')
-    : home.substring( home.indexOf(':') ); // i.e. starting with the ':', is always there
+  if (!home)
+    return (messageId && /^(syntax|api)-/.test( messageId ) ? ' ' + messageId : '~')
+  else
+    return home.substring( home.indexOf(':') ); // i.e. starting with the ':', is always there
 }
 
 /**
@@ -1061,7 +1077,7 @@ function homeSortName( { home, messageId } ) {
  * A message is more precise if it is contained in the other or if
  * the first does not have an endLine/endCol.
  *
- * @param {CSN.Message[]} messages
+ * @param {CompileMessage[]} messages
  */
 function deduplicateMessages( messages ) {
   const seen = new Map();
@@ -1133,7 +1149,7 @@ function homeName( art, absoluteOnly ) {
     return null;
   else if (art.kind === 'using')
     return 'using:' + quoted( art.name.id );
-  else if (art.kind === 'extend')
+  else if (art.kind === 'extend' || art.kind === 'annotate')
     return !absoluteOnly && homeNameForExtend ( art );
   else if (art.name._artifact)             // block, extend, annotate
     return homeName( art.name._artifact, absoluteOnly ); // use corresponding definition
@@ -1148,35 +1164,41 @@ function homeName( art, absoluteOnly ) {
 // The "home" for extensions is handled differently because `_artifact` is not
 // set for unknown extensions and we could have nested extensions.
 function homeNameForExtend( art ) {
+  const kind = art.kind || 'extend';
   // TODO: fix the following - do like in collectArtifactExtensions() or
-  // basically resolveUncheckedPath()
-  const absoluteName = (art.name.id ? art.name.id :
-      art.name.path.map(s => s && s.id).join('.'));
+  //       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('.'));
 
   // Surrounding parent may be another extension.
   const parent = art._parent;
   if (!parent)
-    return 'extend:' + quoted(absoluteName);
-
-  // And that extension's artifact could have been found.
-  const parentArt = parent.name && parent.name._artifact;
-  if (!parentArt)
-    return artName(parent) + '/' + quoted(absoluteName);
-
-  let extensionName;
-  if (parentArt.enum || parentArt.elements) {
-    const fakeArt = {
-      kind: parentArt.enum ? 'enum' : 'element',
-      name: { element: absoluteName }
-    };
-    extensionName = artName(fakeArt);
+    return kind + ':' + quoted(absoluteName);
+
+  if (art.name.param && parent.params) {
+    const fakeArt = { kind: 'param', name: { param: absoluteName } };
+    return homeNameForExtend(parent) + '/' + artName(fakeArt);
   }
-  else {
-    extensionName = 'extend:' + quoted(absoluteName);
+  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);
   }
-  // Even though the parent artifact was found, we use kind 'extend'
-  // to make it clear that we are inside an (element) extension.
-  return 'extend:' + artName(parentArt) + '/' + extensionName;
+  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,
+    // so we need to look at the parent artifact.
+    // For `extend <art> with enum`, there is `enum`.
+    const parentArt = parent.name?._artifact;
+    const fakeKind = (parent.enum || parentArt?.enum) ? 'enum' : 'element';
+    const fakeArt = { kind: fakeKind, name: { element: art.name.element } };
+    let parentOfElementChain = parent;
+    while (parentOfElementChain.name?.element && parentOfElementChain._parent)
+      parentOfElementChain = parentOfElementChain._parent;
+
+    return homeNameForExtend(parentOfElementChain) + '/' + artName(fakeArt);
+  }
+  // This case should not happen, but just in case
+  return kind + ':' + artName(parent);
 }
 
 function constructSemanticLocationFromCsnPath(csnPath, model) {
@@ -1189,10 +1211,14 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
   ];
   const queryProps = [ 'from', 'where', 'groupBy', 'having', 'orderBy', 'limit', 'offset' ];
 
-  let { query } = analyseCsnPath(
-    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);
+  }
+
+  let { query } = analyseCsnPath(csnPath, model, false);
 
   // remove definitions
   csnPath.shift();
@@ -1332,8 +1358,12 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
       if (typeof step === 'number') {
         if (currentThing.as)
           result += `:${ _quoted(currentThing.as) }`;
+        else if (inRef)
+          result +=  `:${ _quoted(currentThing) }`;
+        else if (currentThing.ref)
+          result += `:${ _quoted(currentThing.ref.map(r => r.id ? r.id : r).join('.')) }`;
         else
-          result += inRef ? `:${ _quoted(currentThing) }` : currentThing.ref ? `:${ _quoted(currentThing.ref.map(r => r.id ? r.id : r).join('.')) }` : '';
+          return'';
 
         break;
       }