@sap/cds-compiler 3.5.4 → 3.6.0

package/lib/base/message-registry.js

@@ -55,11 +55,11 @@ const centralMessages = {
   '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"
-  'anno-undefined-action':  { severity: 'Info' },
-  'anno-undefined-art':     { severity: 'Info' }, // for annotate statement (for CDL path root)
-  'anno-undefined-def':     { severity: 'Info' }, // for annotate statement (for CSN or CDL path cont)
-  'anno-undefined-element': { severity: 'Info' },
-  'anno-undefined-param':   { severity: 'Info' },
+  'anno-undefined-action':  { severity: 'Warning' },
+  'anno-undefined-art':     { severity: 'Warning' }, // for annotate statement (for CDL path root)
+  '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-layers': { severity: 'Error', configurableFor: true }, // TODO(v3): Merge with anno-unexpected-ellipsis and make non-configurable
 
   'args-expected-named':  { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
@@ -145,6 +145,8 @@ 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: 'v3' },
+  'syntax-duplicate-clause': { severity: 'Error', configurableFor: true },
+  'syntax-duplicate-equal-clause': { severity: 'Warning' },
   'syntax-invalid-name': { severity: 'Error', configurableFor: 'v3' },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
   'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
@@ -225,14 +227,27 @@ const centralMessageTexts = {
     '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-duplicate': {
+    std: 'Duplicate assignment with $(ANNO)',
+    doc: 'Duplicate assignment with a doc comment',
+  },
+  'anno-duplicate-unrelated-layer': {
+    std: 'Duplicate assignment with $(ANNO)',
+    doc: 'Duplicate assignment with a doc comment',
+  },
   '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',
 
+  'check-proper-type-of': {
+    std: 'Referred element $(NAME) of $(ART) does not contain proper type information',
+    derived: 'Referred type of $(ART) does not contain proper type information',
+    managedAssocForeignKey: 'Foreign key $(NAME) of managed association $(ART) must have a type',
+    managedCompForeignKey: 'Foreign key $(NAME) of managed composition $(ART) must have a type',
+  },
+
   'name-duplicate-element': {
     'std': 'Generated element $(NAME) conflicts with another element',
     'flatten-element-gen': 'Generated element $(NAME) conflicts with other generated element',
@@ -260,16 +275,20 @@ const centralMessageTexts = {
     std: 'A safe non-negative integer is expected here',
     normal: 'A non-negative integer number is expected here',
     unsafe: 'The provided integer is too large',
-    csn: 'Expecting a non-negative integer for property $(PROP)'
+    csn: 'Expecting a non-negative integer for property $(PROP)',
+    'or-asterisk': 'Expecting a non-negative integer or string $(OP) for property $(PROP)',
   },
   'syntax-ignoring-anno': {
     std: 'Annotations can\'t be used in a column with $(CODE)',
     doc: 'Doc comments can\'t be used in a column with $(CODE)',
   },
   'syntax-invalid-name': {
-    std: 'Identifier must consist of at least one character',
-    csn: 'Property name in dictionary $(PARENTPROP) must not be empty',
-    as: 'String in property $(PROP) must not be empty', // TODO: use
+    std: 'Identifier must consist of at least one character', // only via delimited id
+    // as: 'String in property $(PROP) must not be empty', // expecting non-empty string is ok
+    '{}': 'Property name in structured value must not be empty', // CSN anno val
+    dict: 'Property name in dictionary $(PARENTPROP) must not be empty',
+    '=': 'The dot-separated name parts in property $(PROP) must not be empty',
+    type: 'The dot-separated element name parts in property $(PROP) must not be empty', // CSN v0
   },
   'syntax-invalid-literal': {
     'std': 'Invalid literal value',
@@ -278,6 +297,9 @@ const centralMessageTexts = {
     'time': 'A time literal must look like ‹hh:mm:ss› or ‹hh:mm› where each letter represents a digit',
     'date': 'A date literal must look like ‹YYYY-MM-DD› where each letter represents a digit',
     'timestamp': 'A timestamp literal must look like ‹YYYY-MM-DD hh:mm:ss.u…u› or ‹YYYY-MM-DD hh:mm› where each letter represents a digit, ‹u…u› represents 1 to 7 digits',
+    'number': 'The string value in property $(PROP) does not represent a number',
+    '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-missing-ellipsis': 'Expecting an array item $(NEWCODE) after an item with $(CODE)',
   'syntax-unexpected-ellipsis': {
@@ -298,17 +320,29 @@ const centralMessageTexts = {
     std: 'Duplicate value for parameter $(NAME)',
     type: 'Duplicate value for type parameter $(NAME)',
   },
+  'syntax-duplicate-clause': {
+    std: 'You have already provided this clause',
+    cardinality: 'You have already provided a target cardinality $(CODE) instead, at line $(LINE), column $(COL)',
+    notNull: 'You have already provided $(CODE) instead, at line $(LINE), column $(COL) below',
+  },
+  'syntax-duplicate-equal-clause': {
+    std: 'You have already provided the same clause',
+    cardinality: 'You have already provided the target cardinality $(CODE) at line $(LINE), column $(COL)',
+    notNull: 'You have already provided $(CODE) at line $(LINE), column $(COL) below',
+  },
   '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-duplicate-anno', 'syntax-duplicate-doc-comment', 'syntax-duplicate-cardinality',
-  // 'syntax-duplicate-property'
+  // 'syntax-duplicate-anno', 'syntax-duplicate-doc-comment', 'syntax-duplicate-property',
+  // 'syntax-duplicate-wildcard'
+  // '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',
   // 'syntax-missing-newline' (Warning), 'syntax-missing-as',
   // 'syntax-missing-token'
+  'syntax-unexpected-extension': 'Unexpected $(KEYWORD) inside $(CODE) block',
   'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
   'syntax-unexpected-token': {
     std: 'Mismatched $(OFFENDING), expecting $(EXPECTING)',
@@ -319,10 +353,8 @@ const centralMessageTexts = {
     service: 'Annotations can\'t be defined inside services',
     context: 'Annotations can\'t be defined inside contexts',
   },
-  // 'syntax-unexpected-space', 'syntax-unexpected-doc-comment' (TODO is: -ignoring-, Info)
-  // 'syntax-unexpected-alias' (is 'syntax-unexpected-property' in CSN),
-  // 'syntax-unexpected-right-paren'
-  'syntax-unsupported-calc-elem': 'Calculated elements are not supported',
+  // 'syntax-unexpected-space' (TODO: also use for :param, #variant, @(…) and @Begin),
+  // 'syntax-unexpected-alias' (is 'syntax-unexpected-property' in CSN)
   'syntax-unsupported-param': {
     std: 'Parameter not supported', // unused
     dynamic: 'Dynamic parameter $(CODE) is not supported',
@@ -331,7 +363,6 @@ const centralMessageTexts = {
   // 'syntax-unsupported-method', 'syntax-unsupported-new'
 
   // Syntax messages, CSN parser - default: Error  ------------------------------
-  // TODO: use one id with text variants instead of several message ids
   'syntax-deprecated-dollar-syntax': {
     std: 'The property $(PROP) is deprecated; its value is ignored',
     projection: 'The property $(PROP) is deprecated; use property $(SIBLINGPROP) instead of $(OTHERPROP) for the query',
@@ -349,12 +380,17 @@ const centralMessageTexts = {
     '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-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-object': {
+    std: 'Expecting object for property $(PROP)',
+    'or-asterisk': 'Expecting object or string $(OP) for property $(PROP)',
+    'or-string': 'Expecting object or non-empty string for property $(PROP)',
+  },
+  'syntax-expecting-string': {
+    std: 'Expecting non-empty string for property $(PROP)',
+    'or-object': 'Expecting non-empty string or object for property $(PROP)',
+    'or-null': 'Expecting non-empty string or null for property $(PROP)',
+  },
+  // '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',
@@ -384,6 +420,18 @@ const centralMessageTexts = {
     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-invalid-calc-elem': {
+    std: 'Invalid calculated element',
+    key: 'A primary key element can\'t be calculated',
+    virtual: 'A virtual element can\'t be calculated',
+    localized: 'A localized element can\'t be calculated',
+    default: 'An element with a default value can\'t be calculated',
+    event: 'An event can\'t have calculated elements',
+    type: 'A type can\'t have calculated elements',
+    action: 'An action can\'t have calculated elements',
+    function: 'A function can\'t have calculated elements',
+    annotation: 'Annotation definitions can\'t have calculated elements'
+  },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
   // multi-line strings: --------------------------------------------------------
@@ -403,8 +451,8 @@ const centralMessageTexts = {
     placeholder: 'Placeholders are not supported. Replace $(CODE) with $(NEWCODE)',
   },
 
-  // Messages for errorneous references -----------------------------------------
-  // location at errorneous reference (if possible)
+  // Messages for erroneous references -----------------------------------------
+  // location at erroneous 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',
@@ -417,7 +465,8 @@ const centralMessageTexts = {
   'ref-undefined-element': {
     std: 'Element $(ART) has not been found',
     element: 'Artifact $(ART) has no element $(MEMBER)',
-    aspect: 'Element $(ID) has not been found in the anonymous target aspect'
+    aspect: 'Element $(ID) has not been found in the anonymous target aspect',
+    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',
@@ -436,6 +485,25 @@ const centralMessageTexts = {
     std: 'Expected element reference',
     magicVar: 'Only elements of magic variable $(ID) can be selected',
   },
+  'ref-expected-direct-structure': {
+    std: '$(ART) can\'t be extended because it originates from an include',
+    elements: '$(ART) can\'t be extended by elements/enums because it originates from an include',
+  },
+  'ref-unexpected-structured': {
+    std: 'Unexpected usage of structured type $(ELEMREF)',
+    expr: 'Structured elements can\'t be used in expressions',
+  },
+  'ref-unexpected-virtual': {
+    std: 'Unexpected reference to virtual element $(NAME)', // "std" currently unused
+    expr: 'Virtual elements can\'t be used in expressions',
+    fkey: 'Virtual elements can\'t be used as foreign keys for managed associations',
+  },
+  'ref-unexpected-assoc': {
+    std: 'Unexpected reference to association $(NAME)', // "std" currently unused
+    expr: 'Associations can\'t be used as values in expressions',
+    cast: 'Casting to an association is not supported',
+  },
+
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
     type: 'Unexpected $(KEYWORD) in type of a type definition',
@@ -461,9 +529,11 @@ const centralMessageTexts = {
   'anno-undefined-def': 'Artifact $(ART) has not been found',
   'anno-undefined-art': 'No artifact has been found with name $(NAME)',
   'anno-undefined-element': {
-    std: 'Element $(ART) has not been found',
-    element: 'Artifact $(ART) has no element $(MEMBER)',
-    enum: 'Artifact $(ART) has no enum $(MEMBER)'
+    std: 'Element $(NAME) has not been found',
+    element: 'Artifact $(ART) has no element $(NAME)',
+    enum: 'Artifact $(ART) has no enum $(NAME)',
+    returns: 'Return value of $(ART) has no element $(NAME)',
+    'entity-element': 'Elements of entity types can\'t be annotated',
   },
   'anno-undefined-action': {
     std: 'Action $(ART) has not been found',
@@ -486,14 +556,16 @@ const centralMessageTexts = {
   },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
+    virtual: 'Unexpected $(PROP) for virtual element $(NAME)',
     // TODO: Better message?
-    include: '$(ART) can\'t have additional keys (through include)'
+    include: '$(ART) can\'t have additional keys (through include)',
   },
   'def-unexpected-localized': {
     std: '$(ART) can\'t have localized elements',
     // TODO: Better message?
     include:  '$(ART) can\'t have localized elements (through include)',
   },
+  'def-unexpected-localized-anno': 'Annotations can\'t have localized elements',
 
   'def-missing-element': {
     std: 'Expecting entity to have at least one non-virtual element',
@@ -686,7 +758,7 @@ const centralMessageTexts = {
   'odata-anno-type': {
     'std': '$(NAME) is not a known property for $(ANNO) of type $(TYPE)',
     'unknown': '$(TYPE) is not a known vocabulary type for $(ANNO)',
-    'abstract': 'Unexpected abstract type $(TYPE) for $(ANNO)',
+    'abstract': 'Unexpected abstract type $(TYPE) for $(ANNO), use $(CODE) to specify a concrete type',
     'derived': 'Expected specified $(TYPE) to be derived from $(NAME) for $(ANNO)',
   },
   'odata-anno-def': {