@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/base/message-registry.js

@@ -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-assoc': { 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"
@@ -62,47 +63,38 @@ const centralMessages = {
   'anno-undefined-element': { severity: 'Warning' },
   'anno-undefined-param':   { severity: 'Warning' },
   'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
-
-  'args-expecting-named':  { severity: 'Error' },
-  'args-no-params':       { severity: 'Error' },
-  'args-undefined-param': { severity: 'Error' },
+  'anno-unexpected-localized-skip': { severity: 'Error', configurableFor: true },
 
   '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-nested-proj': { severity: 'Error', configurableFor: 'v4' },
   'def-unexpected-paramview-assoc': { severity: 'Error' },
   'def-unexpected-calcview-assoc': { severity: 'Error' },
   'chained-array-of': { severity: 'Error' },
-  'check-proper-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
+  'def-missing-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
   'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
 
   'def-duplicate-autoexposed': { severity: 'Error' },
   'def-unexpected-default': { severity: 'Error', configurableFor: 'test' },
 
-  'expr-no-filter': { severity: 'Error' },
+  'expr-unexpected-filter': { severity: 'Error' },
 
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
-  'ref-expecting-type': { severity: 'Error' },
-  'ref-sloppy-type': { severity: 'Error' },
+  'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
-  'ref-expecting-bare-aspect': { severity: 'Error' },
+  'ref-invalid-include': { severity: 'Error' },
   'type-unexpected-typeof': { severity: 'Error' },
   'type-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'type-expecting-service-target': { severity: 'Error', configurableFor: true },
-  'ref-expecting-action-param-type': { severity: 'Error' },
-  'ref-sloppy-actionparam-type': { severity: 'Error' },
-  'ref-expecting-event-type': { severity: 'Error' }, // TODO: Test coverage
-  'ref-sloppy-event-type': { 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' },
+  'ref-invalid-source': { severity: 'Error' },
+  'ref-invalid-target': { severity: 'Error' },
+  'ref-sloppy-target': { severity: 'Error', configurableFor: 'v4' },
 
   'extend-repeated-intralayer': { severity: 'Warning' },
   'extend-unrelated-layer':     { severity: 'Info' },
@@ -123,6 +115,7 @@ const centralMessages = {
   'type-ambiguous-target': { severity: 'Warning' },
 
   'ref-unexpected-autoexposed': { severity: 'Error' },
+  'ref-unexpected-many-navigation': { 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' },
@@ -166,15 +159,13 @@ const centralMessages = {
   'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
 
   'type-managed-composition': { severity: 'Error' },
-  'type-unsupported-precision-change': { severity: 'Error'},
+  'type-unsupported-precision-change': { severity: 'Error' },
+  'type-unsupported-key-change': { severity: 'Error', configurableFor: true },
 
   'def-missing-element': { severity: 'Error' },
 
   'def-unsupported-calc-elem': { severity: 'Error', configurableFor: true },
 
-  'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
-  '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
@@ -213,6 +204,8 @@ const oldMessageIds = createDict({
   'old-anno-duplicate': 'anno-duplicate', // Example
   'assoc-in-array': 'type-invalid-items',
   'duplicate-autoexposed': 'def-duplicate-autoexposed',
+  'expr-no-filter': 'expr-unexpected-filter',
+  'check-proper-type': 'def-missing-type',
 });
 
 // Set up the old-to-new message ID mapping in the message registry.
@@ -239,6 +232,8 @@ const centralMessageTexts = {
     std: 'Invalid option $(NAME)!',
     deprecated: 'Option $(NAME) is no longer supported! Use latest API options instead',
     magicVars: 'Option $(PROP) is no longer supported! Use $(OTHERPROP) instead. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
+    value: 'Expected option $(PROP) to have $(VALUE). Found: $(OTHERVALUE)',
+    type: 'Expected option $(OPTION) to be of type $(VALUE). Found: $(OTHERVALUE)',
   },
 
   'api-invalid-variable-replacement': {
@@ -248,6 +243,22 @@ const centralMessageTexts = {
     'noDollar': 'Option $(OPTION) does not know $(NAME). Did you forget a leading $(CODE)?'
   },
 
+  'api-invalid-combination': {
+    std: 'Invalid option combination found: $(OPTION) and $(PROP)', // unused
+    'valid-structured': 'Structured OData is only supported with OData version v4',
+    'sql-dialect-and-naming': 'sqlDialect $(NAME) can\'t be combined with sqlMapping $(PROP)',
+    'sql-dialect-and-localized':  'Option $(OPTION) can\'t be combined with SQL dialect $(VALUE) or the to.hdi()/to.hdbcds() backend',
+  },
+  'api-unexpected-combination': {
+    std: 'Unexpected option combination: $(OPTION) and $(PROP)', // unused
+    'beta-no-test':'Option $(OPTION) was used. This option should not be used in productive scenarios!',
+  },
+  'api-invalid-lookup-dir': {
+    std: '',
+    slash: 'Expected directory $(VALUE) in option $(OPTION) to end with $(OTHERVALUE)',
+    relative: 'Expected directory $(VALUE) in option $(OPTION) to not start with $(OTHERVALUE)',
+  },
+
   'anno-duplicate': {
     std: 'Duplicate assignment with $(ANNO)',
     doc: 'Duplicate assignment with a doc comment',
@@ -511,7 +522,12 @@ 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-unexpected-self': {
+    std: 'Unexpected $(ID) reference; is valid only in ON-conditions of unmanaged associations',
+    on: 'Unexpected $(ID) reference; is valid only if compared to be equal to an association of the target side',
+    subQuery: 'Unexpected $(ID) reference in a sub query',
+    setQuery: 'Unexpected $(ID) reference in a query on the right side of $(OP)',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -550,6 +566,9 @@ const centralMessageTexts = {
     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-many-navigation': {
+    std: 'Unexpected navigation into arrayed structure',
+  },
   'ref-unexpected-scope': {
     std: 'Unexpected parameter reference',
     calc: 'Calculated elements can\'t use parameter references',
@@ -565,7 +584,11 @@ const centralMessageTexts = {
   },
   'ref-unexpected-assoc': {
     std: 'Unexpected reference to association $(NAME)', // "std" currently unused
+    unmanaged: 'Unexpected reference to an unmanaged association',
+    'self-unmanaged': 'Unexpected column reference starting with $(ALIAS) to an unmanaged association',
+    self: 'A reference to an unmanaged association is only valid when compared via $(CODE)',
     expr: 'Associations can\'t be used as values in expressions',
+    'expr-comp': 'Compositions can\'t be used as values in expressions',
     cast: 'Casting to an association is not supported',
   },
   'ref-unexpected-calculated': {
@@ -575,7 +598,7 @@ const centralMessageTexts = {
   },
   'ref-unexpected-localized': {
     std: 'Unexpected reference to localized element $(NAME)', // "std" currently unused
-    calc: 'Calculated elements can\'t refer to localized elements',
+    calc: 'Calculated elements "on-write" can\'t refer to localized elements',
   },
 
   'ref-unexpected-navigation': {
@@ -624,6 +647,14 @@ const centralMessageTexts = {
     comp: 'Unexpected composition inside $(PROP)',
   },
 
+  'type-unexpected-default': {
+    std: 'Unexpected $(KEYWORD) on an association/composition', // unused
+    multi: 'Unexpected $(KEYWORD); expected exactly one foreign key in combination with default value, but found $(COUNT)',
+    structured: 'Unexpected $(KEYWORD) in combination with structured foreign key $(NAME); $(KEYWORD) requires a non-structured foreign key',
+    'onCond': 'Unexpected $(KEYWORD) on an association/composition with ON-condition; $(KEYWORD) requires exactly one foreign key',
+    'targetAspect': 'Unexpected $(KEYWORD) on composition of aspect'
+  },
+
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
   'anno-undefined-def': 'Artifact $(ART) has not been found', // TODO: ext-
   'anno-undefined-art': 'No artifact has been found with name $(ART)',
@@ -654,14 +685,25 @@ const centralMessageTexts = {
     source: 'Unexpected definition of an association in an entity with parameters',
     target: 'Expected association target to have no parameters',
   },
+  'def-unexpected-nested-proj': {
+    std: 'Unexpected $(CODE)',
+    var: 'Unexpected $(CODE) after reference to CDS variable',
+    struct: 'Unexpected $(CODE); can only be used after a reference to a structure or association',
+    init: 'Unexpected $(CODE); can only be used after a reference to a structure, association or table alias',
+  },
   'def-unexpected-calcview-assoc': {
     std: 'unused',
     'source': 'Unexpected definition of an association in an entity annotated with $(ANNO)',
     'target': 'Expected association target not to be annotated with $(ANNO)',
   },
+  'def-invalid-key': {
+    std: 'The current element can\'t be defined as primary key', // (unused)
+    unmanaged: 'Unmanaged associations/compositions can\'t be defined as primary key',
+    composition: 'Managed aspect compositions can\'t be defined as primary key',
+  },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
-    virtual: 'Unexpected $(PROP) for virtual element $(NAME)',
+    virtual: 'Unexpected $(PROP) for virtual element $(ART)',
     // TODO: Better message?
     include: '$(ART) can\'t have additional keys (through include)',
   },
@@ -718,6 +760,12 @@ const centralMessageTexts = {
     elements: 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
     actions: 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
   },
+  'ref-invalid-element': {
+    std: 'Invalid element reference',
+    $tableAlias: 'Can\'t refer to source elements of table alias $(ID)',
+    mixin: 'Can\'t refer to the query\'s own mixin $(ID)',
+    $self: 'Can\'t refer to the query\'s own elements',
+  },
   'ref-invalid-override': {
     std: 'Overridden element of include must not change element structure', // unused
     'new-not-structured': 'Expected element $(NAME) to be structured, because it overrides the included element from $(ART)',
@@ -725,19 +773,27 @@ const centralMessageTexts = {
     missing: 'Expected element $(ID) to have at least all the same sub-elements as included artifacts, but it is missing $(NAME)'
   },
 
-  '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',
+  'ref-expecting-const': 'A constant expression or variable is expected here',
+  'ref-invalid-target': {
+    std: 'An entity, projection or view is expected here', // TODO: change text
+    composition: 'Expecting an entity or aspect as composition target',
+    bare: 'Expecting the target aspect to have elements',
+    aspect: 'Expecting the name of an aspect in property $(PROP)', // only CSN input
+  },
+  'ref-invalid-include': {
+    std: 'A type, entity, aspect or event with direct elements is expected here',
+    bare : 'An aspect without elements is expected here',
+  },
+  'ref-invalid-type': {
+    std: 'A type or an element is expected here',
+    param: 'A type, an element, or a service entity is expected here',
+    event: 'A type, an element, an event, or a service entity is expected here',
+  },
   // TODO: text variant if the association does not start an entity
-  '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
+  'ref-invalid-source': 'A query source must be an entity or an association',
   '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',
-  'ref-expecting-bare-aspect': 'An aspect without elements is expected here',
 
   'ext-duplicate-same-file': 'Duplicate extension with $(PROP) in same file',
   'ext-duplicate-extend-type': 'Duplicate type extension for type $(TYPE)',
@@ -787,6 +843,8 @@ const centralMessageTexts = {
     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',
+    enumExtra: 'Specified element $(NAME) differs from inferred element: it has an additional enum element $(ID)',
+    enumVal: 'Specified element $(NAME) differs from inferred element: it has a different value for enum element $(ID)',
   },
 
   'query-unexpected-property': {
@@ -794,10 +852,7 @@ const centralMessageTexts = {
     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',
-  'ref-sloppy-event-type': 'A type, an element, an event, or a service entity is expected here',
 
   'ref-ambiguous': {
     std: 'Replace ambiguous $(ID) by $(NAMES)',
@@ -812,16 +867,41 @@ const centralMessageTexts = {
     entity: 'Entity $(ART) with managed compositions can\'t be used in types', // yet
   },
 
+  'type-unsupported-key-change': {
+    std: 'Added element $(ID) is a primary key change and will not work if the table contains data',
+    changed: 'Changed element $(ID) is a primary key change and will not work if the table contains data'
+  },
+
+  'type-unsupported-key-sqlite': {
+    std: 'Added element $(ID) is a primary key change and will not work with dialect $(NAME)',
+    changed: 'Changed element $(ID) is a primary key change and will not work with dialect $(NAME)'
+  },
+
+  'type-invalid-cast': {
+    std: 'Invalid cast to $(TYPE)', // unused
+    'to-structure': 'Can\'t cast to a structured type',
+    'from-structure':  'Structured elements can\'t be cast to a different type',
+    'expr-to-structure': 'Can\'t cast an expression to a structured type',
+    'val-to-structure': 'Can\'t cast $(VALUE) to a structured type'
+  },
+
   // -----------------------------------------------------------------------------------
   // Expressions
   // -----------------------------------------------------------------------------------
-  'expr-invalid-operator': 'Comparing $(ID) is only allowed with $(OP)',
-  'expr-missing-comparison': {
-    std: 'Expected a comparison with $(OP) when using $(ID) in an ON-condition',
+  'type-invalid-cardinality': {
+    std: 'Invalid value $(VALUE) for cardinality', // unused variant
+    sourceMax: 'Invalid value $(PROP) for maximum source cardinality, expecting a positive number or $(OTHERPROP)',
+    targetMax: 'Invalid value $(PROP) for maximum target cardinality, expecting a positive number or $(OTHERPROP)',
+    targetMin: 'Invalid value $(PROP) for minimum target cardinality, expecting a non-negative number',
+    sourceMin: 'Invalid value $(PROP) for minimum source cardinality, expecting a non-negative number',
+    sourceVal: 'Source minimum cardinality must not be greater than source maximum cardinality',
+    targetVal: 'Target minimum cardinality must not be greater than target maximum cardinality',
   },
 
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
 
+  'expr-missing-foreign-key': 'Path step $(ID) of $(ELEMREF) has no valid foreign keys',
+
   // OData version dependent messages
   'odata-spec-violation-array': 'Unexpected array type for OData $(VERSION)',
   'odata-spec-violation-param' : 'Expected parameter to be typed with either scalar or structured type for OData $(VERSION)',
@@ -854,6 +934,7 @@ const centralMessageTexts = {
     incompatible: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
     facet: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
     external: 'Referenced type $(TYPE) marked as $(ANNO) can\'t be rendered as $(CODE) in service $(NAME) for OData $(VERSION)',
+    scale: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE)'
   },
   'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(META)',
   'odata-spec-violation-namespace': {
@@ -919,7 +1000,7 @@ const centralMessageTexts = {
     // -----------------------------------------------------------------------------------
     'enum': 'Value $(VALUE) is not one out of $(RAWVALUES) for $(ANNO) of type $(TYPE)',
     'std': 'Unexpected value $(VALUE) for $(ANNO) of type $(TYPE)',
-    'struct': 'Unexpected $(STR) value for $(ANNO) of type $(TYPE)',
+    'incompval': 'Unexpected $(STR) value for $(ANNO) of type $(TYPE)',
     'nestedcollection': 'Nested collections are not supported for $(ANNO)',
     'enumincollection': 'Enum inside collection is not supported for $(ANNO)',
     'multexpr': 'EDM JSON code contains more than one dynamic expression: $(RAWVALUES) for $(ANNO)',
@@ -948,7 +1029,7 @@ const centralMessageTexts = {
  *
  * @typedef {object} MessageConfig
  * @property {MessageSeverity} severity Default severity for the message.
- * @property {string[]|'deprecated'|'v4'|true} [configurableFor]
+ * @property {string[]|'deprecated'|'v4'|'test'|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'.

package/lib/base/messages.js

@@ -17,6 +17,7 @@ const { cdlNewLineRegEx } = require('../language/textUtils');
 const fs = require('fs');
 const path = require('path');
 const { inspect } = require('util')
+const { CsnLocation } = require('../compiler/classes');
 
 // term instance for messages
 const colorTerm = term();
@@ -94,7 +95,7 @@ class CompilationError extends Error {
     super( `CDS compilation failed\n${messages?.map( m => m.toString() ).join('\n') || ''}` );
     /** @since v4.0.0 */
     this.code = 'ERR_CDS_COMPILATION_FAILURE';
-    this.messages = messages;
+    this.messages = [ ...messages ].sort(compareMessageSeverityAware);
 
     // TODO: remove this bin/cdsc.js specifics
     Object.defineProperty( this, 'hasBeenReported', { value: false, configurable: true, writable: true, enumerable: false } );
@@ -128,7 +129,7 @@ class CompilationError extends Error {
 class CompileMessage {
   /**
    * Creates an instance of CompileMessage.
-   * @param {any} location Location of the message
+   * @param {CSN.Location} location Location of the message
    * @param {string} msg The message text
    * @param {MessageSeverity} [severity='Error'] Severity: Debug, Info, Warning, Error
    * @param {string} [id] The ID of the message - visible as property messageId
@@ -139,7 +140,7 @@ class CompileMessage {
    */
   constructor(location, msg, severity = 'Error', id = null, home = null, moduleName = null) {
     this.message = msg;
-    this.$location = { ...location, address: undefined };
+    this.$location = { __proto__: CsnLocation.prototype, ...location, address: undefined };
     this.validNames = null;
     this.home = home;  // semantic location, e.g. 'entity:"E"/element:"x"'
     this.severity = severity;
@@ -892,14 +893,14 @@ function replaceInString( text, params ) {
 }
 
 /**
- * @param {CSN.Location} loc
- * @returns {CSN.Location}
+ * @param {CsnLocation} loc
+ * @returns {CsnLocation}
  */
 function weakLocation( loc ) {
   if (!loc)
-    return {};
+    return new CsnLocation();
   // no endLine/endCol
-  return { file: loc.file, line: loc.line, col: loc.col };
+  return new CsnLocation( loc.file, loc.line, loc.col, undefined, undefined );
 }
 
 /**
@@ -1299,6 +1300,13 @@ function deduplicateMessages( messages ) {
 
 function shortArtName( art ) {
   const name = getArtifactName( art );
+  if (!name) {
+    const loc = art.location ? ` at ${ locationString( art.location ) }` : '';
+    throw new CompilerAssertion(
+      art.path
+        ? `No artifact for ${ art.path.map( i => i.id ).join( '.' )}${ loc }`
+        : `No name found in ${ Object.keys( art ).join( '+' )}${ loc }` );
+  }
   if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
     return quote.double( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
@@ -1310,14 +1318,14 @@ function artName( art, omit ) {
   const r = (name.absolute) ? [ quoted( name.absolute ) ] : [];
   if (name.select && name.select > 1 || name.select != null && art.kind !== 'element') // Yes, omit select:1 for element - TODO: re-check
     r.push( (art.kind === 'extend' ? 'block:' : 'query:') + name.select ); // TODO: rename to 'select:1' and consider whether there are more selects
-  if (name.action && omit !== 'action')
+  if (name.action != null && omit !== 'action')
     r.push( `${ memberActionName(art) }:${ quoted( name.action ) }` );
-  if (name.alias && art.kind !== '$self' && name.$inferred !== '$internal')
+  if (name.alias != null && art.kind !== '$self' && name.$inferred !== '$internal')
     r.push( (art.kind === 'mixin' ? 'mixin:' : 'alias:') + quoted( name.alias ) );
   if (name.param != null && omit !== 'param')
     r.push( name.param ? `param:${ quoted( name.param ) }` : 'returns' ); // TODO: join
 
-  if (name.element && omit !== 'element') {
+  if (name.element != null && omit !== 'element') {
     if (name.select != null && !art.$inferred)
       r.push( 'column:' + quoted( name.element ) );
     else

package/lib/base/model.js

@@ -1,3 +1,8 @@
+// module- and csn/XSN-independent definitions
+
+// TODO: move XSN-specific things to lib/compiler/utils/
+// TODO: move CSN-specific things to ???
+
 'use strict';
 
 const { forEach } = require('../utils/objectUtils');
@@ -22,14 +27,14 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   annotationExpressions: true,
-  toRename: true, // Removes once it's publicly documented
   assocsWithParams: true, // beta, because runtimes don't support it, yet.
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
   enableUniversalCsn: true,
-  aspectWithoutElements: true, // TODO: do not just remove beta flag - remove elements, too!
   odataTerms: true,
   optionalActionFunctionParameters: true, // not supported by runtime, yet.
+  associationDefault: true,
+  annotateForeignKeys: true,
   // disabled by --beta-mode
   nestedServices: false,
 };
@@ -40,6 +45,7 @@ const availableDeprecatedFlags = {
   downgradableErrors: true,
   includesNonShadowedFirst: true,
   eagerPersistenceForGeneratedEntities: true,
+  noKeyPropagationWithExpansions: true,
 }
 
 const oldDeprecatedFlags_v2 = [
@@ -126,18 +132,26 @@ function checkRemovedDeprecatedFlags( options, { error } ) {
   });
 }
 
-// Apply function `callback` to all artifacts in dictionary
-// `model.definitions`.  See function `forEachGeneric` for details.
-// TODO: should we skip "namespaces" already here?
+/**
+ * Apply function `callback` to all artifacts in dictionary
+ * `model.definitions`.  See function `forEachGeneric` for details.
+ * TODO: should we skip "namespaces" already here?
+ */
 function forEachDefinition( model, callback ) {
   forEachGeneric( model, 'definitions', callback );
 }
 
-// Apply function `callback` to all members of object `obj` (main artifact or
-// parent member).  Members are considered those in dictionaries `elements`,
-// `enum`, `actions` and `params` of `obj`, `elements` and `enums` are also
-// searched inside property `items` (array of).  See function `forEachGeneric`
-// for details.
+/**
+ * Apply function `callback` to all members of object `obj` (main artifact or
+ * parent member).  Members are considered those in dictionaries `elements`,
+ * `enum`, `actions` and `params` of `obj`, `elements` and `enums` are also
+ * searched inside property `items` (array of).  See function `forEachGeneric`
+ * for details.
+ *
+ * @param {XSN.Artifact} construct
+ * @param {(member: XSN.Artifact, memberName: string, prop: string) => void} callback
+ * @param {XSN.Artifact} [target]
+ */
 function forEachMember( construct, callback, target ) {
   let obj = construct;
   while (obj.items)
@@ -151,6 +165,24 @@ function forEachMember( construct, callback, target ) {
     callback( construct.returns, '', 'params' );
 }
 
+/**
+ * Same as forEachMember, but inside each member, calls itself recursively, i.e.
+ * sub members are traversed as well.
+ *
+ * @param {XSN.Artifact} construct
+ * @param {(member: XSN.Artifact, memberName: string, prop: string) => void} callback
+ * @param {XSN.Artifact} [target]
+ */
+function forEachMemberRecursively( construct, callback, target ) {
+  forEachMember( construct, ( member, memberName, prop ) => {
+    callback( member, memberName, prop );
+    if (Array.isArray(member.$duplicates)) // redefinitions
+      member.$duplicates.forEach( o => callback( o, memberName, prop ) );
+    // Descend into nested members, too
+    forEachMemberRecursively( member, callback );
+  }, target);
+}
+
 // Apply function `callback` to all objects in dictionary `dict`, including all
 // duplicates (found under the same name).  Function `callback` is called with
 // the following arguments: the object, the name, and -if it is a duplicate-
@@ -193,6 +225,7 @@ module.exports = {
   queryOps,
   forEachDefinition,
   forEachMember,
+  forEachMemberRecursively,
   forEachGeneric,
   forEachInOrder,
   setProp,

package/lib/checks/defaultValues.js

@@ -53,12 +53,12 @@ function rejectParamDefaultsInHanaCds( member, memberName, prop, path ) {
  */
 function warnAboutDefaultOnAssociationForHanaCds( member, memberName, prop, path ) {
   const art = this.csn.definitions[path[1]];
-  if (!art.query && !art.projection && this.options.transformation === 'hdbcds' && member.target && member.default) {
-    this.warning(null, path, { '#': member._type.type === 'cds.Association' ? 'std' : 'comp' },
-                 {
-                   std: 'Unexpected default defined on association',
-                   comp: 'Unexpected default defined on composition',
-                 });
+  if (this.options.transformation === 'hdbcds' && !art.query && !art.projection && member.target && member.default) {
+    const type = member._type?.type || member.type || 'cds.Association';
+    this.warning('type-invalid-default', path, { '#': type === 'cds.Association' ? 'std' : 'comp' }, {
+      std: 'Default on associations is not supported for HDBCDS',
+      comp: 'Default on compositions is not supported for HDBCDS',
+    });
   }
 }
 

package/lib/checks/elements.js

@@ -119,18 +119,19 @@ function checkManagedAssoc( art ) {
   forEachMemberRecursively(art, (member) => {
     if (this.csnUtils.isAssocOrComposition(member) &&
         !isManagedComposition.bind(this)(member)) {
+      // Implementation note:  Imported services (i.e. external ones) may contain to-many associations
+      // with an empty foreign key list.  If the user (in this case importer) explicitly sets an empty
+      // foreign key array, we won't emit a warning to avoid spamming the user.
       const max = member.cardinality?.max ? member.cardinality.max : 1;
-      if (max !== 1 && !member.on) {
+      if (max !== 1 && !member.on && (!member.keys || member.keys.length > 0)) {
         const isNoDb = art['@cds.persistence.skip'] || art['@cds.persistence.exists'];
-        this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path,
-                     {
-                       value: cardinality2str(member, false),
-                       '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
-                     },
-                     {
-                       std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
-                       comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
-                     });
+        this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path, {
+          value: cardinality2str(member, false),
+          '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
+        }, {
+          std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
+          comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
+        });
       }
     }
   });

package/lib/checks/foreignKeys.js

@@ -16,8 +16,6 @@ const { setProp } = require('../base/model');
 function validateForeignKeys( member, memberName ) {
   // We have a managed association
   const isManagedAssoc = mem => mem && mem.target && !mem.on;
-  // We have an unmanaged association
-  const isUnmanagedAssoc = mem => mem && mem.target && mem.on && !mem.keys;
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
@@ -46,9 +44,6 @@ function validateForeignKeys( member, memberName ) {
     if (mem.items) {
       this.error(null, member.$path, {}, 'Array-like properties must not be foreign keys');
     }
-    else if (isUnmanagedAssoc(mem)) {
-      this.error(null, member.$path, {}, 'Unmanaged association must not be a foreign key');
-    }
     else if (mem.keys) {
       handleAssociation(mem);
     }

package/lib/checks/manyNavigations.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { applyTransformationsOnNonDictionary } = require('../model/csnUtils');
+
+/**
+ * Check all refs in the given parent for the traversal of paths
+ * into `.items`
+ *
+ * @param {object} parent Object with the expression as a property
+ * @param {string} propOnParent Name of the expression property on parent
+ * @param {Array} e Expression to check - see module.exports
+ * @param {CSN.Path} path
+ */
+function navigationIntoMany( parent, propOnParent, e, path ) {
+  applyTransformationsOnNonDictionary(parent, propOnParent, {
+    ref: (_parent, _prop, ref, _path) => {
+      const itemNavigationIndex = _parent._links?.findIndex(l => l.art.items);
+      if (itemNavigationIndex !== -1 && _parent.ref.length > itemNavigationIndex + 1)
+        this.message('ref-unexpected-many-navigation', _path);
+    },
+  }, { skipStandard: { type: true } }, path);
+}
+
+module.exports = {
+  columns: navigationIntoMany,
+  from: navigationIntoMany,
+  on: navigationIntoMany,
+  having: navigationIntoMany,
+  groupBy: navigationIntoMany,
+  orderBy: navigationIntoMany,
+  where: navigationIntoMany,
+  xpr: navigationIntoMany,
+};