@sap/cds-compiler 3.3.2 → 3.4.0

package/lib/base/message-registry.js

@@ -37,7 +37,11 @@ const { createDict } = require("../utils/objectUtils");
  * Central register of messages and their configuration.
  * Group by id-category.
  *
- * configurableFor: 'deprecated' = severity can only be changed with deprecated.downgradableErrors
+ * configurableFor: truthy = error can be downgraded in certain situations
+ *  - true = can always be downgraded, we do not really care
+ *  - [‹module›, …] = can be downgraded in compiler function ‹module›
+ *  - 'deprecated' = severity can only be changed with deprecated.downgradableErrors
+ *  - 'v3' = currently like true, but should be 'deprecated' in v4
  *
  * @type {Object<string, MessageConfig>}
  */
@@ -74,12 +78,11 @@ const centralMessages = {
 
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
-  // Structured types were warned about but made CSN un-recompilable.
-  'enum-invalid-type': { severity: 'Error', configurableFor: 'deprecated' },
-
   // TODO: rename to ref-expected-XYZ
   'expected-type': { severity: 'Error' },
   'ref-sloppy-type': { severity: 'Error' },
+  'ref-unexpected-self': { severity: 'Error' },
+  'ref-expecting-bare-aspect': { 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 },
@@ -124,13 +127,10 @@ const centralMessages = {
   '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' },
-  'rewrite-key-not-matched-explicit': { severity: 'Error', configurableFor: 'deprecated' },
-  'rewrite-key-not-matched-implicit': { severity: 'Error', configurableFor: 'deprecated' },
-  'rewrite-key-for-unmanaged': { severity: 'Error', configurableFor: 'deprecated' },
-  'rewrite-not-supported': { severity: 'Error' },
-  'rewrite-on-for-managed': { severity: 'Error', configurableFor: 'deprecated' },
+  'rewrite-key-not-covered-explicit': { severity: 'Error' },
+  'rewrite-key-not-covered-implicit': { severity: 'Error' },
+  'rewrite-key-not-matched-explicit': { severity: 'Error' },
+  'rewrite-key-not-matched-implicit': { severity: 'Error' },
 
   'service-nested-context': { severity: 'Error', configurableFor: true }, // does not hurt compile, TODO
   'service-nested-service': { severity: 'Error', configurableFor: 'deprecated' }, // not supported yet
@@ -141,24 +141,13 @@ const centralMessages = {
   // 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-unexpected-property': { severity: 'Error' },
   'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
   'syntax-fragile-alias': { severity: 'Error', configurableFor: true },
   'syntax-fragile-ident': { severity: 'Error', configurableFor: true },
-
-  'syntax-invalid-extend': { severity: 'Error' },
-
-  'syntax-invalid-text-block' : { severity: 'Error' },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
-  'syntax-invalid-escape': { severity: 'Error' },
-  'syntax-missing-escape': { severity: 'Error' },
 
-  'syntax-expected-integer': { severity: 'Error' },
-  'syntax-invalid-masked': { severity: 'Error', configurableFor: true },
+  'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'v3' },
   'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
 
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
@@ -212,7 +201,10 @@ for (const oldName in oldMessageIds) {
 }
 
 
-// For messageIds, where no text has been provided via code (central def)
+// For messageIds, where no text has been provided via code (central def).
+// DO NOT CHANGE THE VARIABLE NAME!
+// If you change it, keep in sync with scripts/eslint/rules/message-text.js
+
 const centralMessageTexts = {
   'api-invalid-option': {
     // TODO: too many different error situations for one message id,
@@ -239,42 +231,118 @@ const centralMessageTexts = {
     '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 messages, both CDL and CSN parser: ----------------------------------
+  'syntax-dollar-ident': {      // Warning, TODO: make it name-invalid-alias
+    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-duplicate-excluding' (TODO: also CDL)
   'syntax-ignoring-anno': {
     std: 'Annotations can\'t be used at prefix references',
     doc: 'Doc comments can\'t be used at prefix references',
   },
+  'syntax-invalid-name': {
+    std: 'Identifier for name must not be empty', // TODO: use
+    csn: 'Property name in dictionary $(PARENTPROP) must not be empty',
+  },
+  'syntax-invalid-literal': {   // TODO: write texts less CDL specific
+    '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': 'Expecting time\'hh:mm:ss\' where hh, mm and the optional ss are numbers',
+    'date': 'Expecting date\'YYYY-MM-DD\' where YYYY, MM and DD are numbers',
+    'timestamp': 'Expecting 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-missing-ellipsis': 'Expecting an array item $(NEWCODE) after an item with $(CODE)',
   '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' ,
+    std: 'Unexpected array item $(CODE)',
+    duplicate: 'Unexpected array item $(CODE) after previous $(CODE) without $(KEYWORD)',
+    'csn-duplicate': 'Unexpected object with property $(PROP) after previous array item $(CODE)',
+    'csn-nested': 'Unexpected object with property $(PROP) in nested array',
+  },
+  'syntax-unsupported-masked': { // configurable Error
+    std: 'The keyword $(KEYWORD) is not supported',
+    csn: 'The property $(PROP) is not supported',
   },
-  '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',
+
+  // Syntax messages, CDL parser - default: Error  ------------------------------
+  '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-extend': 'Can\'t extend an element with $(KIND)',
   'syntax-invalid-text-block': 'Missing newline in text block',
+  'syntax-unsupported-param': {
+    std: 'Parameter not supported', // unused
+    dynamic: 'Dynamic parameter $(NAME) is not supported',
+    positional: 'Positional parameter $(NAME) is not supported',
+  },
+
+  // Syntax messages, CSN parser - default: Error  ------------------------------
+  // TODO: use one id with text variants instead of several message ids
+  'syntax-deprecated-property': {  // Warning
+    std: 'Deprecated property $(PROP)', // unused
+    'zero': 'Deprecated CSN v0.1.0 property $(PROP) is ignored',
+    'zero-replace': 'Replace CSN v0.1.0 property $(PROP) by $(OTHERPROP)',
+  },
+  'syntax-deprecated-value': {  // Warning
+    std: 'Deprecated representation of the value in property $(PROP)',
+    replace: 'Replace value in $(PROP) by $(VALUE)',
+    'zero-parens': 'Deprecated CSN v.0.1.0 representation of expressions in parentheses',
+    'zero-replace': 'Replace CSN v0.1.0 value in $(PROP) by $(VALUE)',
+  },
+
+  'syntax-expecting-object': 'Expecting object for property $(PROP)',
+  'syntax-expecting-column': 'Expecting object or string \'*\' for property $(PROP)',
+  'syntax-expecting-natnum': 'Expecting non-negative number for property $(PROP)',
+  'syntax-expecting-cardinality': 'Expecting non-negative number or string \'*\' for property $(PROP)',
+  'syntax-expecting-reference': 'Expecting non-empty string or object for property $(PROP)',
+  'syntax-expecting-term': 'Expecting non-empty string or object for property $(PROP)',
+  // 'syntax-expecting-string', 'syntax-expecting-boolean' (Warning), 'syntax-expecting-scalar',
+  // 'syntax-expecting-args', 'syntax-expecting-translation', 'syntax-expecting-array'
+  'syntax-incomplete-array': {  // location at ']'
+    std: 'Expecting array in $(PROP) to have at least $(N) items',
+    one: 'Expecting array in $(PROP) to have at least one item',
+    suffix: 'With sibling property $(SIBLINGPROP), expecting array in $(PROP) to have at least one item',
+  },
+  'syntax-incomplete-object': { // location at '}'
+    std: 'Object in $(PROP) must have at least one valid CSN property',
+    as: 'Object in $(PROP) must have at least one valid CSN property other than $(OTHERPROP)',
+  },
+  // 'syntax-invalid-ref' (Warning?), 'syntax-invalid-kind', 'syntax-invalid-literal' (Warning)
+  'syntax-invalid-string': {
+    std: 'Invalid string value in property $(PROP)',
+  },
+  'syntax-missing-property': {  // location at sibling or '}' otherwise
+    std: 'Object in $(PARENTPROP) must have the property $(PROP)',
+    sibling: 'Object with property $(SIBLINGPROP) must also have a property $(PROP)',
+    columns: 'Object in $(PARENTPROP) must have an expression property like $(PROP)',
+    extensions: 'Object in $(PARENTPROP) must have the property $(PROP) or $(OTHERPROP)',
+  },
+  'syntax-unexpected-property': {
+    std: 'Unexpected CSN property $(PROP)',
+    sibling: 'CSN property $(PROP) is not expected in an object with property $(SIBLINGPROP)',
+    prop: 'CSN property $(PROP) is not expected in $(PARENTPROP)',
+    top: 'CSN property $(PROP) is not expected top-level',
+    kind: 'CSN property $(PROP) is not expected by a definition of kind $(KIND)',
+    extend: 'CSN property $(PROP) is not expected by an extend in $(PARENTPROP)',
+    annotate: 'CSN property $(PROP) is not expected by an annotate in $(PARENTPROP)',
+  },
+  // 'syntax-unknown-property' (Warning? Better configurable Error)
+
   'syntax-unknown-escape': 'Unknown escape sequence $(CODE)',
   'syntax-invalid-escape': {
     std: 'Invalid escape sequence $(CODE)',
     octal: 'Octal escape sequences are not supported. Use unicode escapes instead',
     whitespace: 'Unknown escape sequence: Can\'t escape whitespace',
     codepoint: 'Undefined code-point for $(CODE)',
-    'unicode-hex': 'Expected hexadecimal numbers for unicode escape but found $(CODE)',
-    'hex-count': 'Expected $(NUMBER) hexadecimal numbers for escape sequence but found $(CODE)',
+    'unicode-hex': 'Expecting hexadecimal numbers for unicode escape but found $(CODE)',
+    'hex-count': 'Expecting $(NUMBER) hexadecimal numbers for escape sequence but found $(CODE)',
     'unicode-brace': 'Missing closing brace for unicode escape sequence',
     'language-identifier': 'Escape sequences in text-block\'s language identifier are not allowed',
   },
@@ -282,41 +350,34 @@ const centralMessageTexts = {
     std: 'Missing escape. Replace $(CODE) with $(NEWCODE)',
     placeholder: 'Placeholders are not supported. Replace $(CODE) with $(NEWCODE)',
   },
-  'syntax-expected-integer': {
+  'syntax-expecting-integer': {
     std: 'A safe integer is expected here',
     normal: 'An integer number is expected here',
     unsafe: 'The provided integer is too large',
   },
-  'syntax-duplicate-argument': {
+  'syntax-duplicate-argument': { // TODO: also CDL
     std: 'Unexpected argument $(CODE)',
-    unknown: 'Unknown argument $(CODE)',
+    unknown: 'Unknown argument $(CODE)', // huh?
     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',
   },
+  'syntax-fragile-ident': '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it',
+  'syntax-unsupported-field': 'Calculated fields are not supported, yet',
+
+  // Syntax messages for errorneous references ----------------------------------
+  // location at errorneous reference (if possible)
+  'ref-unexpected-self': 'Unexpected $(ID) reference; is valid only in ON-conditions',
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
-    element: 'Artifact $(ART) has no element $(MEMBER)'
+    element: 'Artifact $(ART) has no element $(MEMBER)',
   },
+  'ref-undefined-param': 'Entity $(ART) has no parameter $(ID)',
   'ref-undefined-art': 'No artifact has been found with name $(NAME)',
   // TODO: proposal 'No definition found for $(NAME)',
   'ref-undefined-element': {
@@ -324,6 +385,7 @@ const centralMessageTexts = {
     element: 'Artifact $(ART) has no element $(MEMBER)',
     aspect: 'Element $(ID) has not been found in the anonymous target aspect'
   },
+  'ref-undefined-var': 'Element or variable $(ID) has not been found',
   'ref-unknown-var': {
     std: 'No replacement found for special variable $(ID)'
   },
@@ -416,7 +478,8 @@ 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',
-
+  'extend-unexpected-include': 'Can\'t extend $(KIND) with includes',
+  'ref-expecting-bare-aspect': 'An aspect without elements is expected here',
 
   'ext-duplicate-extend-type': 'Duplicate type extension for type $(TYPE)',
   'ext-duplicate-extend-type-unrelated-layer': 'Duplicate type extension for type $(TYPE)',
@@ -424,9 +487,9 @@ const centralMessageTexts = {
     std: 'Property $(PROP) can only be extended',
     'new-prop': 'Property $(PROP) can only be extended, not added',
     // eslint-disable-next-line max-len
-    smaller: 'Property $(PROP) can only be extended, but $(LITERAL) is smaller than $(NUMBER) of type definition',
+    smaller: 'Property $(PROP) can only be extended, but $(VALUE) is smaller than $(NUMBER) of type definition',
     // eslint-disable-next-line max-len
-    'ext-smaller': 'Property $(PROP) can only be extended, but extended value $(LITERAL) is smaller than $(NUMBER) from previous type extension',
+    'ext-smaller': 'Property $(PROP) can only be extended, but extended value $(VALUE) is smaller than $(NUMBER) from previous type extension',
     prop: 'Type property $(PROP) can\'t be extended',
     scale: 'If property $(PROP) is increased, then so must $(OTHERPROP)',
     string: 'Only numerical properties can be extended, but found string for $(PROP)',
@@ -437,6 +500,10 @@ const centralMessageTexts = {
     inferred: 'Only direct types can be extended',
   },
 
+  'query-undefined-element': {
+    std: 'Element $(ID) has not been found in the elements of the query',
+    redirected: 'Element $(ID) has not been found in the elements of the query; please use REDIRECTED TO with an explicit ON-condition',
+  },
   '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',
   'query-ignoring-param-nullability': {
@@ -530,4 +597,6 @@ const centralMessageTexts = {
  *                                 Don't set this property directly! Append to object oldMessageIds instead!
  */
 
+//console.log('FOO')
+
 module.exports = { centralMessages, centralMessageTexts, oldMessageIds };

package/lib/base/messages.js

@@ -42,9 +42,10 @@ function hasErrors( messages ) {
  * @param {string} moduleName
  * @returns {boolean}
  */
-function hasNonDowngradableErrors( messages, moduleName ) {
-  return messages && messages.some( m => m.severity === 'Error' &&
-      (!m.messageId || !isDowngradable( m.messageId, moduleName )));
+function hasNonDowngradableErrors( messages, moduleName, deprecatedDowngradable ) {
+  return messages &&
+    messages.some( m => m.severity === 'Error' &&
+                   !isDowngradable( m.messageId, moduleName, deprecatedDowngradable ));
 }
 
 /**
@@ -54,10 +55,11 @@ function hasNonDowngradableErrors( messages, moduleName ) {
  *
  * @param {string} messageId
  * @param {string} moduleName
+ * @param {boolean} deprecatedDowngradable
  * @returns {boolean}
  */
-function isDowngradable( messageId, moduleName ) {
-  if (!centralMessages[messageId])
+function isDowngradable( messageId, moduleName, deprecatedDowngradable ) {
+  if (!messageId || !centralMessages[messageId])
     return false;
 
   const msg = centralMessages[messageId];
@@ -66,10 +68,12 @@ function isDowngradable( messageId, moduleName ) {
   // the module, it is NEVER downgradable.
   if (msg.errorFor && msg.errorFor.includes(moduleName))
     return false;
-
-  return (msg.severity !== 'Error' ||
-        msg.configurableFor === true || // useful with error for syntax variants
-        msg.configurableFor && msg.configurableFor.includes( moduleName ));
+  if (msg.severity !== 'Error')
+    return true;
+  const { configurableFor } = msg;
+  return (Array.isArray( configurableFor ))
+    ? configurableFor.includes( moduleName )
+    : configurableFor && (configurableFor !== 'deprecated' || deprecatedDowngradable);
 }
 
 /**
@@ -173,7 +177,7 @@ const severitySpecs = {
  * @param {boolean} deprecatedDowngradable
  * @returns {MessageSeverity}
  */
-function reclassifiedSeverity(msg, options, moduleName, deprecatedDowngradable ) {
+function reclassifiedSeverity( msg, options, moduleName, deprecatedDowngradable ) {
   const spec = centralMessages[msg.messageId] || { severity: msg.severity, configurableFor: null, errorFor: null };
   if (spec.severity === 'Error') {
     const { configurableFor } = spec;
@@ -350,7 +354,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
 
     messages.push( msg );
     hasNewError = hasNewError || msg.severity === 'Error' &&
-      !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
+      !(options.testMode && isDowngradable( msg.messageId, moduleName, deprecatedDowngradable ));
     if (!hasMessageArray)
       console.error( messageString( msg ) );
     return msg;
@@ -496,7 +500,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     if (!messages || !messages.length)
       return;
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
-    if (hasError( messages, moduleName ))
+    if (hasError( messages, moduleName, deprecatedDowngradable ))
       throw new CompilationError( messages, options.attachValidNames && model );
   }
 
@@ -514,7 +518,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
           // Re-set the module regardless of severity, since we reclassified it.
           Object.defineProperty( msg, '$module', { value: moduleName, configurable: true } );
           hasNewError = hasNewError || severity === 'Error' &&
-            !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
+            !(options.testMode && isDowngradable( msg.messageId, moduleName, deprecatedDowngradable ));
         }
       }
     }
@@ -602,7 +606,7 @@ function _check$Severities( id, moduleName, severity ) {
     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 (!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}"` );
   }
@@ -636,14 +640,12 @@ function _check$Texts( id, prop, value ) {
     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
-  name: n => `“${ n }”`,
-  prop: p => `‘${ p }’`,
-  file: f => `‘${ f }’`,
-  code: c => `«${ c }»`,
-  meta: m => `‹${ m }›`,
-  // TODO: probably use keyword as function name, but its name would not have length 4 :-(
-  word: w => w.toUpperCase(),   // keyword
+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
 }
 
 const paramsTransform = {
@@ -651,33 +653,38 @@ const paramsTransform = {
   name: quoted,
   id: quoted,
   alias: quoted,
-  anno: a => (a.charAt(0) === '@' ? quote.name( a ) : quote.name( '@' + a )),
-  delimited: n => '![' + n + ']',
-  file: quote.file,
-  prop: quote.prop,
-  otherprop: quote.prop,
-  code: quote.code,
-  newcode: quote.code,
-  kind: quote.meta,
-  keyword: quote.word,
+  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?
+  file: 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,
   // more complex convenience:
   names: transformManyWith( quoted ),
-  number: n => n,
-  line: l => l,
-  col: c => c,
-  literal: l => l,
+  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 )),
   art: transformArg,
   service: transformArg,
   sorted_arts: transformManyWith( transformArg, true ),
   target: transformArg,
+  source: transformArg,
   elemref: transformElementRef,
   type: transformArg,
   offending: tokenSymbol,
-  op: quote.prop,
+  op: quote.single,
   expecting: transformManyWith( tokenSymbol ),
   // msg: m => m,
   $reviewed: ignoreTextTransform,
-  version: quote.meta,
+  version: quote.single, // TODO delete: just use for OData $(VERSION), with version: 2.0
 };
 
 function ignoreTextTransform() {
@@ -700,20 +707,20 @@ function transformManyWith( t, sorted ) {
 }
 
 function quoted( name ) {
-  return (name) ? quote.name( name ) : '<?>'; // TODO: failure in --test-mode, then remove
+  return (name) ? quote.double( name ) : quote.angle( '?' ); // TODO: failure in --test-mode, then remove
 }
 
 function tokenSymbol( token ) {
   if (token.match( /^[A-Z][A-Z]/ )) // keyword
-    return quote.word( token );
+    return quote.upper( token );
   else if (token.match( /^[A-Z][a-z]/ )) // Number, Identifier, ...
-    return quote.meta( token );
+    return quote.angle( token );
   if (token.startsWith("'") && token.endsWith("'")) // operator token symbol
-    return quote.prop( token.slice( 1, -1 ));
+    return quote.single( token.slice( 1, -1 ));
   else if (token === '<EOF>')
-    return quote.meta( token.slice( 1, -1 ) );
+    return quote.angle( 'EOF' );
   else
-    return quote.code( token ); // should not happen
+    return quote.single( token ); // should not happen
 }
 
 /**
@@ -1107,7 +1114,7 @@ function shortArtName( art ) {
   const { name } = art;
   if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
-    return quote.name( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
+    return quote.double( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
   return artName( art );
 }
 
@@ -1230,11 +1237,15 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
 
   let { query } = analyseCsnPath(csnPath, model, false);
 
-  // remove definitions
-  csnPath.shift();
+  const dictName = csnPath.shift();
+  const dict = model[dictName];
   const artifactName = csnPath.shift();
-  let currentThing = model.definitions[artifactName];
-  let result = `${ (currentThing && currentThing.kind) ? currentThing.kind : 'artifact' }:${ _quoted(artifactName) }`;
+  let currentThing = dict ? dict[artifactName] : undefined;
+  let result = `${ (currentThing?.kind)
+    ? currentThing.kind
+    : (dictName === 'vocabularies'
+      ? 'annotation'
+      : 'artifact') }:${ _quoted(artifactName) }`;
 
   if (!currentThing)
     return result;

package/lib/base/model.js

@@ -28,6 +28,7 @@ const availableBetaFlags = {
   ignoreAssocPublishingInUnion: true,
   enableUniversalCsn: true,
   postgres: true,
+  aspectWithoutElements: true,
   // disabled by --beta-mode
   nestedServices: false,
   odataOpenType: true,

package/lib/checks/actionsFunctions.js

@@ -22,7 +22,7 @@ function checkActionOrFunction(art, artName, prop, path) {
 
   const serviceName = this.csnUtils.getServiceName(artName);
   if (!serviceName)
-    this.warning(null, path, {}, `Functions and actions must be declared in a service`);
+    this.warning(null, path, {}, 'Functions and actions must be declared in a service');
 
   if (art.kind === 'entity') {
     for (const [ actName, act ] of Object.entries(art.actions)) {

package/lib/checks/cdsPersistence.js

@@ -17,7 +17,7 @@ function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
     // TODO: Why not filter over persistenceAnnos, is shorter!
     const TableUdfCv = Object.keys(artifact).filter(p => persistenceAnnos.includes(p) && artifact[p]);
     if (TableUdfCv.length > 1)
-      this.error(null, path, {}, `Annotations ${ TableUdfCv.join(', ') } can't be used in combination`);
+      this.error(null, path, { annos: TableUdfCv }, 'Annotations $(ANNOS) can\'t be used in combination');
   }
 }
 

package/lib/checks/checkForTypes.js

@@ -12,26 +12,30 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  */
 function checkForHanaTypes(parent, name, type, path) {
   const artifact = this.csn.definitions[path[1]];
-  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && typeof parent.type === 'string' && parent.type.startsWith('cds.hana.'))
-    this.error('ref-unexpected-hana-type', [ ...path, 'type' ], {}, `Types in the ”cds.hana“ namespace can't be used with sqlDialect “postgres”`);
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && typeof parent.type === 'string' && parent.type.startsWith('cds.hana.')) {
+    this.error('ref-unexpected-hana-type', [ ...path, 'type' ], { type: 'cds.hana', value: this.options.sqlDialect },
+               'Types in the $(TYPE) namespace can\'t be used with sqlDialect $(VALUE)');
+  }
 }
 
 /**
- * Check that `cds.UInt8`is not used - we don't have a clear idea how to represent it on postgres
+ * Check that `cds.UInt8` is not used - we don't have a clear idea how to represent it on postgres and h2
  *
  * @param {object} parent Object with a type
  * @param {string} name Name of the type property on parent
  * @param {Array} type type to check
  * @param {CSN.Path} path
  */
-function checkForUInt8(parent, name, type, path) {
+function CheckForUInt8(parent, name, type, path) {
   const artifact = this.csn.definitions[path[1]];
-  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && parent.type === 'cds.UInt8')
-    this.error('ref-unexpected-type', [ ...path, 'type' ], {}, `Type ”cds.UInt8“ can't be used with sqlDialect “postgres”`);
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && parent.type === 'cds.UInt8') {
+    this.error('ref-unexpected-type', [ ...path, 'type' ], { type: 'cds.UInt8', value: this.options.sqlDialect },
+               'Type $(TYPE) can\'t be used with sqlDialect $(VALUE)');
+  }
 }
 
 /**
- * Check types - specifically for postgres
+ * Check types - specifically for postgres and h2
  *
  * @param {object} parent Object with a type
  * @param {string} name Name of the type property on parent
@@ -40,7 +44,8 @@ function checkForUInt8(parent, name, type, path) {
  */
 function checkTypes(parent, name, type, path) {
   checkForHanaTypes.bind(this)(parent, name, type, path);
-  checkForUInt8.bind(this)(parent, name, type, path);
+  if (this.options.sqlDialect === 'postgres' || this.options.sqlDialect === 'h2')
+    CheckForUInt8.bind(this)(parent, name, type, path);
 }
 
 module.exports = {

package/lib/checks/defaultValues.js

@@ -20,8 +20,10 @@ function validateDefaultValues(member, memberName, prop, path) {
       // consume all unary signs
       while (member.default.xpr[i] === '-' || member.default.xpr[i] === '+')
         i++;
+      // TODO: This check only counts the number of leading signs, not inbetween (e.g. 1 - - 1).
+      //       The message also needs to be improved.
       if (i > 1)
-        this.error(null, path, {}, `Illegal number of unary '+/-' operators`);
+        this.error(null, path, {}, 'Illegal number of unary ‘+’/‘-’ operators');
     }
   }
 }

package/lib/checks/elements.js

@@ -93,7 +93,7 @@ function checkPrimaryKey(art) {
 function checkVirtualElement(member) {
   if (member.virtual) {
     if (this.csnUtils.isAssociation(member.type)) { // or Composition ???
-      this.error(null, member.$path, {}, `Element can't be virtual and an association`);
+      this.error(null, member.$path, {}, 'Element can\'t be virtual and an association');
     }
   }
 }