@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/base/message-registry.js

@@ -60,7 +60,7 @@ 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-layers': { severity: 'Error', configurableFor: true }, // TODO(v3): Merge with anno-unexpected-ellipsis and make non-configurable
+  'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'v3' },
 
   'args-expected-named':  { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
   'args-no-params':       { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
@@ -159,6 +159,8 @@ const centralMessages = {
 
   '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', configurableFor: 'deprecated' }, // is confusing
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
@@ -183,6 +185,7 @@ const centralMessages = {
   'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
   'odata-anno-preproc': { severity: 'Warning', configurableFor: true },
   'odata-anno-dict': { severity: 'Warning', configurableFor: true },
+  'odata-anno-vocref': { severity: 'Warning', configurableFor: true },
   'odata-anno-dict-enum': { severity: 'Error' },
   'odata-anno-value': { severity: 'Warning', configurableFor: true },
   'odata-anno-type': { severity: 'Warning', configurableFor: true },
@@ -218,27 +221,33 @@ for (const oldName in oldMessageIds) {
 
 const centralMessageTexts = {
   'api-invalid-option': {
-    // TODO: too many different error situations for one message id,
-    // TODO: use message parameter - do not use quotes in message texts
-    std: 'Option $(NAME) is no longer supported! Use SNAPI options instead',
-    magicVars: 'Option “magicVars” is no longer supported! Use “variableReplacements” instead. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
-    user: 'Option “variableReplacements” expects “$user” instead of “user”. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
-    locale: 'Option “variableReplacements” expects “$user.locale” instead of “locale”. See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
-    'noDollar': 'Option “variableReplacements” does not know $(NAME). Did you forget a leading “$”?'
+    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',
+  },
+
+  'api-invalid-variable-replacement': {
+    std: 'Option $(OPTION) does not support $(NAME)',
+    user: 'Option $(OPTION) expects $(PROP) instead of $(OTHERPROP). See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
+    locale: 'Option $(OPTION) expects $(PROP) instead of $(OTHERPROP). See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
+    'noDollar': 'Option $(OPTION) does not know $(NAME). Did you forget a leading $(CODE)?'
   },
 
   'anno-duplicate': {
     std: 'Duplicate assignment with $(ANNO)',
     doc: 'Duplicate assignment with a doc comment',
   },
+  'anno-duplicate-same-file': {
+    std: 'Duplicate assignment with $(ANNO), using last',
+    doc: 'Duplicate assignment with a doc comment, using last',
+  },
   '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-unstable-array': 'Unstable order of array items due to repeated assignments for $(ANNO)',
   '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': {
@@ -262,6 +271,12 @@ const centralMessageTexts = {
     mixin: 'A mixin name starting with $(NAME) might shadow a special variable - replace by another name',
   },
 
+  'name-missing-alias': {
+    std: 'Missing table alias for this subquery',
+    duplicate: 'Missing table alias for this subquery; add $(CODE) to fix name clash of internal and explicit table alias',
+    hdbcds: 'Missing table alias for a subquery; SAP HANA CDS requires table aliases'
+  },
+
   // Syntax messages, both CDL and CSN parser: ----------------------------------
   'syntax-deprecated-abstract': {
     std: 'Abstract entity definitions are deprecated; use aspect definitions instead',
@@ -294,9 +309,9 @@ const centralMessageTexts = {
     'std': 'Invalid literal value',
     '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': 'A time literal must look like ‹hh:mm:ss› or ‹hh:mm› where each letter represents a digit',
+    'time': 'A time literal must look like ‹hh:mm:ss› or ‹hh:mm› where each letter represents a digit. A timezone is optional',
     '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',
+    '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. A timezone is optional',
     '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)',
@@ -360,7 +375,6 @@ const centralMessageTexts = {
     dynamic: 'Dynamic parameter $(CODE) is not supported',
     positional: 'Positional parameter $(CODE) is not supported',
   },
-  // 'syntax-unsupported-method', 'syntax-unsupported-new'
 
   // Syntax messages, CSN parser - default: Error  ------------------------------
   'syntax-deprecated-dollar-syntax': {
@@ -379,6 +393,10 @@ const centralMessageTexts = {
     '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-deprecated-type-ref': {
+    std: 'Expecting a string as value for property $(PROP) for a reference to a definition',
+    'ref-item': 'Expecting a string as value for property $(PROP) for a type reference to an element',
+  },
 
   'syntax-expecting-object': {
     std: 'Expecting object for property $(PROP)',
@@ -420,7 +438,7 @@ 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': {
+  'def-invalid-calc-elem': {
     std: 'Invalid calculated element',
     key: 'A primary key element can\'t be calculated',
     virtual: 'A virtual element can\'t be calculated',
@@ -430,7 +448,18 @@ const centralMessageTexts = {
     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'
+    annotation: 'Annotation definitions can\'t have calculated elements',
+    param: 'Parameters can\'t have calculated elements',
+  },
+  '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',
+  },
+  'def-unsupported-calc-elem': {
+    std: 'Calculated elements are not supported',
+    nested: 'Calculated elements in structures are not supported, yet'
   },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
@@ -489,6 +518,10 @@ 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-scope': {
+    std: 'Unexpected parameter reference',
+    calc: 'Calculated elements can\'t use parameter references',
+  },
   'ref-unexpected-structured': {
     std: 'Unexpected usage of structured type $(ELEMREF)',
     expr: 'Structured elements can\'t be used in expressions',
@@ -503,6 +536,17 @@ const centralMessageTexts = {
     expr: 'Associations can\'t be used as values in expressions',
     cast: 'Casting to an association is not supported',
   },
+  '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',
+  },
+
+  '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',
+  },
 
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
@@ -533,26 +577,32 @@ const centralMessageTexts = {
     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',
+    'enum-returns': 'Return value of $(ART) has no enum $(NAME)',
   },
   'anno-undefined-action': {
     std: 'Action $(ART) has not been found',
-    action: 'Artifact $(ART) has no action $(MEMBER)'
+    action: 'Artifact $(ART) has no action $(NAME)'
   },
   'anno-undefined-param': {
     std: 'Parameter $(ART) has not been found',
-    param: 'Artifact $(ART) has no parameter $(MEMBER)'
+    param: 'Artifact $(ART) has no parameter $(NAME)'
+  },
+
+  // annotation checks against their definition
+  'anno-expecting-value': {
+    'std':  'Expecting a value for the annotation; see annotation definition for $(ANNO)',
+    'type':  'Expecting a value of type $(TYPE) for the annotation'
   },
 
   'def-unexpected-paramview-assoc': {
-    std: 'SAP HANA does no support associations in/to parameterized entities',
-    view: 'SAP HANA does no support associations in parameterized entities',
-    target: 'SAP HANA does no support associations to parameterized entities',
+    std: 'SAP HANA doesn\'t support associations in/to parameterized entities',
+    view: 'SAP HANA doesn\'t support associations in parameterized entities',
+    target: 'SAP HANA doesn\'t support associations to parameterized entities',
   },
   'def-unexpected-calcview-assoc': {
-    std: 'SAP HANA does not allow associations in/to entities annotated with $(ANNO)',
-    'entity-persistence': 'SAP HANA does not allow associations in entities annotated with $(ANNO)',
-    'target-persistence': 'SAP HANA does not allow associations pointing to entities annotated with $(ANNO)',
+    std: 'SAP HANA doesn\'t allow associations in/to entities annotated with $(ANNO)',
+    'entity-persistence': 'SAP HANA doesn\'t allow associations in entities annotated with $(ANNO)',
+    'target-persistence': 'SAP HANA doesn\'t allow associations pointing to entities annotated with $(ANNO)',
   },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
@@ -566,9 +616,13 @@ const centralMessageTexts = {
     include:  '$(ART) can\'t have localized elements (through include)',
   },
   'def-unexpected-localized-anno': 'Annotations can\'t have localized elements',
+  'type-unexpected-structure': {
+    std: 'Unexpected structured type', // unused variant
+    calc: 'A structured type can\'t be used for calculated elements',
+  },
 
   'def-missing-element': {
-    std: 'Expecting entity to have at least one non-virtual element',
+    std: 'Expecting entity to have at least one element which is neither virtual nor calculated',
     view: 'Expecting view to have at least one non-virtual element'
   },
 
@@ -594,6 +648,14 @@ const centralMessageTexts = {
     action: 'Duplicate definition of action or function $(NAME)',
     param: 'Duplicate definition of parameter $(NAME)',
     alias: 'Duplicate definition of table alias or mixin $(NAME)',
+    'include-elements': 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
+    'include-actions': 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
+  },
+  // TODO: Remove in v4, use duplicate-definition
+  'ref-duplicate-include-member': {
+    std: 'Duplicate member $(NAME) through multiple includes $(SORTED_ARTS)',
+    elements: 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
+    actions: 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
   },
 
   // TODO: rename to ref-expected-XYZ
@@ -612,18 +674,18 @@ const centralMessageTexts = {
   '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)',
   'ext-duplicate-extend-type-unrelated-layer': 'Duplicate type extension for type $(TYPE)',
   'ext-invalid-type-property':  {
-    std: 'Property $(PROP) can only be extended',
-    'new-prop': 'Property $(PROP) can only be extended, not added',
+    std: 'Type property $(PROP) can only be extended',
+    'indirect': 'Type property $(PROP) can only be extended if directly provided at the definition',
+    'new-prop': 'Type property $(PROP) can only be extended, not added',
+    string: 'Only numerical properties can be extended, but found string for $(PROP)',
     // eslint-disable-next-line max-len
-    smaller: 'Property $(PROP) can only be extended, but $(VALUE) is smaller than $(NUMBER) of type definition',
+    number: 'Value of type property $(PROP) must be $(NUMBER) or higher, it can\'t be smaller than originally provided',
     // eslint-disable-next-line max-len
-    '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)',
+    scale: 'With the extension for type property $(OTHERPROP), the value of $(PROP) must be $(NUMBER) or higher',
   },
   'ref-expected-scalar-type': {
     std: 'Only scalar type definitions can be extended with type properties',
@@ -645,12 +707,21 @@ const centralMessageTexts = {
     std: 'Expected identifier for select item',
     assoc: 'Expected identifier as the association\'s name',
   },
-
+  'query-unsupported-calc': {
+    std: 'Using nested projections next to calculated elements is not supported, yet',
+    inside: 'Using calculated elements in nested projections is not supported, yet'
+  },
   '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)',
+    few: 'Replace ambiguous $(ID) by $(NAMES) or a new table alias for sub-queries that don\'t have one',
+    none: 'Ambiguous $(ID) requires an explicit table alias, but there are none: add table aliases to all sub-queries to disambiguate $(ID)',
+  },
+
   'type-managed-composition': {
     std: 'Managed compositions can\'t be used in types', // yet
     sub: 'Managed compositions can\'t be used in sub elements',
@@ -658,6 +729,14 @@ const centralMessageTexts = {
     entity: 'Entity $(ART) with managed compositions can\'t be used in types', // yet
   },
 
+  // -----------------------------------------------------------------------------------
+  // 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',
+  },
+
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
 
   // OData version dependent messages
@@ -669,7 +748,8 @@ const centralMessageTexts = {
   'odata-spec-violation-id': {
     std: 'Expected EDM name $(ID) to start with a letter or underscore, followed by at most 127 letters, underscores or digits',
     'v2firstchar': 'Unexpected first character $(PROP) of EDM Name $(ID) for OData $(VERSION)',
-    'qualifier': 'Expected annotation qualifier $(ID) to start with a letter or underscore, followed by at most 127 letters, underscores or digits'
+    'qualifier': 'Expected annotation qualifier $(ID) to start with a letter or underscore, followed by at most 127 letters, underscores or digits',
+    'vocrefalias': 'Expected value $(VALUE) of vocabulary reference attribute $(ID) to start with a letter or underscore, followed by at most 127 letters, underscores or digits'
   },
   // version independent messages
   'odata-spec-violation-key-array': {
@@ -738,6 +818,12 @@ const centralMessageTexts = {
     'experimental': '$(ANNO) is experimental and can be changed or removed at any time, do not use productively!',
     'redefinition': '$(ANNO) is an official OASIS/SAP annotation and can\'t be redefined'
   },
+  'odata-anno-vocref': {
+    'std': 'Vocabulary reference $(ID) doesn\'t match alias $(NAME), reference is ignored',
+    'redef': 'Vocabulary reference $(ID) is the alias of the official OASIS/SAP vocabulary $(TYPE) which can\'t be redefined, reference is ignored',
+    'service': 'Vocabulary reference collides with service $(NAME), reference is ignored',
+    'malformed': 'Vocabulary reference $(ID) has invalid or missing value for attribute $(NAME), reference is ignored'
+  },
   'odata-anno-dict-enum': {
     'std' : 'Unexpected annotation definition $(NAME) with many enum type',
     'type': 'Unexpected annotation definition $(NAME) with many enum type $(TYPE)',

package/lib/base/messages.js

@@ -11,6 +11,7 @@ const { centralMessages, centralMessageTexts, oldMessageIds } = require('./messa
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
 const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
 const { CompilerAssertion } = require('./error');
+const { getArtifactName } = require('../compiler/base');
 
 const fs = require('fs');
 const path = require('path');
@@ -766,6 +767,12 @@ function transformManyWith( t, sorted ) {
   };
 }
 
+/**
+ * Quote the given string.  Performs a type sanity check.
+ *
+ * @param {string} name
+ * @return {string}
+ */
 function quoted( name ) {
   if (typeof name === 'string')
     return quote.double( name );
@@ -835,6 +842,7 @@ const nameProp = {
   function: 'action',
 };
 
+// TODO: very likely delete this function
 function searchName( art, id, variant ) {
   if (!variant) {
     // used to mention the "effective" type in the message, not the
@@ -912,16 +920,16 @@ function weakLocation( loc ) {
  * @param {boolean} [noHome]
  * @returns {string}
  */
-function messageString( err, normalizeFilename, noMessageId, noHome ) {
-  return (err.$location && err.$location.file
-    ? `${ locationString( err.$location, normalizeFilename ) }: `
-    : '') +
-         (err.severity || 'Error') +
-         // TODO: use [message-id]
-         (err.messageId && !noMessageId ? ` ${ err.messageId }: ` : ': ') +
-         err.message +
-         // even with noHome, print err.home if the location is weak
-         (!err.home || noHome && err.$location && err.$location.endLine ? '' : ` (in ${ err.home })`);
+function messageString( err, normalizeFilename, noMessageId, noHome, moduleName = undefined ) {
+  const location = (err.$location?.file ? `${ locationString( err.$location, normalizeFilename ) }: ` : '');
+  const severity = err.severity || 'Error';
+  const downgradable = severity === 'Error' && moduleName &&
+    isDowngradable(err.messageId, moduleName, false) ? '‹↓›' : '';
+  // even with noHome, print err.home if the location is weak
+  const home = !err.home || noHome && err.$location?.endLine ? '' : ` (in ${ err.home })`;
+  // TODO: the plan was with brackets = `Error[ref-undefined-def]`
+  const id = err.messageId && !noMessageId ? ` ${ err.messageId }` : '';
+  return `${ location }${ severity }${ downgradable }${ id }: ${ err.message }${ home }`;
 }
 
 /**
@@ -1180,7 +1188,7 @@ function deduplicateMessages( messages ) {
 }
 
 function shortArtName( art ) {
-  const { name } = art;
+  const name = getArtifactName( art );
   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 );
@@ -1188,13 +1196,13 @@ function shortArtName( art ) {
 }
 
 function artName( art, omit ) {
-  const { name } = art;
+  const name = getArtifactName( art );
   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')
     r.push( `${ memberActionName(art) }:${ quoted( name.action ) }` );
-  if (name.alias && art.kind !== '$self')
+  if (name.alias && 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
@@ -1225,7 +1233,7 @@ function memberActionName( art ) {
 function homeName( art, absoluteOnly ) {
   if (!art)
     return art;
-  if (art._outer)               // in returns / items property
+  if (art._outer)               // in items property
     return homeName( art._outer, absoluteOnly );
   else if (art.kind === 'source' || !art.name) // error reported in parser or on source level
     return null;
@@ -1245,7 +1253,10 @@ function homeName( art, absoluteOnly ) {
 
 // The "home" for extensions is handled differently because `_artifact` is not
 // set for unknown extensions, and we could have nested extensions.
+// TODO: delete this function, just set correct name/_parent for extensions
 function homeNameForExtend( art ) {
+  if (!art.name.absolute && art._main)       // new-style member name
+    return `${ art._main.kind }:${ artName( art ) }`;
   const kind = art.kind || 'extend';
   // TODO: fix the following - do like in collectArtifactExtensions() or
   //       basically resolveUncheckedPath()
@@ -1309,6 +1320,12 @@ function homeNameForExtend( art ) {
 function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (!model)
     return null;
+
+  if (options.testMode)
+    sanitizeCsnPath(csnPath);
+
+  const _quoted = options.testMode ? quoted : quote.double;
+
   let result = '';
   const csnDictionaries = [
     'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
@@ -1338,12 +1355,12 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (step === 'definitions') {
     next(); // "definitions"
     const kind = currentThing?.kind || 'artifact';
-    result += `${ kind }:${ quoted(step) }`;
+    result += `${ kind }:${ _quoted(step) }`;
   }
   else if (step === 'vocabularies') {
     next(); // dictionary name
     if (index < csnPath.length)
-      result += `annotation:${ quoted(csnPath[index]) }`;
+      result += `annotation:${ _quoted(csnPath[index]) }`;
     else
       result += 'vocabularies';
   }
@@ -1355,7 +1372,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
     else {
       const name = currentThing.annotate || currentThing.extend;
       const kind = currentThing.annotate ? 'annotate' : 'extend';
-      result += `${ kind }:${ quoted(name) }`;
+      result += `${ kind }:${ _quoted(name) }`;
     }
   }
 
@@ -1381,7 +1398,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
         next();
       }
       if (elementHierarchy.length > 0)
-        result += `/element:${quoted(elementHierarchy.join('.'))}`;
+        result += `/element:${ _quoted(elementHierarchy.join('.')) }`;
       // no trailing /elements or /items
       continue;
     }
@@ -1389,7 +1406,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
       next(); // "actions"
       if (index < csnPath.length) {
         const kind = currentThing?.kind || 'action';
-        result += `/${ kind }:${ quoted(csnPath[index]) }`;
+        result += `/${ kind }:${ _quoted(csnPath[index]) }`;
       }
       else { // actions is last segment
         result += '/actions';
@@ -1419,7 +1436,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
     }
     else if (step === 'target') {
       if (currentThing)
-        result += '/target:' + quoted(currentThing);
+        result += '/target:' + _quoted(currentThing);
       else
         result += '/target';
       break;
@@ -1447,14 +1464,14 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
       next(); // "keys"
       if (index < csnPath.length) {
         const key = aliasOrReference();
-        result += `/key:${ key ? quoted(key) : step }`;
+        result += `/key:${ key ? _quoted(key) : step }`;
       }
       break;
     }
     else if (step[0] === '@') {
       // Annotations are always the last step.
       // Nothing comes after them, everything is user defined.
-      result += `/${ quoted(csnPath[index]) }`;
+      result += `/${ _quoted(csnPath[index]) }`;
       break;
     }
     else {
@@ -1470,7 +1487,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   function dictEntry( prefix ) {
     next(); // dictionary name
     if (index < csnPath.length)
-      result += `/${ prefix }:${ quoted(csnPath[index]) }`;
+      result += `/${ prefix }:${ _quoted(csnPath[index]) }`;
   }
 
   /**
@@ -1548,7 +1565,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
         } while (index < csnPath.length);
 
         if (elementHierarchy.length > 0)
-          result += `/column:${ quoted(elementHierarchy.join('.')) }`;
+          result += `/column:${ _quoted(elementHierarchy.join('.')) }`;
       }
       else if(step === 'args') {
         // Should only be reached for cases, where no SELECT in a union is picked.
@@ -1578,11 +1595,11 @@ function queryDepthForMessage( csnPath, model, view ) {
   if (!targetQuery)
     return 0;
   const rootQuery = view.query || { SELECT: view.projection };
-  let depth = 1;
+  let depth = 0;
   let totalDepth = 0;
   let isFound = false;
-  traverseQuery(rootQuery, null, null, (q, querySelect) => {
-    if (querySelect) {
+  traverseQuery(rootQuery, null, null, (q) => {
+    if (q.SELECT) {
       totalDepth += 1;
       if (!isFound)
         depth += 1;
@@ -1595,6 +1612,13 @@ function queryDepthForMessage( csnPath, model, view ) {
   return 0;
 }
 
+function sanitizeCsnPath(csnPath) {
+  for (const step of csnPath) {
+    if (typeof step !== 'string' && typeof step !== 'number')
+      throw new CompilerAssertion(`Found CSN path step that is neither string nor number: ${step} ${ JSON.stringify(csnPath) }`)
+  }
+}
+
 /**
  * Get the explanation string for the given message-id.
  * Ensure to have called hasMessageExplanation() before.

package/lib/base/model.js

@@ -21,7 +21,7 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  calculatedElements: true,
+  annotationExpressions: true,
   toRename: true,
   assocsWithParams: true,
   hanaAssocRealCardinality: true,
@@ -35,6 +35,7 @@ const availableBetaFlags = {
   optionalActionFunctionParameters: true,
   // disabled by --beta-mode
   nestedServices: false,
+  v4preview: false,
 };
 
 const availableDeprecatedFlags = {
@@ -110,7 +111,7 @@ function isDeprecatedEnabled( options, feature = null ) {
  * to change their code, emit an error if one of such removed flags was used.
  *
  * @param {CSN.Options} options
- * @param error Error message function returned by makeMessageFunctions().
+ * @param error Error message function returned by makeMessageFunction().
  */
 function checkRemovedDeprecatedFlags( options, { error } ) {
   // Assume that we emitted these errors once if a message with this ID was found.
@@ -127,6 +128,7 @@ 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?
 function forEachDefinition( model, callback ) {
   forEachGeneric( model, 'definitions', callback );
 }

package/lib/base/shuffle.js

@@ -2,7 +2,8 @@
 
 // By <https://github.com/bryc/code/blob/c97a26ad27a9f9d4f48cd3307fd8ee6f1772d4eb/jshash/PRNGs.md>:
 
-// The random seed must be an integer between 0 and 4294967295 (or 1 and 4294967296  = 2**32)
+// The random seed must be an integer between 1 and 4294967296 (= 2**32),
+// otherwise no shuffling takes place.
 function shuffleGen( seed ) {
   return (Number.isSafeInteger( seed ) && seed > 0)
     ? { shuffleArray, shuffleDict }

package/lib/checks/arrayOfs.js

@@ -32,7 +32,7 @@ function validateAssociationsInItems( member ) {
       }
     }
   };
-  if (this.artifact && ( this.artifact.kind === 'entity' || this.artifact.query ) && member && member.items && member.$path[2] === 'elements') {
+  if (this.artifact && this.artifact.kind === 'entity' && member && member.items && member.$path[2] === 'elements') {
     if (member.items.type) {
       const type = member.items.type.ref
         ? this.artifactRef(member.items.type)

package/lib/checks/defaultValues.js

@@ -53,7 +53,7 @@ function rejectParamDefaultsInHanaCds( member, memberName, prop, path ) {
  */
 function warnAboutDefaultOnAssociationForHanaCds( member, memberName, prop, path ) {
   const art = this.csn.definitions[path[1]];
-  if (!art.query && this.options.transformation === 'hdbcds' && member.target && member.default) {
+  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',

package/lib/checks/elements.js

@@ -208,6 +208,34 @@ function checkRecursiveTypeUsage( art ) {
     }
   }
 }
+
+/**
+ * Member validator to check that certain annotations (@cds.valid { from, to, key }) are not
+ * assigned to calculated elements in an entity.
+ *
+ * TODO: Allow @cds.valid on persisted calculated elements (when they become available).
+ *
+ * @param {CSN.Element} member the element to be checked
+ * @param {string} _memberName the elements name
+ * @param {string} _prop which kind of member are we looking at -> only prop "elements"
+ * @param {CSN.Path} _path the path to the member
+ */
+function rejectAnnotationsOnCalcElement( member, _memberName, _prop, _path ) {
+  if (this.artifact.kind === 'entity' && !(this.artifact.query && this.artifact.projection)) {
+    if (member.value) {
+      for (const anno in member) {
+        if (anno.startsWith('@cds.valid.')) {
+          this.error('anno-unexpected-temporal', member.$path, { anno },
+                     'Unexpected $(ANNO) assigned to a calculated element');
+        }
+      }
+    }
+  }
+}
 module.exports = {
-  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+  checkPrimaryKey,
+  checkVirtualElement,
+  checkManagedAssoc,
+  checkRecursiveTypeUsage,
+  rejectAnnotationsOnCalcElement,
 };