@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/api/validate.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { makeMessageFunction, handleMessages } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 
 /* eslint-disable arrow-body-style */
 const booleanValidator = {
@@ -94,6 +94,11 @@ const validators = {
     expected: () => 'Integer literal',
     found: val => `type ${ typeof val }`,
   },
+  csnFlavor: {
+    validate: val => typeof val === 'string',
+    expected: () => 'type string',
+    found: val => `type ${ typeof val }`,
+  },
   dictionaryPrototype: {
     validate: () => true,
   },
@@ -122,15 +127,17 @@ const allCombinationValidators = {
  * Use a custom validator or "default" custom validator, fallback to Boolean validator.
  *
  * @param {object} options Flat options object to validate
+ * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions
  * @param {object} [customValidators] Map of custom validators to use
  * @param {string[]} [combinationValidators] Validate option combinations
  * @returns {void}
  * @throws {CompilationError} Throws in case of invalid option usage
  */
-function validate(options, customValidators = {}, combinationValidators = []) {
+function validate(options, moduleName, customValidators = {}, combinationValidators = []) {
+  // TODO: issuing messages in this function looks very strange...
   {
     const messageCollector = { messages: [] };
-    const { error, throwWithError } = makeMessageFunction(null, messageCollector);
+    const { error, throwWithError } = makeMessageFunction(null, messageCollector, moduleName);
 
     for (const optionName of Object.keys(options)) {
       const optionValue = options[optionName];
@@ -142,7 +149,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
     throwWithError();
   }
 
-  const message = makeMessageFunction(null, options);
+  const message = makeMessageFunction(null, options, moduleName);
 
   for (const combinationValidatorName of combinationValidators.concat([ 'beta-no-test' ])) {
     const combinationValidator = allCombinationValidators[combinationValidatorName];
@@ -150,10 +157,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
       message[combinationValidator.severity]('invalid-option-combination', null, {}, combinationValidator.getMessage(options));
   }
 
-  // TODO: Replace with message.throwWithError():
-  // But be aware that it only throws with non-configurable errors and that this
-  // will lead to issues in test3. See #6037
-  handleMessages(undefined, options);
+  message.throwWithError();
 }
 /* eslint-enable jsdoc/no-undefined-types */
 

package/lib/backends.js

@@ -6,7 +6,6 @@
 const { transformForHanaWithCsn } = require('./transform/forHanaNew');
 const { compactModel, sortCsn } = require('./json/to-csn')
 const { toCdsSourceCsn } = require('./render/toCdl');
-const { toHdbcdsSource } = require('./render/toHdbcds');
 const { toSqlDdl } = require('./render/toSql');
 const { toRenameDdl } = require('./render/toRename');
 const { manageConstraints, listReferentialIntegrityViolations } = require('./render/manageConstraints');
@@ -19,85 +18,6 @@ const timetrace = require('./utils/timetrace');
 const { makeMessageFunction } = require('./base/messages');
 const { forEachDefinition } = require('./model/csnUtils');
 
-/**
- * Transform a CSN into HANA-compatible CDS source.
- * The following options control what is actually generated (see help above):
- *   options : {
- *     toHana.names
- *     toHana.src
- *     toHana.csn
- *   }
- * Options provided here are merged with (and take precedence over) options from 'model'.
- * If 'toHana.names' is not provided, 'quoted' is used.
- * If neither 'toHana.src' nor 'toHana.csn' are provided, the default is to generate only HANA CDS
- * source files.
- * If all provided options are part of 'toHana', the 'toHana' wrapper can be omitted.
- * The result object contains the generation results as follows (as enabled in 'options'):
- *   result : {
- *     csn               : the (compact) transformed CSN model
- *     hdbcds            : a dictionary of top-level artifact names, containing for each name 'X':
- *       <X>             : the HANA CDS source string of the artifact 'X'. Please note that the
- *                         name of 'X' may contain characters that are not legal for filenames on
- *                         all operating systems (e.g. ':', '\' or '/').
- *                         X reflects the naming policy set by toHana.names
- *   }
- * Throws a CompilationError on errors.
- *
- * @param {CSN.Model}   csn
- * @param {CSN.Options} [options]
- */
-function toHanaWithCsn(csn, options) {
-  timetrace.start('toHanaWithCsn');
-  // In case of API usage the options are in the 'options' argument
-  // put the OData specific options under the 'options.toHana' wrapper
-  // and leave the rest under 'options'
-  if (options && !options.toHana) {
-    _wrapRelevantOptionsForCmd(options, 'toHana');
-  }
-  // Provide defaults and merge options with those from model
-  options = mergeOptions({ toHana : getDefaultBackendOptions().toHana }, options);
-
-  // Provide something to generate if nothing else was given (conditional default)
-  if (!options.toHana.src && !options.toHana.csn) {
-    options.toHana.src = true;
-  }
-
-  const { warning } = makeMessageFunction(csn, options, 'to.hdbcds');
-
-  // Verify options
-  optionProcessor.verifyOptions(options, 'toHana', true).forEach(complaint => warning(null, null, `${complaint}`));
-
-  // Special case: For naming variant 'hdbcds' in combination with 'toHana' (and only there!), 'forHana'
-  // must leave namespaces, structs and associations alone.
-  if (options.toHana.names === 'hdbcds') {
-    options = mergeOptions(options, { forHana : { keepNamespaces: true, keepStructsAssocs: true } });
-  }
-
-  options = mergeOptions(options, { forHana: { dialect: 'hana' } }, { forHana : options.toHana });
-
-  // Prepare model for HANA (transferring the options to forHana, and setting 'dialect' to 'hana', because 'toHana' is only used for that)
-  let forHanaCsn = transformForHanaWithCsn(csn, options, 'to.hdbcds');
-
-  // Assemble result
-  let result = {};
-
-  if (options.toHana.src) {
-    if(options.testMode){
-      const sorted = sortCsn(forHanaCsn, options);
-      result = toHdbcdsSource(sorted, options);
-    } else {
-      result = toHdbcdsSource(forHanaCsn, options);
-    }
-  }
-
-  if (options.toHana.csn) {
-    result.csn = options.testMode ? sortCsn(forHanaCsn, options) : forHanaCsn;
-  }
-
-  timetrace.stop();
-  return result;
-}
-
 /**
  * Generate ODATA for `csn` using `options`.
  * The twin of the toOdata function but using CSN
@@ -603,7 +523,6 @@ function _wrapRelevantOptionsForCmd(options, command) {
 }
 
 module.exports = {
-  toHanaWithCsn,
   toOdataWithCsn,
   preparedCsnToEdmx,
   preparedCsnToEdmxAll,

package/lib/base/keywords.js

@@ -194,7 +194,7 @@ module.exports = {
     'OTHERS',
     'TIES',
   ],
-  // HANA keywords, used to warn in 'toSql' renderer with dialect 'hana' or in 'toHana' renderer (both with 'plain' names only)
+  // HANA keywords, used for smart quoting in to-hdi.plain
   // Taken from https://help.sap.com/viewer/7c78579ce9b14a669c1f3295b0d8ca16/Cloud/en-US/28bcd6af3eb6437892719f7c27a8a285.html
   // Better use keywords in ptime/query/parser/syntax/qp_keyword.cc minus those
   // in rule unreserved_keyword_column (=…_common - "CONSTRAINT") in
@@ -673,5 +673,35 @@ module.exports = {
     'WITHIN',
     'XMLTABLE',
     'YEAR'
-  ]  
+  ],
+  // HANA CDS keywords, used for smart quoting in to-hdbcds.plain
+  hdbcds: [
+    'ALL',                'ALTER',             'AS',
+    'BEFORE',             'BEGIN',             'BOTH',
+    'CASE',               'CHAR',              'CONDITION',
+    'CONNECT',            'CROSS',             'CUBE',
+    'CURRENT_CONNECTION', 'CURRENT_DATE',      'CURRENT_SCHEMA',
+    'CURRENT_TIME',       'CURRENT_TIMESTAMP', 'CURRENT_USER',
+    'CURRENT_UTCDATE',    'CURRENT_UTCTIME',   'CURRENT_UTCTIMESTAMP',
+    'CURRVAL',            'CURSOR',            'DECLARE',
+    'DISTINCT',           'ELSE',              'ELSEIF',
+    'ELSIF',              'END',               'EXCEPT',
+    'EXCEPTION',          'EXEC',              'FOR',
+    'FROM',               'FULL',              'GROUP',
+    'HAVING',             'IF',                'IN',
+    'INNER',              'INOUT',             'INTERSECT',
+    'INTO',               'IS',                'JOIN',
+    'LEADING',            'LEFT',              'LIMIT',
+    'LOOP',               'MINUS',             'NATURAL',
+    'NEXTVAL',            'NULL',              'ON',
+    'ORDER',              'OUT',               'OUTER',
+    'PRIOR',              'RETURN',            'RETURNS',
+    'REVERSE',            'RIGHT',             'ROLLUP',
+    'ROWID',              'SELECT',            'SET',
+    'SQL',                'START',             'SYSDATE',
+    'SYSTIME',            'SYSTIMESTAMP',      'SYSUUID',
+    'TOP',                'TRAILING',          'UNION',
+    'USING',              'VALUES',            'WHEN',
+    'WHERE',              'WHILE',             'WITH'
+  ]
 }

package/lib/base/location.js

@@ -14,9 +14,9 @@ const { copyPropIfExist } = require('../utils/objectUtils');
  * @returns {CSN.Location}
  */
 function combinedLocation( start, end ) {
-  if (!start)
+  if (!start || !start.location)
     return end.location;
-  else if (!end)
+  else if (!end || !end.location)
     return start.location;
   const loc = {
     file: start.location.file,

package/lib/base/message-registry.js

@@ -1,5 +1,33 @@
 // Central registry for messages.
 
+// `centralMessages` contains all details of a message-id except its standard texts
+// (`standardTexts` exists for that).  Only `severity` is required, all other
+// properties are optional.
+
+// The user can specify "severity wishes" via the option `severities`.  Errors
+// that don't have a `configurableFor` property cannot be reclassified by
+// users.  If a module is used that is _not_ listed in `configurableFor` (if it
+// is an array) property of the message then the message cannot be
+// reclassified.
+
+// We also allow `configurableFor` to have value `true` for errors which are
+// always configurable; useful for issues like deprecated syntax variants which
+// do not affect the compiler or CSN processors.  Temporarily, we also allow
+// value `deprecated` for errors which are only configurable if the option
+// `deprecated.downgradableErrors` is set.
+
+// Messages other than errors can always be reclassified by the user except if
+// the module is listed in the message's `errorFor` property.
+
+// __NEW__: If the future `poc` (proof of concept) or `sloppy` option is set,
+// the module name `compile` is added to all configurable messages, i.e. to all
+// `configurableFor` arrays.  (module `compile` includes all parsers and the
+// core compiler).  This allows creators of _non-productive models_ to
+// reclassify errors which usually cannot be reclassified, and continue the
+// compilation but has the side effect that the result may be unstable, hence
+// "sloppy": with an upcoming _minor_ version of the compiler, the compilation
+// might lead to an error anyway or the compiled CSN might look different.
+
 'use strict';
 
 /**
@@ -59,13 +87,15 @@ const centralMessages = {
   'param-default': { severity: 'Error', configurableFor: 'deprecated' }, // not supported yet
 
   'query-undefined-element': { severity: 'Error' },
+  'query-unexpected-assoc-hdbcds': { severity: 'Error' },
+  'query-unexpected-structure-hdbcds': { 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
   'type-ambiguous-target': { severity: 'Warning' },
 
   'ref-autoexposed': { severity: 'Error', configurableFor: 'deprecated' },
-  'ref-undefined-art':    { severity: 'Error' }, // TODO: Remove if shared.js uses makeMessageFunction()
+  'ref-undefined-art':    { severity: 'Error' },
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
@@ -100,13 +130,21 @@ const centralMessages = {
   'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
   'unmanaged-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
-  'odata-spec-violation-constraints': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-array':  { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
+  'odata-spec-violation-type': { severity: 'Error', configurableFor: [ 'to.edmx' ] },
+  '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
 };
 
 // For messageIds, where no text has been provided via code (central def)
 const centralMessageTexts = {
+  'anno-mismatched-ellipsis': 'An array with $(CODE) can only be used if there is an assignment below with an array value',
+  'anno-unexpected-ellipsis': 'Unexpected $(CODE) in annotation assignment',
+  'missing-type-parameter': 'Missing value for type parameter $(NAME) in reference to type $(ID)',
   '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)',
@@ -187,6 +225,10 @@ const centralMessageTexts = {
   'expected-target': 'An entity or an aspect is expected here',
   'extend-columns': 'Artifact $(ART) can\'t be extended with columns, only projections can',
   'extend-repeated-intralayer': 'Unstable element order due to repeated extensions in same layer',
+
+  'query-unexpected-assoc-hdbcds': 'Publishing a managed association in a view is not possible for “hdbcds” naming mode',
+  'query-unexpected-structure-hdbcds': 'Publishing a structured element in a view is not possible for “hdbcds” naming mode',
+
   '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',
   'ref-sloppy-target': 'An entity or an aspect (not type) is expected here',
@@ -200,9 +242,29 @@ const centralMessageTexts = {
   },
 
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
-  'odata-spec-violation-attribute': 'EDM Property $(NAME) has no attribute $(PROP)',
-  'odata-spec-violation-property-name': 'EDM Property $(NAME) must not have the same name as the declaring $(TYPE)',
 
+  // 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)',
+  // version independent messages
+  'odata-spec-violation-key-array': {
+    std: 'Unexpected array type for element $(NAME)',
+    scalar: 'Unexpected array type'
+  },
+  'odata-spec-violation-key-null': {
+    std: 'Expected key element $(NAME) to be not nullable', // structured
+    scalar: 'Expected key element to be not nullable' // flat
+  },
+  'odata-spec-violation-key-type': {
+    std: 'Unexpected $(TYPE) mapped to $(ID) as type for key element $(NAME)', // structured
+    scalar: 'Unexpected $(TYPE) mapped to $(ID) as type for key element' // flat
+  },
+  'odata-spec-violation-type': 'Expected element to have a type',
+  '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)',
 }
 
 /**

package/lib/base/messages.js

@@ -1,5 +1,7 @@
 // Functions and classes for syntax messages
 
+// See internalDoc/ReportingMessages.md and lib/base/message-registry.js for details.
+
 'use strict';
 
 const term = require('../utils/term');
@@ -92,14 +94,17 @@ class CompilationError extends Error {
 
     /** @type {boolean} model */
     this.hasBeenReported = false; // TODO: remove this bin/cdsc.js specifics
-    // TODO: remove property `model`
+    // 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.errors.map( m => m.toString() ).join('\n');
+      : this.message + '\n' + this.messages.map( m => m.toString() ).join('\n');
   }
+  /**
+   * @deprecated Use `.messages` instead.
+   */
   get errors() {
     return this.messages;
   }
@@ -210,6 +215,7 @@ const severitySpecs = {
  * @returns {CSN.MessageSeverity}
  *
  * TODO: we should pass options as usual
+ * TODO: should be part of the returned function
  */
 function reclassifiedSeverity( id, severity, severities, moduleName, deprecatedDowngradable ) {
   const spec = centralMessages[id] || { severity };
@@ -294,6 +300,30 @@ function searchForLocation( model, path ) {
   return lastLocation;
 }
 
+/**
+ * Create the `message` functions to emit messages.
+ * See internalDoc/ReportingMessages.md for detail
+ *
+ * @example
+ * ```
+ *   const { createMessageFunctions } = require(‘../base/messages’);
+ *   function module( …, options ) {
+ *     const { message, info, throwWithError } = createMessageFunctions( options, moduleName );
+ *     // [...]
+ *     message( 'message-id', <location>, <text-arguments>, <severity>, <text> );
+ *     info( 'message-id', <location>, [<text-arguments>,] <text> );
+ *     // [...]
+ *     throwWithError();
+ *   }
+ * ```
+ * @param {CSN.Options} [options]
+ * @param {string} [moduleName]
+ * @param {object} [model=null] the CSN or XSN model, used for convenience
+ */
+function createMessageFunctions( options, moduleName, model = null ) {
+  return makeMessageFunction( model, options, moduleName, true );
+}
+
 /**
  * Create the `message` function to emit messages.
  *
@@ -312,8 +342,9 @@ function searchForLocation( model, path ) {
  * @param {object} model
  * @param {CSN.Options} [options]
  * @param {string} [moduleName]
+ * @param {boolean} [throwOnlyWithNew=false] behave like createMessageFunctions
  */
-function makeMessageFunction( model, options = model.options || {}, moduleName = null ) {
+function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNew = false ) {
   // ensure message consistency during runtime with --test-mode
   if (options.testMode)
     _check$Init( options );
@@ -327,11 +358,12 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
    *
    * @type {CSN.Message[]}
    */
-  let messages = options && options.messages || [];
-
+  let messages = options.messages || [];
+  let hasNewError = false;
   return {
-    message, error, warning, info, debug,
-    messages, throwWithError, callTransparently
+    message, error, warning, info, debug, messages,
+    throwWithError: (throwOnlyWithNew ? throwWithError : throwWithAnyError),
+    callTransparently, moduleName,
   };
 
   function _message(id, location, textOrArguments, severity, texts = null) {
@@ -342,7 +374,6 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
       texts = { std: textOrArguments };
       textOrArguments = {};
     }
-
     if (id) {
       if (options.testMode && !options.$recompile)
         _check$Consistency( id, moduleName, severity, texts, options )
@@ -360,6 +391,8 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
       msg.$location.address = { definition };
 
     messages.push( msg );
+    hasNewError = hasNewError || msg.severity === 'Error' &&
+      !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
     if (!hasMessageArray)
       console.error( messageString( msg ) );
     return msg;
@@ -488,6 +521,11 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
     return _message(id, location, textOrArguments, 'Debug', texts);
   }
 
+  function throwWithError() {
+    if (hasNewError)
+      throw new CompilationError( messages, options.attachValidNames && model );
+  }
+
   /**
    * Throws a CompilationError exception if there is at least one error message
    * in the model's messages after reclassifying existing messages according to
@@ -495,22 +533,20 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
    * If `--test-mode` is enabled, this function will only throw if the
    * error *cannot* be downgraded to a warning.  This is done to ensure that
    * developers do not rely on certain errors leading to an exception.
-   *
-   * @param {CSN.Message[]} [msgs] Which messages to check for. Default: The ones of
-   *                               this makeMessageFunction() scope.
    */
-  function throwWithError(msgs = messages) {
-    if (!msgs || !msgs.length)
+  function throwWithAnyError() {
+    if (!messages || !messages.length)
       return;
-    reclassifyMessagesForModule(msgs, severities, moduleName); // TODO: no, at the beginning of the module
+    reclassifyMessagesForModule( messages, severities, moduleName ); // TODO: no, at the beginning of the module
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
-    if (hasError( msgs, moduleName ))
-      throw new CompilationError( msgs, options.attachValidNames && model );
+    if (hasError( messages, moduleName ))
+      throw new CompilationError( messages, options.attachValidNames && model );
   }
 
   /**
    * Collects all messages during the call of the callback function instead of
    * storing them in the model. Returns the collected messages.
+   * Not yet in use.
    *
    * @param {Function} callback
    * @param  {...any} args
@@ -612,6 +648,10 @@ const paramsTransform = {
   keyword: quote.word,
   // more complex convenience:
   names: transformManyWith( quoted ),
+  number: n => n,
+  line: l => l,
+  col: c => c,
+  literal: l => l,
   art: transformArg,
   service: transformArg,
   sorted_arts: transformManyWith( transformArg, true ),
@@ -621,8 +661,13 @@ const paramsTransform = {
   offending: tokenSymbol,
   expecting: transformManyWith( tokenSymbol ),
   // msg: m => m,
+  $reviewed: ignoreTextTransform,
 };
 
+function ignoreTextTransform() {
+  return null;
+}
+
 function transformManyWith( t, sorted ) {
   return function transformMany( many, r, args, texts ) {
     const prop = ['none','one'][ many.length ];
@@ -766,7 +811,7 @@ function weakLocation( loc ) {
  * Return message string with location if present in compact form (i.e. one line)
  *
  * Example:
- *   <source>.cds:3:11: Error: cannot find value `nu` in this scope *
+ *   <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 {boolean} [normalizeFilename]
@@ -803,12 +848,15 @@ function messageHash(msg) {
 }
 
 /**
- * Return message string with location if present.
+ * Returns a message string with file- and semantic location if present
+ * in multiline form.
  *
  * Example:
- *   Error: cannot find value `nu` in this scope
- *     <source>.cds:3:11, at entity:“E”
- *
+ * ```txt
+ * Error[message-id]: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
+ *    |
+ *   <source>.cds:3:11, at entity:“E”
+ * ```
  * @param {CSN.Message} err
  * @param {object} [config = {}]
  * @param {boolean} [config.normalizeFilename] Replace windows `\` with forward slashes `/`.
@@ -983,12 +1031,12 @@ function homeSortName( { home, messageId } ) {
 
 /**
  * Removes duplicate messages from the given messages array without destroying
- * references to the array.
+ * references to the array, i.e. removes them in-place.
  *
- * Does NOT keep the original order!
+ * _Note_: Does NOT keep the original order!
  *
  * Two messages are the same if they have the same message hash. See messageHash().
- * If one of the two is more precise then it replaces the other.
+ * If one of the two is more precise, then it replaces the other.
  * A message is more precise if it is contained in the other or if
  * the first does not have an endLine/endCol.
  *
@@ -1187,7 +1235,10 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
         if (!csnPath[index + 1]) {
           result += select();
         }
-        else if (queryProps.includes(csnPath[index + 1]) && !csnPath[index + 2]) {
+        // only print last query prop for paths like
+        // [... 'query', 'SELECT', 'from', 'SELECT', 'elements', 'struct'] -> select:2/element:"struct"
+        // no from in the semantic location in this case
+        else if (queryProps.includes(csnPath[index + 1]) && (!csnPath[index + 2] || query.isOnlySelect)) {
           const clause = csnPath[index + 1];
           result += select();
           result += `/${ clause }`;
@@ -1199,6 +1250,11 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
         inColumn = true;
         inQuery = false;
       }
+      else if (inElement) {
+        result += select();
+        elements.push(step);
+        inQuery = false;
+      }
     }
     else if ( inMixin ) {
       if (step === 'on') {
@@ -1251,7 +1307,7 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
         if (currentThing.as)
           result += `:${ _quoted(currentThing.as) }`;
         else
-          result += inRef ? `:${ _quoted(currentThing) }` : currentThing.ref ? `:${ _quoted(currentThing.ref.join('.')) }` : '';
+          result += inRef ? `:${ _quoted(currentThing) }` : currentThing.ref ? `:${ _quoted(currentThing.ref.map(r => r.id ? r.id : r).join('.')) }` : '';
 
         break;
       }
@@ -1310,7 +1366,7 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
     let totalQueryDepth = 0;
 
     let isFound = false;
-    traverseQuery(rootQuery, null, (q, querySelect) => {
+    traverseQuery(rootQuery, null, null, (q, querySelect) => {
       if ( querySelect )
         totalQueryDepth += 1;
       if ( querySelect && !isFound)
@@ -1365,6 +1421,7 @@ module.exports = {
   messageStringMultiline,
   messageContext,
   searchName,
+  createMessageFunctions,
   makeMessageFunction,
   artName,
   handleMessages,