@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/checks/cdsPersistence.js

@@ -13,7 +13,8 @@
 function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
   if (artifact.kind === 'entity') {
     // filter for 'table', 'udf', 'calcview' === true
-    const TableUdfCv = Object.keys(artifact).filter(p => [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ].includes(p) && artifact[p]);
+    const persistenceAnnos = [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ];
+    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/emptyOrOnlyVirtual.js

@@ -12,9 +12,9 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  * @param {CSN.Path} path Path to the artifact
  */
 function validateEmptyOrOnlyVirtual(artifact, artifactName, prop, path) {
-  if (artifact.kind === 'entity' && !artifact.query && isPersistedOnDatabase(artifact)) {
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact)) {
     if (!artifact.elements || !hasRealElements(artifact.elements))
-      this.error(null, path, "Artifacts containing only virtual or empty elements can't be deployed");
+      this.error('def-missing-element', path, { '#': artifact.query ? 'view' : 'std' });
   }
 }
 

package/lib/checks/enricher.js

@@ -30,6 +30,7 @@ function enrichCsn( csn ) {
     type: simpleRef,
     target: simpleRef,
     includes: simpleRef,
+    columns,
     // Annotations are ignored.
     '@': () => { /* ignore annotations */ },
   };
@@ -40,7 +41,7 @@ function enrichCsn( csn ) {
     cleanupCallbacks = [];
   };
 
-  const { inspectRef, artifactRef } = csnRefs( csn );
+  const { inspectRef, artifactRef, getElement } = csnRefs( csn );
   const csnPath = [];
   if (csn.definitions)
     dictionary( csn, 'definitions', csn.definitions );
