@sap/cds-compiler 2.15.4 → 3.0.0

package/lib/base/message-registry.js

@@ -45,6 +45,7 @@ const centralMessages = {
   'anno-definition':        { severity: 'Warning' },
   'anno-duplicate':         { severity: 'Error', configurableFor: true }, // does not hurt us
   'anno-duplicate-unrelated-layer': { severity: 'Error', configurableFor: true }, // does not hurt us
+  '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-kind': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
@@ -67,7 +68,7 @@ const centralMessages = {
   '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.rename' ] },
+  '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' },
 
@@ -80,6 +81,7 @@ const centralMessages = {
   'expected-type': { severity: 'Error' },
   'ref-sloppy-type': { severity: 'Error' },
   'type-unexpected-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
+  'type-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'expected-actionparam-type': { severity: 'Error' },
   'ref-sloppy-actionparam-type': { severity: 'Error' },
@@ -116,6 +118,7 @@ const centralMessages = {
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: true }, // does not hurt us
   'ref-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
+  'ref-expected-element': { severity: 'Error' },
 
   'rewrite-key-not-covered-explicit': { severity: 'Error', configurableFor: 'deprecated' },
   'rewrite-key-not-covered-implicit': { severity: 'Error', configurableFor: 'deprecated' },
@@ -128,14 +131,11 @@ const centralMessages = {
   'service-nested-context': { severity: 'Error', configurableFor: true }, // does not hurt compile, TODO
   'service-nested-service': { severity: 'Error', configurableFor: 'deprecated' }, // not supported yet
 
-  'syntax-anno-after-enum':   { severity: 'Error', configurableFor: true }, // does not hurt
-  'syntax-anno-after-params': { severity: 'Error', configurableFor: true }, // does not hurt
-  'syntax-anno-after-struct': { severity: 'Error', configurableFor: true }, // does not hurt
-  'syntax-csn-expected-cardinality': { severity: 'Error' }, // TODO: more than 30 chars
-  'syntax-csn-expected-length': { severity: 'Error' },
-  'syntax-csn-expected-translation': { severity: 'Error' }, // TODO: more than 30 chars
-  'syntax-csn-required-subproperty': { severity: 'Error' }, // TODO: more than 30 chars
-  'syntax-csn-unexpected-property': { severity: 'Error', configurableFor: true }, // is the removed
+  'syntax-expected-cardinality': { severity: 'Error' },
+  'syntax-expected-length': { severity: 'Error' },
+  'syntax-expected-translation': { severity: 'Error' },
+  'syntax-required-subproperty': { severity: 'Error' },
+  'syntax-unexpected-property': { severity: 'Error', configurableFor: true }, // is the removed
   'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
   'syntax-fragile-alias': { severity: 'Error', configurableFor: true },
   'syntax-fragile-ident': { severity: 'Error', configurableFor: true },
@@ -148,6 +148,8 @@ const centralMessages = {
   'syntax-missing-escape': { severity: 'Error' },
 
   'syntax-expected-integer': { severity: 'Error' },
+  'syntax-invalid-masked': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
 
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
 
@@ -193,27 +195,47 @@ for (const oldName in oldMessageIds) {
 
 // For messageIds, where no text has been provided via code (central def)
 const centralMessageTexts = {
+  'api-invalid-option': {
+    std: 'Option $(NAME) is deprecated! Use SNAPI options instead',
+    magicVars: 'Option “magicVars” is deprecated! 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 “$”?'
+  },
+
   'anno-duplicate': 'Duplicate assignment with $(ANNO)',
+  'anno-duplicate-unrelated-layer': 'Duplicate assignment with $(ANNO)',
+  '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',
-  'syntax-csn-expected-object': 'Expected object for property $(PROP)',
-  'syntax-csn-expected-column': 'Expected object or string \'*\' for property $(PROP)',
-  'syntax-csn-expected-natnum': 'Expected non-negative number for property $(PROP)',
-  'syntax-csn-expected-cardinality': 'Expected non-negative number or string \'*\' for property $(PROP)',
-  'syntax-csn-expected-reference': 'Expected non-empty string or object for property $(PROP)',
-  'syntax-csn-expected-term': 'Expected non-empty string or object for property $(PROP)',
-  'syntax-anno-after-struct': 'Avoid annotation assignments after structure definitions',
-  'syntax-anno-after-enum': 'Avoid annotation assignments after enum definitions',
-  'syntax-anno-after-params': 'Avoid annotation assignments after parameters',
+
+  'name-duplicate-element': {
+    'std': 'Generated element $(NAME) conflicts with another element',
+    'flatten-element-gen': 'Generated element $(NAME) conflicts with other generated element',
+    'flatten-element-exist': 'Flattened name of structured element conflicts with existing element $(NAME)',
+    'flatten-fkey-gen': 'Duplicate definition of foreign key element $(NAME) for association $(ART)',
+    'flatten-fkey-exists': 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element',
+  },
+
+  'syntax-unexpected-ellipsis': {
+    std: 'Expected no more than one $(CODE)',
+    'nested-array': 'Unexpected $(CODE) in nested array'
+  },
+  'syntax-expected-object': 'Expected object for property $(PROP)',
+  'syntax-expected-column': 'Expected object or string \'*\' for property $(PROP)',
+  'syntax-expected-natnum': 'Expected non-negative number for property $(PROP)',
+  'syntax-expected-cardinality': 'Expected non-negative number or string \'*\' for property $(PROP)',
+  'syntax-expected-reference': 'Expected non-empty string or object for property $(PROP)',
+  'syntax-expected-term': 'Expected non-empty string or object for property $(PROP)',
   'syntax-dollar-ident': {
     std: 'An artifact starting with $(NAME) might shadow a special variable - replace by another name',
     $tableAlias: 'A table alias name starting with $(NAME) might shadow a special variable - replace by another name',
     $tableImplicit: 'The resulting table alias starts with $(NAME) and might shadow a special variable - specify another name with $(KEYWORD)',
     mixin: 'A mixin name starting with $(NAME) might shadow a special variable - replace by another name' ,
   },
-  'syntax-csn-expected-length': {
+  'syntax-expected-length': {
     std: 'Expected array in $(PROP) to have at least $(N) items',
     one: 'Expected array in $(PROP) to have at least one item',
     suffix: 'With sibling property $(OTHERPROP), expected array in $(PROP) to have at least one item',
@@ -245,6 +267,20 @@ const centralMessageTexts = {
     unknown: 'Unknown argument $(CODE)',
     duplicate: 'Duplicate argument $(CODE)',
   },
+  'syntax-invalid-literal': {
+    'std': 'Invalid literal',
+    'uneven-hex': 'A binary literal must have an even number of characters',
+    'invalid-hex': 'A binary literal must only contain characters 0-9, a-f and A-F',
+    'time': 'Expected time\'hh:mm:ss\' where hh, mm and the optional ss are numbers',
+    'date': 'Expected date\'YYYY-MM-DD\' where YYYY, MM and DD are numbers',
+    'timestamp': 'Expected timestamp\'YYYY-MM-DD hh:mm:ss.u…u\' where YYYY, MM, DD, hh, mm, ss and u are numbers (optional 1-7×u)',
+  },
+  'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
+  'syntax-unexpected-vocabulary': {
+    std: 'Annotations can\'t be defined inside contexts or services',
+    service: 'Annotations can\'t be defined inside services',
+    context: 'Annotations can\'t be defined inside contexts',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -266,6 +302,10 @@ const centralMessageTexts = {
     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',
   },
+  'ref-expected-element': {
+    std: 'Expected element reference',
+    magicVar: 'Only elements of magic variable $(ID) can be selected',
+  },
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
     type: 'Unexpected $(KEYWORD) in type of a type definition',
@@ -423,7 +463,7 @@ const centralMessageTexts = {
  *        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]

package/lib/base/messages.js

@@ -27,7 +27,7 @@ let test$texts = null;
 /**
  * Returns true if at least one of the given messages is of severity "Error".
  *
- * @param {CSN.Message[]} messages
+ * @param {CompileMessage[]} messages
  * @returns {boolean}
  */
 function hasErrors( messages ) {
@@ -39,7 +39,7 @@ function hasErrors( messages ) {
  * and *cannot* be reclassified to a warning for the given module.
  * Won't detect already downgraded messages.
  *
- * @param {CSN.Message[]} messages
+ * @param {CompileMessage[]} messages
  * @param {string} moduleName
  * @returns {boolean}
  */
@@ -319,20 +319,23 @@ function createMessageFunctions( options, moduleName, model = null ) {
  * ```
  * @param {object} model
  * @param {CSN.Options} [options]
- * @param {string} [moduleName]
+ * @param {string|null} [moduleName]
  */
 function makeMessageFunction( model, options, moduleName = null ) {
-  // ensure message consistency during runtime with --test-mode
-  if (options.testMode)
+  if (options.testMode) {
+    // ensure message consistency during runtime with --test-mode
     _check$Init( options );
+    if (!options.messages)
+      throw new CompilerAssertion('makeMessageFunction() expects options.messages to exist in testMode!');
+  }
 
   const hasMessageArray = !!options.messages;
-  const deprecatedDowngradable = isDeprecatedEnabled( options, 'downgradableErrors' );
+  const deprecatedDowngradable = isDeprecatedEnabled( options, '_downgradableErrors' );
   /**
    * Array of collected compiler messages. Only use it for debugging. Will not
    * contain the messages created during a `callTransparently` call.
    *
-   * @type {CSN.Message[]}
+   * @type {CompileMessage[]}
    */
   let messages = options.messages || [];
   /**
@@ -361,7 +364,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     const [ fileLocation, semanticLocation, definition ] = _normalizeMessageLocation(location);
     const text = messageText( texts || centralMessageTexts[id], textOrArguments );
 
-    /** @type {CSN.Message} */
+    /** @type {CompileMessage} */
     const msg = new CompileMessage( fileLocation, text, severity, id, semanticLocation, moduleName );
     if (options.internalMsg)
       msg.error = new Error( 'stack' );
@@ -553,7 +556,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
    *
    * @param {Function} callback
    * @param  {...any} args
-   * @returns {CSN.Message[]}
+   * @returns {CompileMessage[]}
    */
   function callTransparently(callback, ...args) {
     const backup = messages;
@@ -579,6 +582,22 @@ function _check$Init( options ) {
   }
 }
 
+/**
+ * Check the consistency of the given message and run some basic lint checks.  These include:
+ *
+ *  - Long message IDs must be listed centrally.
+ *  - Messages with the same ID must have the same severity (in a module).
+ *  - Messages with the same ID must have the same message texts.
+ *    This ensures that $(PLACEHOLDERS) are used and that we don't accidentally
+ *    use the same ID for different meanings, i.e. texts.
+ *
+ * @param {string} id
+ * @param {string} moduleName
+ * @param {string} severity
+ * @param {string|object} texts
+ * @param {CSN.Options} options
+ * @private
+ */
 function _check$Consistency( id, moduleName, severity, texts, options ) {
   if (id.length > 30 && !centralMessages[id])
     throw new CompilerAssertion( `The message ID "${id}" has more than 30 chars and must be listed centrally` );
@@ -589,6 +608,16 @@ function _check$Consistency( id, moduleName, severity, texts, options ) {
     _check$Texts( id, variant, text );
 }
 
+/**
+ * Check the consistency of the message severity for the given message ID.
+ * Messages with the same ID must have the same severity (in a module).
+ * Non-downgradable errors must never be called with a lower severity.
+ *
+ * @param {string} id
+ * @param {string} moduleName
+ * @param {string} severity
+ * @private
+ */
 function _check$Severities( id, moduleName, severity ) {
   if (!severity)                // if just used message(), we are automatically consistent
     return;
@@ -598,22 +627,34 @@ function _check$Severities( id, moduleName, severity ) {
     if (!expected)
       test$severities[id] = severity;
     else if (expected !== severity)
-      throw new CompilerAssertion( `Expecting severity "${expected}" from previous call, not "${severity}" for message ID "${id}"` );
+      throw new CompilerAssertion( `Inconsistent severity: Expecting "${expected}" from previous call, not "${severity}" for message ID "${id}"` );
     return;
   }
   // now try whether the message could be something less than an Error in the module due to user wishes
   if (!isDowngradable( id, moduleName )) { // always an error in module
     if (severity !== 'Error')
-      throw new CompilerAssertion( `Expecting severity "Error", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
+      throw new CompilerAssertion( `Inconsistent severity: Expecting "Error", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
   }
   else if (spec.severity === 'Error') {
-    throw new CompilerAssertion( `Expecting the use of function message() when message ID "${id}" is a configurable error in module "${moduleName}"` );
+    throw new CompilerAssertion( `Inconsistent severity: Expecting the use of function message() when message ID "${id}" is a configurable error in module "${moduleName}"` );
   }
   else if (spec.severity !== severity) {
-    throw new CompilerAssertion( `Expecting severity "${spec.severity}", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
+    throw new CompilerAssertion( `Inconsistent severity: Expecting "${spec.severity}", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
   }
 }
 
+/**
+ * Check the consistency of the message text for the given message ID.
+ *
+ * Messages with the same ID must have the same message texts.
+ * This ensures that $(PLACEHOLDERS) are used and that we don't accidentally
+ * use the same ID for different meanings, i.e. texts.
+ *
+ * @param {string} id
+ * @param {string} prop
+ * @param {string} value
+ * @private
+ */
 function _check$Texts( id, prop, value ) {
   if (!test$texts[id])
     test$texts[id] = Object.create(null);
@@ -621,7 +662,7 @@ function _check$Texts( id, prop, value ) {
   if (!expected)
     test$texts[id][prop] = value;
   else if (expected !== value)
-    throw new CompilerAssertion( `Expecting text "${expected}", not "${value}" for message ID "${id}" and text variant "${prop}"`);
+    throw new CompilerAssertion( `Different texts for the same message ID. Expecting "${expected}", not "${value}" for ID "${id}" and text variant "${prop}"`);
 }
 
 const quote = {                 // could be an option in the future
@@ -819,7 +860,7 @@ function weakLocation( loc ) {
  * Example:
  *   <source>.cds:3:11: Error message-id: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
  *
- * @param {CSN.Message} err
+ * @param {CompileMessage} err
  * @param {boolean} [normalizeFilename]
  * @param {boolean} [noMessageId]
  * @param {boolean} [noHome]
@@ -841,7 +882,7 @@ function messageString( err, normalizeFilename, noMessageId, noHome ) {
  * Return message hash which is either the message string without the file location,
  * or the full message string if no semantic location is provided.
  *
- * @param {CSN.Message} msg
+ * @param {CompileMessage} msg
  * @returns {string} can be used to uniquely identify a message
  */
 function messageHash(msg) {
@@ -867,7 +908,7 @@ function messageHash(msg) {
  *   <source>.cds:3:11, at entity:“E”/element:“e”
  * ```
  *
- * @param {CSN.Message} err
+ * @param {CompileMessage} err
  * @param {object} [config = {}]
  * @param {boolean} [config.normalizeFilename] Replace windows `\` with forward slashes `/`.
  * @param {boolean} [config.noMessageId]
@@ -915,7 +956,7 @@ function messageStringMultiline( err, config = {} ) {
  *
  * @param {string[]} sourceLines The source code split up into lines, e.g. by `splitLines(src)`
  *                               from `lib/utils/file.js`
- * @param {CSN.Message} err Error object containing all details like line, message, etc.
+ * @param {CompileMessage} err Error object containing all details like line, message, etc.
  * @param {object} [config = {}]
  * @param {boolean | 'auto'} [config.color] If true, ANSI escape codes will be used for coloring the `^`.  If false, no
  *                                          coloring will be used.  If 'auto', we will decide based on certain factors such
@@ -994,8 +1035,8 @@ function messageContext(sourceLines, err, config) {
  * larger than `b`, and -1 if `a` is smaller than `b`. Messages without a location
  * are considered larger than messages with a location.
  *
- * @param {CSN.Message} a
- * @param {CSN.Message} b
+ * @param {CompileMessage} a
+ * @param {CompileMessage} b
  */
 function compareMessage( a, b ) {
   const aFile = a.$location && a.$location.file;
@@ -1029,8 +1070,8 @@ function compareMessage( a, b ) {
  * location and severity, >0 if `a` is larger than `b`, and <0 if `a` is smaller
  * than `b`. See `compareSeverities()` for how severities are compared.
  *
- * @param {CSN.Message} a
- * @param {CSN.Message} b
+ * @param {CompileMessage} a
+ * @param {CompileMessage} b
  */
 function compareMessageSeverityAware( a, b ) {
   const c = compareSeverities(a.severity, b.severity);
@@ -1042,7 +1083,7 @@ function compareMessageSeverityAware( a, b ) {
  * Messages without semantic locations are considered smaller (for syntax errors)
  * and (currently - should not happen in v2) larger for other messages.
  *
- * @param {CSN.Message} msg
+ * @param {CompileMessage} msg
  */
 function homeSortName( { home, messageId } ) {
   return (!home)
@@ -1061,7 +1102,7 @@ function homeSortName( { home, messageId } ) {
  * A message is more precise if it is contained in the other or if
  * the first does not have an endLine/endCol.
  *
- * @param {CSN.Message[]} messages
+ * @param {CompileMessage[]} messages
  */
 function deduplicateMessages( messages ) {
   const seen = new Map();

package/lib/base/model.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { forEach } = require("../utils/objectUtils");
+
 const queryOps = {
   query: 'select',                // TODO: rename to SELECT
   union: 'union',
@@ -20,7 +22,6 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   toRename: true,
-  addTextsLanguageAssoc: true,
   assocsWithParams: true,
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true,
@@ -58,16 +59,56 @@ function isBetaEnabled( options, feature ) {
  * Please do not move this function to the "option processor" code.
  *
  * @param {object} options Options
- * @param {string} [feature] Feature to check for
+ * @param {string|null} [feature] Feature to check for
  * @returns {boolean}
  */
 function isDeprecatedEnabled( options, feature = null ) {
   const { deprecated } = options;
   if (!feature)
     return !!deprecated;
+
   return deprecated && typeof deprecated === 'object' && deprecated[feature];
 }
 
+const oldDeprecatedFlags_v2 = [
+  'createLocalizedViews',
+  'downgradableErrors',
+  'generatedEntityNameWithUnderscore',
+  'longAutoexposed',
+  'noElementsExpansion',
+  'noInheritedAutoexposeViaComposition',
+  'noScopedRedirections',
+  'oldVirtualNotNullPropagation',
+  'parensAsStrings',
+  'projectionAsQuery',
+  'redirectInSubQueries',
+  'renderVirtualElements',
+  'shortAutoexposed',
+  'unmanagedUpInComponent',
+  'v1KeysForTemporal',
+];
+
+/**
+ * In cds-compiler v3, we removed old v2 deprecated flags.  That can lead to silent
+ * errors such as entity/view names changing.  To ensure that the user is forced
+ * 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().
+ */
+function checkRemovedDeprecatedFlags( options, { error } ) {
+  // Assume that we emitted these errors once if a message with this ID was found.
+  if (!options.deprecated || options.messages?.some(m => m.messageId === 'api-invalid-deprecated'))
+    return;
+
+  forEach(options.deprecated, (key, val) => {
+    if (val && oldDeprecatedFlags_v2.includes(key)) {
+      error('api-invalid-deprecated', null, { name: key },
+        'Deprecated flag $(NAME) has been removed in CDS compiler v3');
+    }
+  });
+}
+
 // Apply function `callback` to all artifacts in dictionary
 // `model.definitions`.  See function `forEachGeneric` for details.
 function forEachDefinition( model, callback ) {
@@ -129,6 +170,7 @@ module.exports = {
   isBetaEnabled,
   availableBetaFlags,
   isDeprecatedEnabled,
+  checkRemovedDeprecatedFlags,
   queryOps,
   forEachDefinition,
   forEachMember,

package/lib/checks/actionsFunctions.js

@@ -16,8 +16,8 @@ function checkActionOrFunction(art, artName, prop, path) {
   if (!(art.kind === 'action' || art.kind === 'function') && !art.actions)
     return;
 
-  // const isMultiSchema = this.options.toOdata.odataFormat === 'structured' &&
-  //   (this.options.toOdata.odataProxies || this.options.toOdata.odataXServiceRefs);
+  // const isMultiSchema = this.options.odataFormat === 'structured' &&
+  //   (this.options.odataProxies || this.options.odataXServiceRefs);
 
   const serviceName = this.csnUtils.getServiceName(artName);
   if (!serviceName)
@@ -85,9 +85,11 @@ function checkActionOrFunction(art, artName, prop, path) {
    * @param {string} actKind 'action' or 'function'
    */
   function checkReturns(returns, currPath, actKind) {
-    const finalReturnType = returns.type ? this.csnUtils.getFinalBaseType(returns.type) : returns;
+    const finalReturnType = returns.type ? this.csnUtils.getFinalBaseTypeWithProps(returns.type) : returns;
+    if (!finalReturnType)
+      return; // no type, e.g. `type of V:calculated`; already an error in `checkTypeOfHasProperType()`
 
-    if (this.csnUtils.isAssocOrComposition(finalReturnType)) {
+    if (this.csnUtils.isAssocOrComposition(finalReturnType.type)) {
       this.error(null, currPath, { '#': actKind },
                  {
                    std: 'An association is not allowed as this artifact\'s return type', // Not used
@@ -98,7 +100,7 @@ function checkActionOrFunction(art, artName, prop, path) {
 
     if (finalReturnType.items) // check array return type
       checkReturns.bind(this)(finalReturnType.items, currPath.concat('items'), actKind);
-    else // check if return type is user definited from the current service
+    else // check if return type is user defined from the current service
       checkUserDefinedType.bind(this)(finalReturnType, returns.type, currPath);
   }
 

package/lib/checks/annotationsOData.js

@@ -23,7 +23,7 @@ function checkCoreMediaTypeAllowence(member) {
     'cds.hana.CLOB': 1,
     'cds.hana.BINARY': 1,
   };
-  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseType(member.type) in allowedCoreMediaTypes)) {
+  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type in allowedCoreMediaTypes)) {
     this.warning(null, member.$path, { names: [ 'Edm.String', 'Edm.Binary' ] },
                  'Element annotated with “@Core.MediaType” should be of a type mapped to $(NAMES)');
   }

package/lib/checks/cdsPersistence.js

@@ -14,6 +14,7 @@ function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
   if (artifact.kind === 'entity') {
     // filter for 'table', 'udf', 'calcview' === true
     const persistenceAnnos = [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ];
+    // TODO: Why not filter over persistenceAnnos, is shorter!
     const TableUdfCv = Object.keys(artifact).filter(p => persistenceAnnos.includes(p) && artifact[p]);
     if (TableUdfCv.length > 1)
       this.error(null, path, `Annotations ${ TableUdfCv.join(', ') } can't be used in combination`);

package/lib/checks/elements.js

@@ -36,10 +36,10 @@ function checkPrimaryKey(art) {
    */
   function checkIfPrimaryKeyIsOfGeoType(member, elemFqName, parentIsKey, parentPath) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseType(member.type);
-      if (typeof finalBaseType === 'string' && isGeoTypeName(finalBaseType)) {
+      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
+      if (isGeoTypeName(finalBaseType?.type)) {
         this.error(null, parentPath || member.$path,
-                   { type: finalBaseType, name: elemFqName },
+                   { type: finalBaseType.type, name: elemFqName },
                    'Type $(TYPE) can\'t be used as primary key in element $(NAME)');
       }
       else if (finalBaseType && this.csnUtils.isStructured(finalBaseType)) {
@@ -63,7 +63,7 @@ function checkPrimaryKey(art) {
    */
   function checkIfPrimaryKeyIsArray(member, elemFqName, parentIsKey, parentPath) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseType(member.type);
+      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
       if (member.items || (finalBaseType && finalBaseType.items)) {
         this.error(null, parentPath || member.$path, { name: elemFqName },
                    'Array-like type in element $(NAME) can\'t be used as primary key');
@@ -96,10 +96,10 @@ function checkVirtualElement(member) {
 
 /**
  * Checks whether managed associations
- * with cardinality 'to many' have an on-condition
- * and if managed associations have foreign keys.
+ * with cardinality 'to many' have an on-condition.
  *
  * @param {CSN.Artifact} art The artifact
+ * @todo this is a member validator, is it not?
  */
 function checkManagedAssoc(art) {
   forEachMemberRecursively(art, (member) => {

package/lib/checks/invalidTarget.js

@@ -26,7 +26,7 @@ function invalidTarget(member) {
       if (!target)
         throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
-        const isAssoc = this.csnUtils.getFinalBaseType(member.type) !== 'cds.Composition';
+        const isAssoc = this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type !== 'cds.Composition';
         this.error(
           null,
           member.$path,

package/lib/checks/nonexpandableStructured.js

@@ -21,7 +21,7 @@ function nonexpandableStructuredInExpression(parent, name, expression) {
       if (_art) {
         _art = resolveArtifactType.call(this, _art);
         // Paths of an expression may end on a structured element only if both operands in the expression end on a structured element
-        if (_art.elements && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
+        if (_art?.elements && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
           this.error(null, expression[i].$path, { elemref: { ref } },
                      'Unexpected usage of structured type $(ELEMREF)');
         }

package/lib/checks/queryNoDbArtifacts.js

@@ -3,7 +3,8 @@
 const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('../model/csnUtils');
 /**
  * Make sure that all source artifacts and association targets reach the database
- * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database
+ * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database // <- what does this mean?
+ *
  * Check the given query for:
  * - Associations-traversal over skipped/abstract things
  * - Associations (indirectly) using managed associations without foreign keys

package/lib/checks/selectItems.js

@@ -5,9 +5,13 @@ const { forEachGeneric } = require('../model/csnUtils');
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
- * Validate select items of a query.
+ * Validate select items of a query. If a column reference starts with $self or $projection, it must not contain association steps.
+ * Furthermore, for to.hdbcds, window functions are not allowed.
+ *
+ * For to.hdbcds-hdbcds, structures and managed associations are not allowed as they are not flattened - @see rejectManagedAssociationsAndStructuresForHdbcdsNames
  *
  * @param {CSN.Query} query query object
+ * @todo Why do we care about this with $self?
  */
 function validateSelectItems(query) {
   const { SELECT } = query;

package/lib/checks/types.js

@@ -129,8 +129,8 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
   if (!artOrElement.type)
     return;
 
-  const { getFinalBaseType } = getUtils(model);
-  const typeOfType = getFinalBaseType(artOrElement.type, path);
+  const { getFinalBaseTypeWithProps } = getUtils(model);
+  const typeOfType = getFinalBaseTypeWithProps(artOrElement.type);
 
   if (typeOfType === null) {
     if (artOrElement.type.ref) {
@@ -157,6 +157,7 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
  * @param {CSN.Path} path the path to the element or the artifact
  * @param {string} name of the element or the artifact which is dubious
  * @param {boolean} isElement indicates whether we are dealing with an element or an artifact
+ * @todo Rename, is an error not a warning
  */
 function warnAboutMissingType(error, path, name, isElement = false) {
   error('check-proper-type', path, { art: name, '#': isElement ? 'elm' : 'std' }, {
@@ -173,6 +174,7 @@ function warnAboutMissingType(error, path, name, isElement = false) {
  *
  * @param {CSN.Artifact} artifact the artifact to check
  * @returns {boolean} indicates whether the artifact has type information
+ * @todo What is the point of isBuiltinType here if we check for artifact.type at the end?
  */
 function hasArtifactTypeInformation(artifact) {
   // When is what property set?

package/lib/checks/utils.js

@@ -31,7 +31,7 @@ function otherSideIsExpandableStructure(on, startIndex) {
   return false;
 
   /**
-   * Artifact is structured or a managed association/compoisition
+   * Artifact is structured or a managed association/composition
    *
    * @param {CSN.Artifact} art Artifact
    * @returns {boolean} True if expandable
@@ -49,7 +49,7 @@ function otherSideIsExpandableStructure(on, startIndex) {
  */
 function resolveArtifactType(art) {
   if (art && art.type && !isBuiltinType(art.type))
-    return this.getFinalBaseType(art);
+    return this.csnUtils.getFinalBaseTypeWithProps(art.type);
 
   return art;
 }