@sap/cds-compiler 3.9.4 → 4.0.2

package/lib/base/message-registry.js

@@ -41,7 +41,7 @@ const { createDict } = require('../utils/objectUtils');
  *  - 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
+ *  - 'v4' = currently like true, but should be 'deprecated' in v5
  *
  * @type {Object<string, MessageConfig>}
  */
@@ -52,6 +52,7 @@ const centralMessages = {
   '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-calc': { 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"
   'anno-invalid-sql-view': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view-element': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
@@ -60,41 +61,47 @@ const centralMessages = {
   'anno-undefined-def':     { severity: 'Warning' }, // for annotate statement (for CSN or CDL path cont)
   'anno-undefined-element': { severity: 'Warning' },
   'anno-undefined-param':   { severity: 'Warning' },
-  'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'v3' },
+  'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
 
-  'args-expected-named':  { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
-  'args-no-params':       { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
-  'args-undefined-param': { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
+  'args-expecting-named':  { severity: 'Error' },
+  'args-no-params':       { severity: 'Error' },
+  'args-undefined-param': { severity: 'Error' },
 
-  'assoc-in-array': { severity: 'Error', configurableFor: 'deprecated' }, // not supported yet
-  'assoc-as-type':  { severity: 'Error', configurableFor: 'deprecated' }, // TODO: allow more, but not all
+  'name-invalid-dollar-alias': { severity: 'Error', configurableFor: true },
+
+  'type-invalid-items': { severity: 'Error' }, // not supported yet
+  'assoc-as-type':  { severity: 'Error' }, // TODO: allow more, but not all
   'def-unexpected-paramview-assoc': { severity: 'Error' },
   'def-unexpected-calcview-assoc': { severity: 'Error' },
   'chained-array-of': { severity: 'Error' },
   'check-proper-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
   'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
 
-  'expr-no-filter': { severity: 'Error', configurableFor: 'deprecated' },
+  'def-duplicate-autoexposed': { severity: 'Error' },
+  'def-unexpected-default': { severity: 'Error', configurableFor: 'test' },
+
+  'expr-no-filter': { severity: 'Error' },
 
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
-  // TODO: rename to ref-expected-XYZ
-  'expected-type': { severity: 'Error' },
+  'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
+  'ref-expecting-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-unexpected-typeof': { severity: 'Error' },
   'type-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
-  'expected-actionparam-type': { severity: 'Error' },
+  'type-expecting-service-target': { severity: 'Error', configurableFor: true },
+  'ref-expecting-action-param-type': { severity: 'Error' },
   'ref-sloppy-actionparam-type': { severity: 'Error' },
-  'expected-event-type': { severity: 'Error' },
+  'ref-expecting-event-type': { severity: 'Error' }, // TODO: Test coverage
   'ref-sloppy-event-type': { severity: 'Error' },
-  'expected-struct': { severity: 'Error' },
-  'expected-const': { severity: 'Error' },
-  'expected-entity': { severity: 'Error' },
-  'expected-source': { severity: 'Error' },
-  'expected-target': { severity: 'Error' },
+  'ref-expecting-struct': { severity: 'Error' },
+  'ref-expecting-const': { severity: 'Error' },
+  'ref-expecting-entity': { severity: 'Error' },
+  'ref-expecting-source': { severity: 'Error' },
+  'ref-expecting-target': { severity: 'Error' },
   'ref-sloppy-target': { severity: 'Warning' },
 
   'extend-repeated-intralayer': { severity: 'Warning' },
@@ -103,7 +110,7 @@ const centralMessages = {
   'ext-duplicate-extend-type': { severity: 'Error' },
   'ext-duplicate-extend-type-unrelated-layer': { severity: 'Error', configurableFor: true },
 
-  'param-default': { severity: 'Error', configurableFor: 'deprecated' }, // not supported yet
+  'param-default': { severity: 'Error' }, // not supported yet
 
   'query-undefined-element': { severity: 'Error' },
   'query-unexpected-assoc-hdbcds': { severity: 'Error' },
@@ -115,14 +122,14 @@ const centralMessages = {
   '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-unexpected-autoexposed': { severity: 'Error' },
   // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
   'ref-undefined-art':    { severity: 'Error' },
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
   'ref-unknown-var': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
-  'ref-obsolete-parameters': { severity: 'Error', configurableFor: true },
+  'ref-obsolete-parameters': { severity: 'Error', configurableFor: 'v4' },
            // does not hurt us, but makes it tedious to detect parameter refs
   'ref-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
@@ -134,27 +141,31 @@ const centralMessages = {
   '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
+  'service-nested-service': { severity: 'Error' }, // not supported yet; TODO: configurableFor:'test'?
 
   'expr-unexpected-operator': { severity: 'Error', configurableFor: true },
 
+  'syntax-deprecated-auto-union': { severity: 'Error', configurableFor: 'v4' },
   // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
   // Also used by other projects that rely on double-quotes for delimited identifiers.
   'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
+  'syntax-deprecated-property': { severity: 'Error', configurableFor: 'v4' }, // v0 prop
+  'syntax-deprecated-value': { severity: 'Error', configurableFor: 'v4' },    // v0 prop
   // '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: 'v3' },
+  'syntax-duplicate-annotate': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-duplicate-clause': { severity: 'Error', configurableFor: true },
   'syntax-duplicate-equal-clause': { severity: 'Warning' },
-  'syntax-invalid-name': { severity: 'Error', configurableFor: 'v3' },
+  'syntax-invalid-name': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
   'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
   'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
-  'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'v3' },
+  'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
+  'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
 
-  'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
+  'type-managed-composition': { severity: 'Error' },
   'type-unsupported-precision-change': { severity: 'Error'},
 
   'def-missing-element': { severity: 'Error' },
@@ -162,8 +173,8 @@ const centralMessages = {
   'def-unsupported-calc-elem': { severity: 'Error', configurableFor: true },
 
   '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
+  'unmanaged-as-key': { severity: 'Error' }, // is confusing
+  'composition-as-key': { severity: 'Error' }, // is confusing and not supported
   'def-invalid-key-cardinality': { severity: 'Error' },
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-array': { severity: 'Warning' }, // more than 30 chars
@@ -191,6 +202,7 @@ const centralMessages = {
   'odata-anno-value': { severity: 'Warning', configurableFor: true },
   'odata-anno-type': { severity: 'Warning', configurableFor: true },
   'odata-anno-def': { severity: 'Info', configurableFor: true },
+  'query-ignoring-assoc-in-union': { severity: 'Info' }
 };
 
 // Old/Deprecated message IDs that we only still use for backwards-compatibility.
@@ -199,6 +211,8 @@ 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
+  'assoc-in-array': 'type-invalid-items',
+  'duplicate-autoexposed': 'def-duplicate-autoexposed',
 });
 
 // Set up the old-to-new message ID mapping in the message registry.
@@ -265,11 +279,11 @@ 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',
   },
-  'name-invalid-dollar-alias': {      // Warning
-    std: 'An alias name 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',
+  'name-invalid-dollar-alias': {
+    std: 'An alias name starting with $(NAME) might shadow a special variable; replace by another name',
+    $tableAlias: 'A table alias name must not start with $(NAME); choose another name',
+    $tableImplicit: 'The resulting table alias starts with $(NAME); choose another name with $(KEYWORD)',
+    mixin: 'A mixin name starting with $(NAME) might shadow a special variable; replace by another name',
   },
 
   'name-missing-alias': {
@@ -317,6 +331,10 @@ const centralMessageTexts = {
     'expecting': 'Expecting literal type $(OP) for the value in property $(OTHERPROP)',
     'typeof': 'String $(RAWVALUE) is no valid literal type for the string value in property $(OTHERPROP)',
   },
+  'syntax-invalid-source': {
+    std: 'The given source is invalid', // unused
+    'cdl-stackoverflow': 'The parser ran into a stack overflow. Does your CDS file contain too many nested artifacts?'
+  },
   'syntax-missing-ellipsis': 'Expecting an array item $(NEWCODE) after an item with $(CODE)',
   'syntax-unexpected-ellipsis': {
     std: 'Unexpected array item $(CODE)',
@@ -353,6 +371,11 @@ const centralMessageTexts = {
   },
   // 'syntax-duplicate-anno', 'syntax-duplicate-doc-comment', 'syntax-duplicate-property',
   // 'syntax-duplicate-wildcard'
+  'syntax-invalid-path-separator': {
+    std: 'Invalid reference path separator', // unused
+    dot: 'Use a $(NEWCODE), not a $(CODE) after the arguments or filter on an entity',
+    colon: 'Use a $(NEWCODE), not a $(CODE) between the element names in a reference',
+  },
   // 'syntax-ignoring-doc-comment' (Info)
   'syntax-unexpected-reserved-word': '$(CODE) is a reserved word - write $(DELIMITED) instead if you want to use it as name',
   'syntax-invalid-text-block': 'Missing newline in text block',
@@ -376,6 +399,9 @@ const centralMessageTexts = {
     dynamic: 'Dynamic parameter $(CODE) is not supported',
     positional: 'Positional parameter $(CODE) is not supported',
   },
+  'syntax-unexpected-sql-clause': {
+    std: 'Unexpected $(KEYWORD) clause for path filter',
+  },
 
   // Syntax messages, CSN parser - default: Error  ------------------------------
   'syntax-deprecated-dollar-syntax': {
@@ -383,14 +409,13 @@ const centralMessageTexts = {
     projection: 'The property $(PROP) is deprecated; use property $(SIBLINGPROP) instead of $(OTHERPROP) for the query',
     aspect: 'The property $(PROP) is deprecated; change the kind of the current definition to $(KIND) instead',
   },
-  'syntax-deprecated-property': {  // Warning
+  'syntax-deprecated-property': {  // Configurable error
     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
+  'syntax-deprecated-value': {  // Configurable error
     std: 'Deprecated representation of the value in property $(PROP)',
-    replace: 'Replace value in $(PROP) by $(VALUE)',
     'zero-parens': 'Deprecated CSN v0.1.0 representation of expressions in parentheses',
     'zero-replace': 'Replace CSN v0.1.0 value in $(PROP) by $(VALUE)',
   },
@@ -454,9 +479,9 @@ const centralMessageTexts = {
   },
   'ref-invalid-calc-elem': {
     std: 'Can\'t include artifact with calculated element',
-    event: 'An event can\'t include an entity with calculated elements',
-    type: 'A type can\'t include an entity with calculated elements',
-    annotation: 'An annotation can\'t include an entity with calculated elements',
+    event: 'An event can\'t include an artifact with calculated elements',
+    type: 'A type can\'t include an artifact with calculated elements',
+    annotation: 'An annotation can\'t include an artifact with calculated elements',
   },
   'def-unsupported-calc-elem': {
     std: 'Calculated elements are not supported, yet',
@@ -485,6 +510,7 @@ const centralMessageTexts = {
 
   // Messages for erroneous references -----------------------------------------
   // location at erroneous reference (if possible)
+  'ref-deprecated-orderby': 'Replace source element reference $(ID) by $(NEWCODE); auto-corrected',
   'ref-unexpected-self': 'Unexpected $(ID) reference; is valid only in ON-conditions',
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
@@ -492,23 +518,26 @@ const centralMessageTexts = {
     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)',
+  'ref-undefined-art': 'No artifact has been found with name $(ART)',
   // TODO: proposal 'No definition found for $(NAME)',
   'ref-undefined-element': {
     std: 'Element $(ART) has not been found',
     element: 'Artifact $(ART) has no element $(MEMBER)',
+    target: 'Target entity $(ART) has no element $(ID)',
     aspect: 'Element $(ID) has not been found in the anonymous target aspect',
+    query: 'The current query has no element $(ART)',
     virtual: 'Element $(ART) has not been found. Use $(CODE) to add virtual elements in queries'
   },
   'ref-undefined-var': {
     std: 'Variable $(ID) has not been found',
     alias: 'Variable $(ID) has not been found. Use table alias $(ALIAS) to refer an element with the same name',
+    self: 'Variable $(ID) has not been found. Use $(ALIAS) to refer an element with the same name',
   },
   'ref-unknown-var': {
     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': {
+  'ref-rejected-on': {          // TODO: currently not used - just remove?
     std: 'Do not refer to a artefact like $(ID) in the explicit ON of a redirection', // Not used
     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',
@@ -541,20 +570,35 @@ const centralMessageTexts = {
   },
   'ref-unexpected-calculated': {
     std: 'Unexpected reference to calculated element',
-    on: 'Calculated elements can\'t be used in ON-conditions of unmanaged associations',
-    fkey: 'Calculated elements can\'t be used as foreign keys for managed associations',
+    on: 'Calculated elements (on-read) can\'t be used in ON-conditions of unmanaged associations',
+    fkey: 'Calculated elements (on-read) can\'t be used as foreign keys for managed associations',
+  },
+  'ref-unexpected-localized': {
+    std: 'Unexpected reference to localized element $(NAME)', // "std" currently unused
+    calc: 'Calculated elements can\'t refer to localized elements',
   },
 
   'ref-unexpected-navigation': {
-    std: 'Can\'t follow association $(ID) of path $(ELEMREF) in an ON-condition; only foreign keys can be referred to, but not $(NAME)',
-    unmanaged: 'Can\'t follow unmanaged association $(ID) of path $(ELEMREF) in an ON-condition; only foreign keys can be referred to',
-    unmanagedleaf: 'Unexpected unmanged association as final path step of $(ELEMREF) in an ON-condition',
+    std: 'Can\'t follow association $(ID) in path $(ELEMREF) in an ON-condition; only foreign keys can be referred to, but not $(NAME)',
+    unmanaged: 'Can\'t follow unmanaged association $(ID) in path $(ELEMREF) in an ON-condition',
+    unmanagedleaf: 'Unexpected unmanaged association as final path step of $(ELEMREF) in an ON-condition',
+    'calc-non-fk': 'Can\'t follow association $(ID) in path $(ELEMREF) in a stored calculated element; only foreign keys can be referred to, but not $(NAME)',
+    'calc-unmanaged': 'Can\'t follow unmanaged association $(ID) in path $(ELEMREF) in a stored calculated element',
+  },
+  'ref-unexpected-filter': {
+    std: 'Unexpected filter in path $(ELEMREF)', // unused
+    'on-condition': 'ON-conditions must not contain filters, step $(ID) of path $(ELEMREF)',
+    calc:  'Unexpected filter in path $(ELEMREF) of stored calculated element; only simple paths can be used here'
+  },
+  'ref-unexpected-args': {
+    std: 'Unexpected arguments in path $(ELEMREF)', // unused
+    'on-condition': 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)',
+    calc: 'Unexpected arguments in path $(ELEMREF) of stored calculated element; only simple paths can be used here'
   },
 
   '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',
+    type: 'Unexpected $(KEYWORD) for the type of a type definition',
     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',
@@ -563,18 +607,26 @@ const centralMessageTexts = {
   'type-missing-argument': 'Missing value for argument $(NAME) in reference to type $(ID)',
   'type-ignoring-argument': 'Too many arguments for type $(ART)',
   'type-unexpected-argument': {
-    std: 'Too many arguments for type $(ART)',
+    std: 'Too many arguments for type $(ART)', // we use config 'type-ignoring-argument' instead
     type: 'Unexpected argument $(PROP) for type $(ART) with base type $(TYPE)',
     builtin: 'Unexpected argument $(PROP) for type $(ART)',
     'non-scalar': 'Only scalar types can have arguments',
+    // TODO: the following variants look like for an upcoming type-invalid-argument:
     max: 'Expecting argument $(PROP) for type $(TYPE) to not exceed $(NUMBER)',
     min: 'Expecting argument $(PROP) for type $(TYPE) to be greater than or equal to $(NUMBER)',
     'incorrect-type': 'Expected $(NAMES) for argument $(PROP), but found $(CODE)',
   },
 
+  'type-invalid-items': {
+    std: 'Unexpected $(PROP)', // unused
+    nested: 'Unexpected $(PROP) inside $(PROP)',
+    assoc: 'Unexpected association inside $(PROP)',
+    comp: 'Unexpected composition inside $(PROP)',
+  },
+
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
-  'anno-undefined-def': 'Artifact $(ART) has not been found',
-  'anno-undefined-art': 'No artifact has been found with name $(NAME)',
+  'anno-undefined-def': 'Artifact $(ART) has not been found', // TODO: ext-
+  'anno-undefined-art': 'No artifact has been found with name $(ART)',
   'anno-undefined-element': {
     std: 'Element $(NAME) has not been found',
     element: 'Artifact $(ART) has no element $(NAME)',
@@ -623,6 +675,12 @@ const centralMessageTexts = {
     std: 'Unexpected structured type', // unused variant
     calc: 'A structured type can\'t be used for calculated elements',
   },
+  'type-unexpected-many': {
+    std: 'Unexpected arrayed type', // unused variant
+    calc: 'An arrayed type can\'t be used for calculated elements',
+    'calc-implicit': 'An arrayed type can\'t be used for calculated elements (due to direct reference $(ELEMREF))',
+    'calc-cast': 'An arrayed type can\'t be used for calculated elements (via cast)',
+  },
 
   'def-missing-element': {
     std: 'Expecting entity to have at least one element which is neither virtual nor calculated',
@@ -667,17 +725,15 @@ const centralMessageTexts = {
     missing: 'Expected element $(ID) to have at least all the same sub-elements as included artifacts, but it is missing $(NAME)'
   },
 
-  // TODO: rename to ref-expected-XYZ
-  'expected-actionparam-type': 'A type, an element, or a service entity is expected here',
-  'expected-const': 'A constant value is expected here',
-  'expected-context': 'A context or service is expected here',
-  'expected-event-type': 'A type, an element, an event, or a service entity is expected here',
-  'expected-entity': 'An entity, projection or view is expected here',
-  'expected-struct': 'A type, entity, aspect or event with direct elements is expected here',
-  'expected-type': 'A type or an element is expected here',
+  'ref-expecting-action-param-type': 'A type, an element, or a service entity is expected here',
+  'ref-expecting-const': 'A constant value is expected here',
+  'ref-expecting-event-type': 'A type, an element, an event, or a service entity is expected here',
+  'ref-expecting-entity': 'An entity, projection or view is expected here',
+  'ref-expecting-struct': 'A type, entity, aspect or event with direct elements is expected here',
+  'ref-expecting-type': 'A type or an element is expected here',
   // TODO: text variant if the association does not start an entity
-  'expected-source': 'A query source must be an entity or an association',
-  'expected-target': 'An entity or an aspect is expected here',
+  'ref-expecting-source': 'A query source must be an entity or an association',
+  'ref-expecting-target': 'An entity or an aspect is expected here', // TODO: coverage
   '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 $(META) with includes',
@@ -696,6 +752,8 @@ const centralMessageTexts = {
     // eslint-disable-next-line max-len
     scale: 'With the extension for type property $(OTHERPROP), the value of $(PROP) must be $(NUMBER) or higher',
   },
+  'ext-missing-type-property': 'Type extension with property $(PROP) must also have property $(OTHERPROP) because $(ART) has both',
+
   'ref-expected-scalar-type': {
     std: 'Only scalar type definitions can be extended with type properties',
     unsupported: 'Only integer-, decimal-, binary-, and string-types can be extended but found $(PROP)',
@@ -720,6 +778,22 @@ const centralMessageTexts = {
     std: 'Using nested projections next to calculated elements is not supported, yet',
     inside: 'Using calculated elements in nested projections is not supported, yet'
   },
+  'query-mismatched-element': {
+    std: 'Specified element $(NAME) differs from inferred element in property $(PROP)',
+    type: 'Expected type of specified element $(NAME) to be the same as the inferred element\'s type',
+    typeName: 'Expected type $(TYPE) of specified element $(NAME) to be the same as the inferred element\'s type $(OTHERTYPE)',
+    missing: 'Specified element $(NAME) differs from inferred element: it is missing property $(PROP)',
+    extra: 'Specified element $(NAME) differs from inferred element: it has an additional property $(PROP)',
+    target: 'Expected target $(TARGET) of specified element $(NAME) to be the same as the inferred element\'s target $(ART)',
+    foreignKeys: 'Expected foreign keys of specified element $(NAME) to be the same as the inferred element\'s foreign keys',
+    prop: 'Value for $(PROP) of the specified element $(NAME) does not match the inferred element\'s value',
+  },
+
+  'query-unexpected-property': {
+    std: 'Unexpected property $(PROP) in the specified element $(NAME)',
+    calculatedElement: 'Unexpected property $(PROP) in the specified element $(NAME); calculated elements are not supported in queries',
+  },
+
   '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',
@@ -841,7 +915,7 @@ const centralMessageTexts = {
   'odata-anno-value': {
     'nested': 'Missing $(STR) annotation for $(ANNO)',
     // -----------------------------------------------------------------------------------
-    // All mesages of odata-anno-value below here MUST have $(ANNO) filled with msgctx.anno
+    // All messages of odata-anno-value below here MUST have $(ANNO) filled with msgctx.anno
     // -----------------------------------------------------------------------------------
     'enum': 'Value $(VALUE) is not one out of $(RAWVALUES) for $(ANNO) of type $(TYPE)',
     'std': 'Unexpected value $(VALUE) for $(ANNO) of type $(TYPE)',
@@ -862,6 +936,11 @@ const centralMessageTexts = {
     'deprecated': '$(ANNO) is deprecated. $(DEPR)',
     'notapplied': '$(ANNO) is not applied (AppliesTo: $(RAWVALUES))',
   },
+  'query-ignoring-assoc-in-union': {
+    'managed': 'Ignoring managed association $(NAME) that is published in a UNION',
+    'std': 'Ignoring association $(NAME) that is published in a UNION'
+  }
+
 }
 
 /**
@@ -869,11 +948,11 @@ const centralMessageTexts = {
  *
  * @typedef {object} MessageConfig
  * @property {MessageSeverity} severity Default severity for the message.
- * @property {string[]|'deprecated'|'v3'|true} [configurableFor]
+ * @property {string[]|'deprecated'|'v4'|true} [configurableFor]
  *        Whether the error can be reclassified to a warning or lower.
  *        If not `true` then an array is expected with specified modules in which the error is downgradable.
  *        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]