@@ -82,6 +83,21 @@ function enrichCsn( csn ) {
     csnPath.pop();
   }
 
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function columns( parent, prop, node ) {
+    // Establish the link relationships
+    parent[prop].forEach((column) => {
+      const element = getElement(column);
+      if (element) {
+        setProp(column, '_element', element);
+        cleanupCallbacks.push(() => delete column._element);
+        setProp(element, '_column', column);
+        cleanupCallbacks.push(() => delete element._column);
+      }
+    });
+    standard(parent, prop, node);
+  }
+
   // eslint-disable-next-line jsdoc/require-jsdoc
   function simpleRef( node, prop ) {
     setProp(node, '$path', [ ...csnPath ]);

package/lib/checks/foreignKeys.js

@@ -18,12 +18,12 @@ function validateForeignKeys(member) {
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
-    for (let i = 0; i < mem.keys.length; i++) {
-      if (mem.keys[i].ref) {
-        if (!mem.keys[i]._art)
+    for (const key of mem.keys) {
+      if (key.ref) {
+        if (!key._art)
           continue;
         // eslint-disable-next-line no-use-before-define
-        checkForItems(mem.keys[i]._art);
+        checkForItems(key._art);
       }
     }
   };

package/lib/checks/invalidTarget.js

@@ -2,6 +2,8 @@
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
+const { ModelError } = require('../base/error');
+
 /**
  * Assert that targets of associations and compositions are entities.
  *
@@ -22,7 +24,7 @@ function invalidTarget(member) {
     if (mem.target) {
       const target = this.csn.definitions[mem.target];
       if (!target)
-        throw new Error(`Expected target ${ mem.target }`);
+        throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
         const isAssoc = this.csnUtils.getFinalBaseType(member.type) !== 'cds.Composition';
         this.error(

package/lib/checks/managedInType.js

@@ -13,11 +13,11 @@
 function checkUsedTypesForAnonymousAspectComposition(member) {
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem, fn) => {
-    for (let i = 0; i < mem.keys.length; i++) {
-      if (mem.keys[i].ref) {
-        if (!mem.keys[i]._art)
+    for (const key of mem.keys) {
+      if (key.ref) {
+        if (!key._art)
           continue;
-        fn(mem.keys[i]._art);
+        fn(key._art);
       }
     }
   };

package/lib/checks/managedWithoutKeys.js

@@ -1,6 +1,8 @@
 'use strict';
 
 
+const { ModelError } = require('../base/error');
+
 /**
  * Trigger a recompilation in case of an association without .keys and without .on
  *
@@ -10,7 +12,7 @@
  */
 function managedWithoutKeys(member, memberName, prop) {
   if (prop === 'elements' && member.target && !member.keys && !member.on) { // trigger recompilation
-    throw new Error('Expected association to have either an on-condition or foreign keys.');
+    throw new ModelError('Expected association to have either an on-condition or foreign keys.');
   }
 }
 

package/lib/checks/queryNoDbArtifacts.js

@@ -124,10 +124,8 @@ function checkQueryForNoDBArtifacts(query) {
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
-        for (let i = 0; i < queryPart.length; i++) {
-          const part = queryPart[i];
+        for (const part of queryPart)
           checkRef(part, prop === 'columns');
-        }
       }
       else if (typeof queryPart === 'object') {
         checkRef(queryPart, prop === 'columns');

package/lib/checks/selectItems.js

@@ -29,7 +29,7 @@ function validateSelectItems(query) {
     }
   });
   // .call() with 'this' to ensure we have access to the options
-  rejectManagedAssociationsAndStructuresForHdbcsNames.call(this, SELECT, SELECT.$path);
+  rejectManagedAssociationsAndStructuresForHdbcdsNames.call(this, SELECT, SELECT.$path);
 }
 
 
@@ -41,10 +41,10 @@ function validateSelectItems(query) {
  * @param {CSN.Artifact} queryArtifact the query artifact which should be checked
  * @param {CSN.Path} artifactPath the path to that artifact
  */
-function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, artifactPath) {
+function rejectManagedAssociationsAndStructuresForHdbcdsNames(queryArtifact, artifactPath) {
   if (this.options.transformation === 'hdbcds' && this.options.sqlMapping === 'hdbcds') {
     forEachGeneric(queryArtifact, 'elements', (selectItem, elemName, prop, elementPath) => {
-      if (this.csnUtils.isManagedAssociationElement(selectItem))
+      if (this.csnUtils.isManagedAssociation(selectItem))
         this.error('query-unexpected-assoc-hdbcds', elementPath);
       if (this.csnUtils.isStructured(selectItem))
         this.error('query-unexpected-structure-hdbcds', elementPath);
@@ -52,4 +52,4 @@ function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, arti
   }
 }
 
-module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcsNames };
+module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcdsNames };

package/lib/checks/sql-snippets.js

@@ -0,0 +1,94 @@
+'use strict';
+
+// Only to be used with validator.js - a correct this value needs to be provided!
+
+/**
+ * Check that @sql.prepend annotation is not used on any elements and @sql.append is not used on elements in views.
+ *
+ * @param {CSN.Element} member
+ * @param {string} memberName
+ * @param {string} prop
+ * @param {CSN.Path} path
+ * @returns {void}
+ */
+function checkSqlAnnotationOnElement(member, memberName, prop, path) {
+  if (member['@sql.replace'])
+    this.error(null, path, { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+  if (member['@sql.prepend'])
+    this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, `Annotation $(ANNO) can't be used on elements` );
+
+  if (member['@sql.append']) {
+    if (this.artifact.query)
+      this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on elements in views` );
+    else if (this.csnUtils.isStructured(member))
+      this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on structured elements` );
+    else
+      checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
+  }
+}
+
+/**
+ * @param {object} carrier element which has the annotation
+ * @param {string} annotation
+ * @param {CSN.Path} path
+ * @param {Function} error
+ * @param {CSN.Options} options
+ */
+function checkValidAnnoValue(carrier, annotation, path, error, options) {
+  if (carrier[annotation] !== undefined && carrier[annotation] !== null) {
+    if (typeof carrier[annotation] !== 'string')
+      error(null, path, { anno: annotation.slice(1), type: typeof carrier[annotation] }, `Annotation $(ANNO) must be a string, found $(TYPE)` );
+    else if (options.transformation === 'sql') // HDI and HDBCDS do their own checks
+      guardAgainstInjection(annotation, carrier[annotation], path, error);
+  }
+}
+
+/**
+ * Check that @sql.prepend is not used on views - only supported for entities (tables)
+ *
+ * @param {CSN.Artifact} artifact
+ * @param {string} artifactName
+ */
+function checkSqlAnnotationOnArtifact(artifact, artifactName) {
+  if (artifact.kind !== 'entity') {
+    if (artifact['@sql.prepend'])
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.prepend', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+    if (artifact['@sql.append'])
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.append', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+  }
+  else if (artifact['@sql.prepend']) {
+    if (artifact.query)
+      this.message('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, `Annotation $(NAME) can't be used on views` );
+    else
+      checkValidAnnoValue(artifact, '@sql.prepend', [ 'definitions', artifactName ], this.error, this.options);
+  }
+
+
+  if (artifact['@sql.replace'])
+    this.error(null, [ 'definitions', artifactName ], { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+
+  checkValidAnnoValue(artifact, '@sql.append', [ 'definitions', artifactName ], this.error, this.options);
+}
+
+// Anything that could terminate the "old" statement and start a new one basically.
+const invalidInSnippet = [ ';', '--', '/*', '*/' ];
+
+/**
+ * Check that the common characters used to terminate the current statement and start a fresh one are not used.
+ *
+ * @param {string} annoName
+ * @param {string} annoValue
+ * @param {CSN.Path} path
+ * @param {Function} error
+ */
+function guardAgainstInjection(annoName, annoValue, path, error) {
+  for (const invalid of invalidInSnippet) {
+    if (annoValue.indexOf(invalid) !== -1) // These should probably not be configurable, right?
+      error(null, path, { name: annoName, prop: invalid }, 'Annotation $(NAME) must not contain $(PROP)');
+  }
+}
+
+module.exports = {
+  checkSqlAnnotationOnArtifact,
+  checkSqlAnnotationOnElement,
+};

package/lib/checks/types.js

@@ -19,7 +19,7 @@ function checkDecimalScale(member, memberName, prop, path) {
      // skip is already filtered in validator, here for completeness
      hasAnnotationValue(this.artifact, '@cds.persistence.skip'))
     return;
-  if (member.scale && [ 'variable', 'floating' ].includes(member.scale))
+  if (member.scale && (member.scale === 'variable' || member.scale === 'floating'))
     this.error(null, path, { name: member.scale }, 'Unexpected scale $(NAME)');
 }
 

package/lib/checks/unknownMagic.js

@@ -32,7 +32,7 @@ function unknownMagicVariable(parent, name, ref) {
     const magicVariable = magicVariables[head];
     if (magicVariable && magicVariable.indexOf(tail) === -1 &&
           getVariableReplacement(ref, this.options) === null)
-      this.error(null, parent.$location, { id: tail, elemref: parent }, 'No configuration for magic variable was provided - path $(ELEMREF), step $(ID)');
+      this.error('ref-missing-replacement', parent.$location, { elemref: parent }, 'Missing replacement for variable $(ELEMREF)');
   }
 }
 

package/lib/checks/validator.js

@@ -35,6 +35,10 @@ const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
 const unknownMagic = require('./unknownMagic');
 const managedWithoutKeys = require('./managedWithoutKeys');
+const {
+  checkSqlAnnotationOnArtifact,
+  checkSqlAnnotationOnElement,
+} = require('./sql-snippets');
 
 const forHanaMemberValidators
 = [
@@ -45,6 +49,8 @@ const forHanaMemberValidators
   checkExplicitlyNullableKeys,
   managedWithoutKeys,
   warnAboutDefaultOnAssociationForHanaCds,
+  // sql.prepend/append
+  checkSqlAnnotationOnElement,
 ];
 
 const forHanaArtifactValidators
@@ -53,6 +59,8 @@ const forHanaArtifactValidators
   validateCdsPersistenceAnnotation,
   // virtual items are not persisted on the db
   checkForEmptyOrOnlyVirtual,
+  // sql.prepend/append
+  checkSqlAnnotationOnArtifact,
 ];
 
 const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];
@@ -121,7 +129,7 @@ function _validate(csn, that,
                    iterateOptions = {}) {
   const { cleanup } = enrich(csn);
 
-  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], true, { drillRef: true });
+  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
 
   forEachDefinition(csn, (artifact, artifactName, prop, path) => {
     artifactValidators.forEach((artifactValidator) => {
@@ -196,12 +204,9 @@ function forHana(csn, that) {
                    ),
                    forHanaQueryValidators.concat(commonQueryValidators),
                    {
-                     skipArtifact: artifact => artifact.abstract || hasAnnotationValue(artifact, '@cds.persistence.skip'),
-                     skip: [
-                       'action',
-                       'function',
-                       'event',
-                     ],
+                     skipArtifact: artifact => artifact.abstract ||
+                                                hasAnnotationValue(artifact, '@cds.persistence.skip') ||
+                                                [ 'action', 'function', 'event' ].includes(artifact.kind),
                    });
 }
 

package/lib/compiler/assert-consistency.js

@@ -249,7 +249,7 @@ function assertConsistency( model, stage ) {
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
           '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
-          '$tableAliases', 'kind', '_$next', '_combined', '$inlines',
+          '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
       },
       none: { optional: () => true }, // parse error
@@ -298,6 +298,7 @@ function assertConsistency( model, stage ) {
     },
     expand: { kind: [ 'element' ], inherits: 'columns' },
     inline: { kind: [ 'element' ], inherits: 'columns' },
+    $noOrigin: { kind: [ 'element' ], test: TODO },
     excludingDict: {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
@@ -325,8 +326,8 @@ function assertConsistency( model, stage ) {
       kind: true,
       requires: [ 'location' ],
       optional: [
-        'path', 'elements', '_outer',
-        'scope', '_artifact', '$inferred', '$expand',
+        'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
+        'scope', '_artifact', '$inferred', '$expand', '$tableAliases', '_$next',
         '_effectiveType',           // by propagation
       ],
     },
@@ -424,9 +425,12 @@ function assertConsistency( model, stage ) {
     val: {
       test: isVal,              // the following for array/struct value
       requires: [ 'location' ],
-      optional: [ 'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate' ],
+      optional: [
+        'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate', 'upTo',
+      ],
       // TODO: restrict path to #simplePath
     },
+    upTo: { test: TODO },
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
@@ -542,7 +546,7 @@ function assertConsistency( model, stage ) {
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit',
+        'limit', '_status',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -638,7 +642,8 @@ function assertConsistency( model, stage ) {
    * and `localized` namespaces.
    */
   function builtin( node, parent, prop, spec, name ) {
-    if (![ 'string', 'boolean' ].includes(typeof node))
+    const type = typeof node;
+    if (type !== 'string' && type !== 'boolean')
       throw new Error(`Property '${ prop }' must be a boolean or string but was '${ typeof node }'${ at( [ node, parent ], prop, name ) }` );
 
     if (parent.kind !== 'namespace')
@@ -792,8 +797,7 @@ function assertConsistency( model, stage ) {
   }
 
   function at( nodes, prop, name ) {
-    // eslint-disable-next-line no-nested-ternary
-    const n = name ? (typeof name === 'number' ? ` for index ${ name }` : ` for "${ name }"`) : '';
+    const n = name && (typeof name === 'number' ? ` for index ${ name }` : ` for "${ name }"`) || '';
     const loc = nodes.find( o => o && typeof o === 'object' && (o.location || o.start) );
     const f = (prop) ? `${ n } in property '${ prop }'` : n;
     const l = locationString( loc && loc.location || loc || model.location );

package/lib/compiler/base.js

@@ -1,6 +1,5 @@
 // Base Definitions for the Core Compiler
 
-
 'use strict';
 
 const dictKinds = {

package/lib/compiler/builtins.js

@@ -1,10 +1,14 @@
 // The builtin artifacts of CDS
 
+// TODO: split this file
+// - in base/: common definitions
+// - in compiler/: XSN-specific
+// - in ?: CSN-specific
+
 'use strict';
 
-const { forEachInDict } = require('../base/dictionaries');
 const { builtinLocation } = require('../base/location');
-const { setProp } = require('./utils');
+const { setLink: setProp } = require('./utils');
 
 const core = {
   String: { parameters: [ 'length' ], category: 'string' },
@@ -57,7 +61,6 @@ const coreHana = {
  * (do not add more - make it part of the SQL renderer to remove parentheses for
  * other funny SQL functions like CURRENT_UTCTIMESTAMP).
  */
-
 const functionsWithoutParens = [
   'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
@@ -82,18 +85,19 @@ const specialFunctions = {
  */
 const magicVariables = {
   $user: {
+    // id and locale are always available
     elements: { id: {}, locale: {} },
     // Allow $user.<any>
     $uncheckedElements: true,
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
     $autoElement: 'id',
-  },                  // CDS-specific, not part of SQL
-  $at: {
+  },
+  $at: { // CDS-specific, not part of SQL
     elements: {
       from: {}, to: {},
     },
   },
-  $now: {},                   // Dito
+  $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
@@ -176,7 +180,8 @@ function isRelationTypeName(typeName) {
 function isInReservedNamespace(absolute) {
   return absolute.startsWith( 'cds.') &&
     !absolute.match(/^cds\.foundation(\.|$)/) &&
-    !absolute.match(/^cds\.outbox(\.|$)/); // Requested by Node runtime
+    !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
+    !absolute.match(/^cds\.xt(\.|$)/); // Requested by Mtx
 }
 
 /**
@@ -199,6 +204,7 @@ function isBuiltinType(type) {
  * @param {XSN.Model} model XSN model without CDS builtins
  */
 function initBuiltins( model ) {
+  const { options } = model;
   setMagicVariables( magicVariables );
   // namespace:"cds" stores the builtins ---
   const cds = createNamespace( 'cds', 'reserved' );
@@ -213,9 +219,6 @@ function initBuiltins( model ) {
   model.$builtins.hana = hana;
   cds._subArtifacts.hana = hana;
   env( coreHana, 'cds.hana.', hana );
-  // namespace:"localized" stores localized convenience views ---
-  const localized = createNamespace( 'localized', true );
-  model.definitions.localized = localized;
   model.$internal = { $frontend: '$internal' };
   return;
 
@@ -266,27 +269,45 @@ function initBuiltins( model ) {
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { id: name, element: name } };
+      const art = { kind: 'builtin', name: { element: name, id: name } };
       artifacts[name] = art;
-      if (magic.elements)
-        art.elements = forEachInDict( magic.elements, (e, n) => magicElement( e, n, art ));
+
       if (magic.$autoElement)
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+
+      createMagicElements( art, magic.elements );
+      if (options.variableReplacements)
+        createMagicElements( art, options.variableReplacements[name] );
       // setProp( art, '_effectiveType', art );
     }
     model.$magicVariables = { kind: '$magicVariables', artifacts };
   }
 
-  function magicElement( spec, name, parent ) {
-    const magic = {
-      kind: 'builtin',
-      name: { id: name, element: `${ parent.name.element }.${ name }` },
-    };
-    setProp( magic, '_parent', parent );
-    // setProp( magic, '_effectiveType', magic );
-    return magic;
+  function createMagicElements( art, elements ) {
+    if (!elements)
+      return;
+
+    const names = Object.keys(elements);
+    if (names.length > 0 && !art.elements)
+      art.elements = Object.create(null);
+
+    for (const n of names) {
+      const magic = {
+        kind: 'builtin',
+        name: { id: n, element: `${ art.name.element }.${ n }` },
+      };
+      // Propagate this property so that it is available for sub-elements.
+      if (art.$uncheckedElements)
+        magic.$uncheckedElements = art.$uncheckedElements;
+      setProp( magic, '_parent', art );
+      // setProp( magic, '_effectiveType', magic );
+      if (elements[n] && typeof elements[n] === 'object')
+        createMagicElements(magic, elements[n]);
+
+      art.elements[n] = magic;
+    }
   }
 }
 

package/lib/compiler/checks.js

@@ -87,6 +87,17 @@ function check( model ) {       // = XSN
                 'Keyword “localized” may only be used in combination with string types');
       }
     }
+    // "key" keyword at localized element in SELECT list.
+    // TODO: This check should be moved to localized.js
+    if (elem.key && elem.key.val && elem._main && elem._main.query) {
+      // original element is localized but not key, as that would have
+      // already resulted in a warning
+      if (elem._origin && elem._origin.localized && elem._origin.localized.val &&
+        ( !elem._origin.key || !elem._origin.key.val)) {
+        warning('localized-key', [ elem.key.location, elem ], { keyword: 'localized' },
+                'Keyword $(KEYWORD) is ignored for primary keys');
+      }
+    }
   }
 
   function checkQuery( query ) {
@@ -334,11 +345,17 @@ function check( model ) {       // = XSN
     // Max cardinalities must be a positive number or '*'
     for (const prop of [ 'sourceMax', 'targetMax' ]) {
       if (elem.cardinality[prop]) {
-        if (!(elem.cardinality[prop].literal === 'number' && elem.cardinality[prop].val > 0 ||
-              elem.cardinality[prop].literal === 'string' && elem.cardinality[prop].val === '*')) {
-          error(null, [ elem.cardinality[prop].location, elem ],
-                { code: elem.cardinality[prop].val },
-                'Illegal value $(CODE) for max cardinality (must be a positive number or "*")');
+        const { literal, val, location } = elem.cardinality[prop];
+        if (!(literal === 'number' && val > 0 ||
+              literal === 'string' && val === '*')) {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+            // eslint-disable-next-line max-len
+            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or ‘*’',
+            // eslint-disable-next-line max-len
+            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or ‘*’',
+            // eslint-disable-next-line max-len
+            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or ‘*’',
+          });
         }
       }
     }
@@ -348,10 +365,16 @@ function check( model ) {       // = XSN
     //       from-csn.json (expected non-negative number)
     for (const prop of [ 'sourceMin', 'targetMin' ]) {
       if (elem.cardinality[prop]) {
-        if (!(elem.cardinality[prop].literal === 'number' && elem.cardinality[prop].val >= 0)) {
-          error(null, [ elem.cardinality[prop].location, elem ],
-                { code: elem.cardinality[prop].val },
-                'Illegal value $(CODE) for min cardinality (must be a non-negative number)');
+        const { literal, val, location } = elem.cardinality[prop];
+        if (!(literal === 'number' && val >= 0)) {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+            // eslint-disable-next-line max-len
+            std: 'Value $(CODE) is invalid for minimum cardinality, expecting a non-negative number',
+            // eslint-disable-next-line max-len
+            targetMin: 'Value $(CODE) is invalid for minimum target cardinality, expecting a non-negative number',
+            // eslint-disable-next-line max-len
+            sourceMin: 'Value $(CODE) is invalid for minimum source cardinality, expecting a non-negative number',
+          });
         }
       }
     }
@@ -436,6 +459,10 @@ function check( model ) {       // = XSN
    * Check whether the argument count of the given path expression matches its artifact.
    * If there is a mismatch, an error is issued.
    *
+   * TODO: remove this function - it also checks for parameter in type
+   * references.  We could have a warning, see also configurable errors
+   * 'args-no-params', 'args-undefined-param'.
+   *
    * @param {object} pathStep The expression to check
    */
   function checkPathForMissingArguments(pathStep) {
@@ -471,8 +498,15 @@ function check( model ) {       // = XSN
 
       const missingArgs = [];
       for (const fAName in formalArgs) {
-        if (!actualArgs[fAName] && !formalArgs[fAName].default)
-          missingArgs.push(fAName);
+        if (!actualArgs[fAName]) {
+          // Note: _effectiveType points to cds.String for `type T : DefaultString`.
+          //       And `default` may appear at any `type` in the hierarchy.
+          let fArg = formalArgs[fAName];
+          while (fArg.type && !fArg.default)
+            fArg = fArg.type._artifact;
+          if (!fArg.default)
+            missingArgs.push(fAName);
+        }
       }
 
       if (missingArgs.length) {
@@ -612,7 +646,7 @@ function check( model ) {       // = XSN
     return checkTreeLikeExpression(xpr, allowAssocTail);
   }
   /**
-   * Check wether the supplied argument is a virtual element
+   * Check whether the supplied argument is a virtual element
    *
    * TO CLARIFY: do we want the "no virtual element" check for virtual elements/columns, too?
    *