@sap/cds-compiler 5.9.4 → 6.0.12

package/lib/base/messages.js

@@ -6,8 +6,13 @@
 
 const { term } = require('../utils/term');
 const { Location, locationString } = require('./location');
-const { isDeprecatedEnabled, isBetaEnabled } = require('./model');
-const { centralMessages, centralMessageTexts, oldMessageIds } = require('./message-registry');
+const { isBetaEnabled } = require('./model');
+const {
+  centralMessages,
+  configurableForValidValues,
+  centralMessageTexts,
+  oldMessageIds,
+} = require('./message-registry');
 const _messageIdsWithExplanation = require('../../share/messages/message-explanations.json').messages;
 const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
 const { CompilerAssertion } = require('./error');
@@ -54,8 +59,10 @@ function hasNonDowngradableErrors( messages, moduleName, options ) {
 
 /**
  * Returns true if the given message id exist in the central message register and is
- * downgradable, i.e. an error can be reclassified to a warning or lower.
- * Returns false if the messages is an errorFor the given moduleName.
+ * downgradable
+ *  - Non-errors are not downgradable if the moduleName is listed in the
+ *    `errorFor` property
+ *  - Errors might be downgradable according to the `configurableFor` property,
  *
  * @param {string} messageId
  * @param {string} moduleName
@@ -70,17 +77,12 @@ function isDowngradable( messageId, moduleName, options ) {
 
   // errorFor has the highest priority.  If the message is an error for
   // the module, it is NEVER downgradable.
-  if (msg.errorFor && msg.errorFor.includes(moduleName))
-    return false;
   if (msg.severity !== 'Error')
-    return true;
-  // v6 messages are downgradable (except if errorFor also contains the current module).
-  if (msg.errorFor && msg.errorFor.includes('v6'))
-    return true;
+    return !msg.errorFor?.includes( moduleName );
   const { configurableFor } = msg;
   return (Array.isArray( configurableFor ))
     ? configurableFor.includes( moduleName )
-    : configurableFor && (configurableFor !== 'deprecated' || isDeprecatedEnabled( options, 'downgradableErrors' ));
+    : configurableFor && configurableForValidValues[configurableFor]?.( options );
 }
 
 /**
@@ -90,14 +92,16 @@ function isDowngradable( messageId, moduleName, options ) {
  * @returns {string}
  */
 function severityChangeMarker( msg, config ) {
-  const severity = msg.severity || 'Error';
-  if (config.moduleForMarker) {
-    if (severity === 'Error' &&
-        isDowngradable( msg.messageId, config.moduleForMarker,
+  if (config.moduleForMarker && msg.messageId) {
+    if (!msg.severity || msg.severity === 'Error') {
+      if (isDowngradable( msg.messageId, config.moduleForMarker,
                         { deprecated: { downgradableErrors: true } }))
-      return '‹↓›';
-    if (msg.messageId && centralMessages[msg.messageId]?.errorFor?.includes('v6'))
+        // Do not include testMode here, no marker for configurableFor: 'test'
+        return '‹↓›';
+    }
+    else if (centralMessages[msg.messageId]?.errorFor?.includes( 'v7' )) {
       return '‹↑›';
+    }
   }
   return '';
 }
@@ -246,7 +250,7 @@ function reclassifiedSeverity( msg, options, moduleName ) {
       if (errorFor.includes(moduleName))
         return 'Error';
 
-      if (errorFor.includes('v6') && isBetaEnabled(options, 'v6preview')) {
+      if (errorFor.includes('v7') && isBetaEnabled(options, 'v7preview')) {
         severity = 'Error';
         if (!isDowngradable(msg.messageId, moduleName, options))
           return severity;
@@ -755,7 +759,7 @@ const quote = {            // could be an option in the future
   single: p => `‘${ p }’`, // for other things cited from or expected in the model
   angle: p => `‹${ p }›`, // for tokens like ‹Identifier›, and similar
   direct: p => p,          // e.g. for numbers _not cited from or expected in_ the source
-  upper: p => p.toUpperCase(), // for keywords reported by ANTLR, use prop.single in v4
+  upper: p => p.toUpperCase(),
 };
 
 const paramsTransform = {
@@ -774,6 +778,7 @@ const paramsTransform = {
   subprop: quote.single,
   otherprop: quote.single,
   code: quote.single,
+  enum: sym => quote.single( `#${ sym }`),
   newcode: quote.single,
   kind: quote.single,
   meta: quote.angle,
@@ -1489,12 +1494,17 @@ function homeName( art, absoluteOnly ) {
     return art;
   if (art._user)               // when providing a path item with filter as “user”
     return homeName( art._user, absoluteOnly );
-  if (art._outer) {              // in items property, or annotation with path
+  if (art._outer) {             // in items property, or annotation with path
+    if (art._outer?.kind === '$annotation')
+      art = art._outer;
     const outer = homeName( art._outer, absoluteOnly );
     if (art.kind === '$annotation') // eslint-disable-next-line sonarjs/no-nested-template-literals
       return `${ outer }/${ quoted( `@${ art.name.id }` ) }`;
     return outer;
   }
+  else if (art.kind === '$annotation') { // in items property, or annotation with path
+    return quoted( `@${ art.name.id }` );
+  }
   else if (art.kind === 'source' || !art.name) { // error reported in parser or on source level
     return null;
   }
@@ -1899,6 +1909,8 @@ function sanitizeCsnPath( csnPath ) {
  */
 function explainMessage( messageId ) {
   messageId = oldMessageIds[messageId] || messageId;
+  if (Array.isArray(messageId))
+    messageId = messageId[0]; // take first just in case
   const filename = path.join(__dirname, '..', '..', 'share', 'messages', `${ messageId }.md`);
   return fs.readFileSync(filename, 'utf8');
 }
@@ -1912,7 +1924,9 @@ function explainMessage( messageId ) {
  * @returns {boolean}
  */
 function hasMessageExplanation( messageId ) {
-  const id = oldMessageIds[messageId] || messageId || false;
+  let id = oldMessageIds[messageId] || messageId || false;
+  if (Array.isArray(id))
+    id = id[0];
   return id && _messageIdsWithExplanation.includes(id);
 }
 

package/lib/base/model.js

@@ -25,7 +25,7 @@ const availableBetaFlags = {
   tenantVariable: true,
   calcAssoc: true,
   temporalRawProjection: true,
-  v6preview: true,
+  v7preview: true,
   draftMessages: true,
   rewriteAnnotationExpressionsViaType: true,
   sqlServiceDummies: true,
@@ -36,31 +36,21 @@ const availableBetaFlags = {
 // Used by isDeprecatedEnabled() to check if any flag ist set.
 const availableDeprecatedFlags = {
   // the old ones starting with _, : false
+  noPersistenceJournalForGeneratedEntities: true, // since v6
   downgradableErrors: true,
-  includesNonShadowedFirst: true,
-  eagerPersistenceForGeneratedEntities: true,
-  noKeyPropagationWithExpansions: true,
+  noCompositionIncludes: true, // since v6; was an option with inverted meaning in v5
+  noQuasiVirtualAssocs: true, // since v6
+  _includesNonShadowedFirst: true,
+  _eagerPersistenceForGeneratedEntities: true,
+  _noKeyPropagationWithExpansions: true,
   ignoreSpecifiedQueryElements: true,
 };
 
-const oldDeprecatedFlagsV2 = [
-  'createLocalizedViews',
-  // 'downgradableErrors', // re-added in v4
-  'generatedEntityNameWithUnderscore',
-  'longAutoexposed',
-  'noElementsExpansion',
-  'noInheritedAutoexposeViaComposition',
-  'noScopedRedirections',
-  'oldVirtualNotNullPropagation',
-  'parensAsStrings',
-  'projectionAsQuery',
-  'redirectInSubQueries',
-  'renderVirtualElements',
-  'shortAutoexposed',
-  'unmanagedUpInComponent',
-  'v1KeysForTemporal',
-  // do not add old deprecated flags which should not lead to an error:
-  // autoCorrectOrderBySourceRefs - just info would be ok
+// Deprecated flags that were removed in v5.
+const oldDeprecatedFlagsV5 = [
+  'includesNonShadowedFirst',
+  'eagerPersistenceForGeneratedEntities',
+  'noKeyPropagationWithExpansions',
 ];
 
 /**
@@ -120,9 +110,9 @@ function checkRemovedDeprecatedFlags( options, { error } ) {
     return;
 
   forEach(options.deprecated, (key, val) => {
-    if (val && oldDeprecatedFlagsV2.includes(key)) {
+    if (val && oldDeprecatedFlagsV5.includes(key)) {
       error('api-invalid-deprecated', null, { name: key },
-            'Deprecated flag $(NAME) has been removed in CDS compiler v3');
+            'Deprecated flag $(NAME) has been removed in CDS compiler v6');
     }
   });
 }

package/lib/checks/actionsFunctions.js

@@ -68,13 +68,8 @@ function checkActionOrFunction( art, artName, prop, path ) {
     if (!paramType)
       return; // no type could be resolved
 
-    if (param.type && this.csnUtils.isAssocOrComposition(param)) {
-      this.error(null, currPath, { '#': actKind }, {
-        std: 'An association is not allowed as this artifact\'s parameter type', // Not used
-        action: 'An association is not allowed as action\'s parameter type',
-        function: 'An association is not allowed as function\'s parameter type',
-      });
-    }
+    if (param.type && this.csnUtils.isAssocOrComposition(param))
+      this.error('ref-unexpected-assoc-type', currPath, { '#': `${ actKind }-param` });
 
     if (paramType.items?.type)
       checkActionOrFunctionParameter.call(this, paramType.items, currPath.concat('items'), actKind);
@@ -95,14 +90,8 @@ function checkActionOrFunction( art, artName, prop, path ) {
     if (!finalReturnType)
       return; // no type, e.g. `type of V:calculated`; already an error in `checkTypeOfHasProperType()`
 
-    if (this.csnUtils.isAssocOrComposition(returns)) {
-      this.error(null, currPath, { '#': actKind },
-                 {
-                   std: 'An association is not allowed as this artifact\'s return type', // Not used
-                   action: 'An association is not allowed as action\'s return type',
-                   function: 'An association is not allowed as function\'s return type',
-                 });
-    }
+    if (this.csnUtils.isAssocOrComposition(returns))
+      this.error('ref-unexpected-assoc-type', currPath, { '#': `${ actKind }-returns` });
 
     if (finalReturnType.items) // check array return type
       checkReturns.call(this, finalReturnType.items, currPath.concat('items'), actKind);
@@ -118,14 +107,15 @@ function checkActionOrFunction( art, artName, prop, path ) {
    * @param {CSN.Path} currPath The current path
    */
   function checkUserDefinedType( type, typeName, currPath ) {
-    // TODO: isBuiltinType does not resolve any type-chains.
-    if (!isBuiltinType(type.type) && type.kind && type.kind !== 'type') {
+    if (type.kind && type.kind !== 'type' && type.type && !isBuiltinType(this.csnUtils.getFinalTypeInfo(type.type)?.type)) {
       const serviceOfType = this.csnUtils.getServiceName(typeName);
       if (serviceName && serviceName !== serviceOfType) {
         // if (!(isMultiSchema && serviceOfType)) {
-        this.error(null, currPath,
-                   { type: typeName, kind: type.kind, service: serviceName },
-                   'Referenced $(KIND) $(TYPE) can\'t be used in service $(SERVICE) because it is not defined in $(SERVICE)');
+        this.error('ref-expected-service-type', currPath, { type: typeName, kind: type.kind, service: serviceName }, {
+          std: 'Referenced $(KIND) $(TYPE) can\'t be used in service $(SERVICE) because it is defined outside the service',
+          entity: 'Referenced entity $(TYPE) can\'t be used in service $(SERVICE) because it is defined outside the service',
+          type: 'Referenced type $(TYPE) can\'t be used in service $(SERVICE) because it is defined outside the service',
+        });
         // }
       }
     }

package/lib/checks/annotationsOData.js

@@ -108,7 +108,7 @@ function checkTemporalAnnotationsAssignment( artifact, artifactName ) {
    * @param {CSN.Path} path
    */
   function checkForAnnoAssignmentAndApplicability( annoIdentifier, member, path ) {
-    if (this.csnUtils.hasAnnotationValue(member, `@cds.valid.${ annoIdentifier }`)) {
+    if (member[`@cds.valid.${ annoIdentifier }`]) {
       valid[annoIdentifier].push(path);
       // check whether annotation is not assigned to not allowed element type, these are: association, structured elements, leaf element of a structure
       if (this.csnUtils.isAssocOrComposition(member) || this.csnUtils.isStructured(member) || path.length > 5)

package/lib/checks/elements.js

@@ -1,7 +1,10 @@
 'use strict';
 
 const {
-  forEachMember, forEachMemberRecursively, cardinality2str,
+  forEachMember,
+  forEachMemberRecursively,
+  cardinality2str,
+  hasPersistenceSkipAnnotation,
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { isGeoTypeName } = require('../compiler/builtins');
@@ -41,9 +44,8 @@ function checkPrimaryKey( art ) {
     if (member.key || parentIsKey) {
       const finalBaseType = this.csnUtils.getFinalTypeInfo(member.type);
       if (isGeoTypeName(finalBaseType?.type)) {
-        this.error(null, parentPath || member.$path,
-                   { type: finalBaseType.type, name: elemFqName },
-                   'Type $(TYPE) can\'t be used as primary key in element $(NAME)');
+        this.error('ref-unsupported-type', parentPath || member.$path,
+                   { '#': 'key', type: finalBaseType.type, name: elemFqName });
       }
       else if (finalBaseType && this.csnUtils.isStructured(finalBaseType) && !finalBaseType.$visited) {
         setProp(finalBaseType, '$visited', true);
@@ -105,7 +107,7 @@ function checkPrimaryKey( art ) {
 function checkVirtualElement( member ) {
   if (member.virtual) {
     if (this.csnUtils.isAssocOrComposition(member))
-      this.error(null, member.$path, {}, 'Element can\'t be virtual and an association or composition');
+      this.error('def-unexpected-virtual', member.$path, { keyword: 'virtual' });
   }
 }
 
@@ -119,12 +121,36 @@ function checkVirtualElement( member ) {
 function checkManagedAssoc( member ) {
   if (!member.target || isManagedComposition.bind(this)(member))
     return;
+
+  const targetMax = member.cardinality?.max ?? 1;
+  if (targetMax === 1 || member.on)
+    return;
+
+  // Special case for "--with-mocks" of the cds cli: For testing databases such as H2 and SQLite, we allow
+  // associations with neither on-condition nor foreign keys if the CSN is mocked.
+  // See #13916 for details.
+  const allowForMocked = this.csn._mocked && (this.options.sqlDialect === 'h2' || this.options.sqlDialect === 'sqlite');
+
+  const isPersisted = !hasPersistenceSkipAnnotation(this.artifact) && !this.artifact['@cds.persistence.exists'];
+  if (isPersisted && !allowForMocked && !member.keys && (targetMax === '*' || Number(targetMax) > 1) && this.options.transformation === 'sql') {
+    // Since cds-compiler v6, managed to-many no longer get 'keys'.
+    // As this would lead to DROP COLUMNs, emit an error instead.
+    this.error('type-missing-on-condition', member.cardinality?.$path || member.$path, {
+      value: cardinality2str(member, false),
+      '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
+    }, {
+      // same as 'to-many-no-on', but as error
+      std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
+      comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
+    });
+  }
+
   // 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 ?? 1;
-  if (max === 1 || member.on || !member.keys || member.keys.length === 0)
+  if (!member.keys || member.keys.length === 0)
     return;
+
   // We use the fact that `key` is only supported top-level (warning otherwise).
   // And if an element of a structured _type_ is "key", we get a warning for the key.
   // However, we may get false negatives for our warning, which is acceptable, e.g. for
@@ -135,8 +161,7 @@ function checkManagedAssoc( member ) {
   if (!coversAllTargetKeys.call(this, foreignKeys, targetKeys))
     return; // foreign key does not cover at least one target key -> can be to-many
 
-  const isNoDb = this.artifact['@cds.persistence.skip'] || this.artifact['@cds.persistence.exists'];
-  this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality?.$path || member.$path, {
+  this.warning(!isPersisted ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality?.$path || member.$path, {
     value: cardinality2str(member, false),
     '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
   }, {
@@ -256,7 +281,7 @@ function checkRecursiveTypeUsage( art ) {
       if (!isDeref && this.options.odataVersion === 'v4' && this.options.odataFormat === 'structured')
         return;
       if (!def.$recErr) {
-        this.error(null, loc, {}, 'Unexpected recursive type definition');
+        this.error('ref-cyclic', loc, { '#': 'type', type: type ?? prevType });
         setProp(def, '$recErr', true);
       }
     }

package/lib/checks/enums.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { ModelError } = require('../base/error');
+
+/**
+ * Removes the `enum` property - the compiler already resolved them.
+ *
+ * @param {Object} parent
+ */
+function removeEnum( parent ) {
+  delete parent.enum;
+}
+
+/**
+ * Check if '#' has a  `val` property. If val is undefined, an error is logged as this means that the compiler could not resolve the reference.
+ *
+ * If the reference was resolved, remove # and keep the .val.
+ *
+ * @param {Object} parent
+ */
+function checkAndRemoveHash( parent ) {
+  if (parent.val === undefined)
+    throw new ModelError('Expected value to be resolved by the compiler - throwing exception to trigger recompilation.');
+
+  delete parent['#'];
+}
+
+module.exports = {
+  enum: removeEnum,
+  '#': checkAndRemoveHash,
+};

package/lib/checks/foreignKeys.js

@@ -42,7 +42,7 @@ function validateForeignKeys( member, memberName ) {
   // Declared as arrow-function to keep scope the same (this value)
   const checkForItemsOrMissingType = (mem, memName) => {
     if (mem.items) {
-      this.error(null, member.$path, {}, 'Array-like properties must not be foreign keys');
+      this.error('type-invalid-foreign-key', member.$path, { '#': 'items' });
     }
     else if (mem.keys) {
       handleAssociation(mem);
@@ -52,7 +52,7 @@ function validateForeignKeys( member, memberName ) {
     }
     else if (mem.type) {
       if (mem.type === 'cds.Map') {
-        this.error(null, member.$path, { type: mem.type }, 'Unexpected type $(TYPE) in foreign key');
+        this.error('type-invalid-foreign-key', member.$path, { '#': 'std', type: mem.type } );
       }
       else {
         const type = mem.type.ref

package/lib/checks/hasPersistedElements.js

@@ -35,6 +35,11 @@ function hasRealElements( elements ) {
         if (hasRealElements(element.elements))
           return true;
       }
+      else if (element.target) {
+        if (element.keys?.length > 0)
+          return true;
+        // else: either unmanaged or no keys
+      }
       else {
         return true;
       }

package/lib/checks/invalidTarget.js

@@ -24,7 +24,7 @@ function invalidTarget( member ) {
   const checkForInvalidTarget = (mem) => {
     if (mem.target) {
       const target = this.csn.definitions[mem.target];
-      if (!target)
+      if (!target)              // `[object Object]` → anonymous target aspect
         throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
         const isAssoc = this.csnUtils.getFinalTypeInfo(member.type)?.type !== 'cds.Composition';

package/lib/checks/managedWithoutKeys.js

@@ -1,18 +1,19 @@
 'use strict';
 
-
 const { ModelError } = require('../base/error');
 
 /**
- * Trigger a recompilation in case of an association without .keys and without .on
+ * Trigger a recompilation in case of an to-one association without .keys and without .on
  *
  * @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"
  */
 function managedWithoutKeys( member, memberName, prop ) {
-  if (prop === 'elements' && member.target && !member.keys && !member.on) { // trigger recompilation
-    throw new ModelError('Expected association to have either an on-condition or foreign keys.');
+  if (prop === 'elements' && member.target && !member.keys && !member.on) {
+    const targetMax = member.cardinality?.max;
+    if (!targetMax || targetMax === 1)
+      throw new ModelError('Expected association to have either an on-condition or foreign keys.');
   }
 }
 

package/lib/checks/queryNoDbArtifacts.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { hasAnnotationValue, isPersistedOnDatabase } = require('../model/csnUtils');
+const { isPersistedOnDatabase, hasPersistenceSkipAnnotation } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { requireForeignKeyAccess } = require('./onConditions');
 const { pathId } = require('../model/csnRefs');
@@ -22,7 +22,7 @@ const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy
  * @param {CSN.Query} query Query to check
  */
 function checkQueryForNoDBArtifacts( query ) {
-  if (isPersistedOnDatabase(this.artifact) && !hasAnnotationValue(this.artifact, '@cds.persistence.table')) {
+  if (isPersistedOnDatabase(this.artifact) && !this.artifact['@cds.persistence.table']) {
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
@@ -164,7 +164,7 @@ function _checkRef( ref, _links, $path, inColumns ) {
       }
 
       if (isJoinRelevant) {
-        const cdsPersistenceSkipped = hasAnnotationValue(targetArt, '@cds.persistence.skip');
+        const cdsPersistenceSkipped = hasPersistenceSkipAnnotation(targetArt);
         this.error( null, $path, {
           '#': cdsPersistenceSkipped ? 'std' : 'abstract',
           anno: '@cds.persistence.skip',
@@ -180,11 +180,7 @@ function _checkRef( ref, _links, $path, inColumns ) {
     }
 
     // check managed association to have foreign keys array filled
-    if (art.keys && !hasForeignKeys.call(this, art)) {
-      this.error('expr-missing-foreign-key', $path, { id: pathStep, elemref: { ref } } );
-      break; // only one error per path
-    }
-    else if (art.on) {
+    if (art.target && art.on) {
       for (let j = 0; j < art.on.length - 2; j++) {
         if (art.on[j].ref && art.on[j + 1] === '=' && art.on[j + 2].ref) {
           const [ fwdAssoc, fwdPath ] = getForwardAssociation(pathStep, art.on[j], art.on[j + 2]);
@@ -196,6 +192,12 @@ function _checkRef( ref, _links, $path, inColumns ) {
         }
       }
     }
+    else if (art.target && !hasForeignKeys.call(this, art)) {
+      // Either no 'keys' array or an empty one.  Since v6, to-many associations
+      // may have neither ON-condition nor foreign keys.
+      this.error('expr-missing-foreign-key', $path, { id: pathStep, elemref: { ref } } );
+      break; // only one error per path
+    }
   }
 }
 

package/lib/checks/types.js

@@ -1,9 +1,9 @@
 'use strict';
 
-const { hasAnnotationValue } = require('../model/csnUtils');
-
 // Only to be used with validator.js - a correct this value needs to be provided!
 
+const { hasPersistenceSkipAnnotation } = require('../model/csnUtils');
+
 /**
  * Scale must not be 'variable' or 'floating'
  *
@@ -15,9 +15,9 @@ const { hasAnnotationValue } = require('../model/csnUtils');
  * @param {CSN.Path} path the path to the member
  */
 function checkDecimalScale( member, memberName, prop, path ) {
-  if (hasAnnotationValue(this.artifact, '@cds.persistence.exists') ||
-     // skip is already filtered in validator, here for completeness
-     hasAnnotationValue(this.artifact, '@cds.persistence.skip'))
+  if (this.artifact['@cds.persistence.exists'] ||
+      // skip is already filtered in validator, here for completeness
+      hasPersistenceSkipAnnotation(this.artifact))
     return;
   if (member.scale && (member.scale === 'variable' || member.scale === 'floating'))
     this.error(null, path, { name: member.scale }, 'Unexpected scale $(NAME)');

package/lib/checks/validator.js

@@ -2,8 +2,8 @@
 
 const {
   forEachDefinition, forEachMemberRecursively, forAllQueries,
-  forEachMember, getNormalizedQuery, hasAnnotationValue,
-  applyTransformations, functionList, mergeTransformers,
+  forEachMember, getNormalizedQuery,
+  applyTransformations, functionList, mergeTransformers, hasPersistenceSkipAnnotation,
 } = require('../model/csnUtils');
 const enrichCsn = require('./enricher');
 
@@ -17,6 +17,7 @@ const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
 const { checkAnnotationExpression } = require('./structuredAnnoExpressions');
 const checkForParams = require('./parameters');
+const checkAndRemoveEnums = require('./enums');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
 const { checkActionOrFunction } = require('./actionsFunctions');
@@ -90,6 +91,7 @@ const forRelationalDBCsnValidators = [
   navigationIntoMany,
   checkPathsInStoredCalcElement,
   featureFlags,
+  checkAndRemoveEnums,
 ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
@@ -239,8 +241,8 @@ function forRelationalDB( csn, that ) {
                    forRelationalDBQueryValidators.concat(commonQueryValidators),
                    {
                      skipArtifact: artifact => artifact.abstract ||
-                                                hasAnnotationValue(artifact, '@cds.persistence.skip') ||
-                                                hasAnnotationValue(artifact, '@cds.persistence.exists') ||
+                                                hasPersistenceSkipAnnotation(artifact) ||
+                                                artifact['@cds.persistence.exists'] ||
                                                 [ 'action', 'function', 'event' ].includes(artifact.kind),
                    });
 }

package/lib/compiler/assert-consistency.js

@@ -261,7 +261,12 @@ function assertConsistency( model, stage ) {
     $contains: { kind: true, test: TODO },
     actions: { kind: true, inherits: 'definitions' },
     enum: { kind: true, inherits: 'definitions' },
-    foreignKeys: { kind: true, inherits: 'definitions', instanceOf: 'ignore' },
+    foreignKeys: {
+      kind: true,
+      inherits: 'definitions',
+      instanceOf: 'ignore',
+      also: [ false ],
+    },
     $keysNavigation: { kind: true, test: TODO },
     $filtered: { kind: true, inherits: 'value' }, // for assoc+filter
     $enclosed: { kind: true, inherits: 'value' }, // for comp+filter
@@ -334,7 +339,7 @@ function assertConsistency( model, stage ) {
       test: isArray( column ),
       instanceOf: XsnArtifact,
       optional: thoseWithKind,
-      enum: [ '*' ],
+      enum: [ '*', '**' ],      // '**' = duplicate wildcard
       requires: [ 'location' ],
       // schema: { kind: { isRequired: () => {} } } // kind not required
     },
@@ -433,9 +438,6 @@ function assertConsistency( model, stage ) {
       optional: [
         'location', '$inferred', 'sort', 'nulls',
         'param', 'scope', // for dynamic parameter '?'
-        // before recompilation for A2J, named types are replaced by the base
-        // definition (TODO v6 remove, we can probably remove elements+items now)
-        'elements', 'items', 'enum',
         'args', 'op', 'func', 'suffix',
         // calculated elements on-write - TODO: outside `value`
         'stored',
@@ -472,7 +474,6 @@ function assertConsistency( model, stage ) {
           '$parens',
           '_artifact',          // _artifact with "localized data"s 'coalesce'
           'sort', 'nulls',      // if used in GROUP BY
-          'enum',               // for CAST in A2J recompilation (TODO v6: remove)
           // `elements` of type is not put into cast, many will be cds.LargeString
           ...typeProperties,    // for CAST
         ],
@@ -496,6 +497,7 @@ function assertConsistency( model, stage ) {
         // expressions as annotation values
         '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type', '$typeArgs',
         'scale', 'srid', 'length', 'precision', 'scope', '$parens',
+        '_block', '_outer',     // for annotation assignments
       ],
       // TODO: restrict path to #simplePath
     },
@@ -877,9 +879,11 @@ function assertConsistency( model, stage ) {
     if (node !== null || noSyntaxErrors()) {
       isObject( node, parent, prop, spec, idx );
 
-      // eslint-disable-next-line no-nested-ternary
-      const choice = (node.path) ? 'ref' : (node.join) ? 'join'
-        : (node.query) ? 'query' : 'none';
+      const choice = (!noSyntaxErrors()) ? 'none'
+        : (node.path) && 'ref' ||
+          (node.join) && 'join' ||
+          (node.query) && 'query' ||
+          'none';
       if (spec[choice])
         assertProp( node, parent, prop, spec[choice], choice );
       else