@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/checks/annotationsOData.js

@@ -13,42 +13,22 @@
  * @param {CSN.Element} member Member to be checked
  */
 function checkCoreMediaTypeAllowence(member) {
-  const allowedCoreMediaTypes = [
-    'cds.String',
-    'cds.LargeString',
-    'cds.hana.VARCHAR',
-    'cds.hana.CHAR',
-    'cds.Binary',
-    'cds.LargeBinary',
-    'cds.hana.CLOB',
-    'cds.hana.BINARY',
-  ];
-  if (member['@Core.MediaType'] && member.type && !allowedCoreMediaTypes.includes(member.type)) {
+  const allowedCoreMediaTypes = {
+    'cds.String': 1,
+    'cds.LargeString': 1,
+    'cds.hana.VARCHAR': 1,
+    'cds.hana.CHAR': 1,
+    'cds.Binary': 1,
+    'cds.LargeBinary': 1,
+    'cds.hana.CLOB': 1,
+    'cds.hana.BINARY': 1,
+  };
+  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)');
   }
 }
 
-/**
- * Make sure only one element in a definition is annotated with `@Core.MediaType`
- * This is only OData V2 relevant.
- *
- * @param {CSN.Artifact} artifact Definition to be checked
- * @param {string} artifactName The name of the artifact
- */
-function checkForMultipleCoreMediaTypes(artifact, artifactName) {
-  if (!this.csnUtils.getServiceName(artifactName))
-    return;
-  if (this.options.toOdata && this.options.toOdata.version === 'v2' && artifact.elements) {
-    const mediaTypeElementsNames = Object.keys(artifact.elements)
-      .filter(elementName => artifact.elements[elementName]['@Core.MediaType']);
-    if (mediaTypeElementsNames.length > 1) {
-      this.error(null, artifact.$path, { names: mediaTypeElementsNames },
-                 `Multiple elements $(NAMES) annotated with “@Core.MediaType”, OData V2 allows only one`);
-    }
-  }
-}
-
 /**
  * Check if `@Aggregation.default` is assigned together with `@Analytics.Measure`
  *
@@ -88,7 +68,6 @@ function checkReadOnlyAndInsertOnly(artifact, artifactName) {
 
 module.exports = {
   checkCoreMediaTypeAllowence,
-  checkForMultipleCoreMediaTypes,
   checkAnalytics,
   checkAtSapAnnotations,
   checkReadOnlyAndInsertOnly,

package/lib/checks/arrayOfs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const { forEachMemberRecursively } = require('../model/csnUtils');
-
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
 /**
@@ -43,35 +41,4 @@ function validateAssociationsInItems(member) {
   }
 }
 
-/**
- * Check that there are no .items containing .items.
- *
- * @param {CSN.Artifact} art Artifact
- * @param {string} artName Name of the artifact
- */
-function checkChainedArray(art, artName) {
-  if (!this.csnUtils.getServiceName(artName))
-    return;
-  checkIfItemsOfItems.bind(this)(art);
-  forEachMemberRecursively(art, checkIfItemsOfItems.bind(this));
-
-  /**
-   *
-   * @param {object} construct the construct to be checked
-   */
-  function checkIfItemsOfItems(construct) {
-    const constructType = this.csnUtils.effectiveType(construct);
-    if (constructType.items) {
-      if (constructType.items.items) {
-        this.error('chained-array-of', construct.$path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
-        return;
-      }
-
-      const itemsType = this.csnUtils.effectiveType(constructType.items);
-      if (itemsType.items)
-        this.error('chained-array-of', construct.$path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
-    }
-  }
-}
-
-module.exports = { validateAssociationsInItems, checkChainedArray };
+module.exports = { validateAssociationsInItems };

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;
 }

package/lib/checks/validator.js

@@ -14,11 +14,10 @@ const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const checkForEmptyOrOnlyVirtual = require('./emptyOrOnlyVirtual');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
-// const { checkChainedArray } = require('./arrayOfs');
 const { checkActionOrFunction } = require('./actionsFunctions');
 const {
-  checkCoreMediaTypeAllowence, checkForMultipleCoreMediaTypes,
-  checkAnalytics, checkAtSapAnnotations, checkReadOnlyAndInsertOnly,
+  checkCoreMediaTypeAllowence, checkAnalytics,
+  checkAtSapAnnotations, checkReadOnlyAndInsertOnly,
 } = require('./annotationsOData');
 // both
 const { validateOnCondition, validateMixinOnCondition } = require('./onConditions');
@@ -92,7 +91,6 @@ const forOdataArtifactValidators
   //       the renderer does not work because the enricher can't handle certain
   //       OData specifics.
   // checkChainedArray,
-  checkForMultipleCoreMediaTypes,
   checkReadOnlyAndInsertOnly,
 ];
 
@@ -105,8 +103,9 @@ const commonMemberValidators
   validateAssociationsInItems, checkForInvalidTarget,
   checkVirtualElement, checkElementTypeDefinitionHasType ];
 
+// TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [ checkTypeDefinitionHasType, checkPrimaryKey, checkManagedAssoc ];
-
+// TODO: Does it make sense to run the on-condition check as part of a CSN validator?
 const commonQueryValidators = [ validateMixinOnCondition ];
 
 /**

package/lib/compiler/assert-consistency.js

@@ -72,6 +72,7 @@ const { locationString, hasErrors } = require('../base/messages');
 // Properties that can appear where a type can have type arguments.
 const typeProperties = [
   'type', '$typeArgs', 'length', 'precision', 'scale', 'srid',
+  '_effectiveType',
 ];
 
 function assertConsistency( model, stage ) {
@@ -117,8 +118,10 @@ function assertConsistency( model, stage ) {
         '$sources',
       ],
     },
-    location: {                 // location req if at least one property:
-      isRequired: parent => noSyntaxErrors() || Object.keys( parent ).length,
+    location: {
+      // every thing with a $location in CSN must have a XSN location even
+      // with syntax errors (currently even internal artifacts like $using):
+      isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
       requires: [ 'file' ],     // line is optional in top-level location
       optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
@@ -184,12 +187,16 @@ function assertConsistency( model, stage ) {
           // are missing the location property
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
-          optional: [ 'elements', '$autoElement', '$uncheckedElements', '_effectiveType', '_deps' ],
+          optional: [
+            'elements', '$autoElement', '$uncheckedElements',
+            '$requireElementAccess', '_effectiveType', '_deps',
+          ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
             name: { test: isObject, requires: [ 'id', 'element' ] },
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
+            $requireElementAccess: { test: isBoolean },
             // missing location for normal "elements"
             elements: { test: TODO },
           },
@@ -216,8 +223,7 @@ function assertConsistency( model, stage ) {
     usings: {
       test: isArray(),
       requires: [ 'kind', 'location' ],
-      optional: [ 'name', 'extern', 'usings', '$annotations', 'fileDep' ],
-      // TODO: get rid of $annotations: []
+      optional: [ 'name', 'extern', 'usings', 'fileDep' ],
     },
     extern: {
       requires: [ 'location', 'path' ],
@@ -303,7 +309,6 @@ function assertConsistency( model, stage ) {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
       requires: [ 'location', 'name' ],
-      optional: [ '$annotations' ], // TODO: get rid of annos: []
     },
     orderBy: { inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
@@ -448,11 +453,11 @@ function assertConsistency( model, stage ) {
     '@': {
       kind: true,
       inherits: 'value',
-      optional: [ 'name', '_block', '$priority', '$duplicate', '$inferred', '$duplicates' ],
+      optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: TODO }, // TODO: rename to $priority
-    $annotations: { parser: true, kind: true, test: TODO },
+    $priority: { test: TODO },
+    $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
       kind: true,
@@ -467,7 +472,7 @@ function assertConsistency( model, stage ) {
       ],
     },
     absolute: { test: isString },
-    variant: { test: TODO }, // TODO: not set in CDL parser, only in $annotations
+    variant: { test: TODO }, // TODO: not set in CDL parser
     element: { test: TODO }, // TODO: { test: isString },
     action: { test: isString },
     param: { test: isString },
@@ -580,6 +585,7 @@ function assertConsistency( model, stage ) {
     // (it can contain the artifact itself with no/failed autoexposure):
     _descendants: { kind: [ 'entity' ], test: isDictionary( isArray( TODO ) ) },
 
+    $errorReported: { parser: true, test: isBoolean },     // to avoid duplicate messages
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
     $inferred: { parser: true, kind: true, test: isString },

package/lib/compiler/base.js

@@ -45,6 +45,7 @@ const kindProperties = {
     noDep: 'special',
     elements: true, /* only for parse-cdl */
     actions: true,  /* only for parse-cdl */
+    enum: true,     /* only for parse-cdl */
   },
   annotate: {
     isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,

package/lib/compiler/builtins.js

@@ -46,6 +46,16 @@ const coreHana = {
   ST_GEOMETRY: { parameters: [ { name: 'srid', literal: 'number', val: 0 } ], category: 'geo' },
 };
 
+const typeParameters = {
+  expectedLiteralsFor: {
+    length: [ 'number' ],
+    scale: [ 'number', 'string' ],
+    precision: [ 'number' ],
+    srid: [ 'number' ],
+  },
+};
+typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
+
 // const hana = {
 //   BinaryFloat: {},
 //   LocalDate: {},
@@ -66,19 +76,92 @@ const functionsWithoutParens = [
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
 ];
 
-const specialFunctions = {
+const specialFunctions = compileFunctions( {
+  '': [                         // the default
+    {
+      intro: [ 'ALL', 'DISTINCT' ],
+      introMsg: [],             // do not list them in code completion
+    },
+    {},
+  ],
   ROUND: [
     null, null, {               // 3rd argument: rounding mode
-      ROUND_HALF_UP: 'argFull',
-      ROUND_HALF_DOWN: 'argFull',
-      ROUND_HALF_EVEN: 'argFull',
-      ROUND_UP: 'argFull',
-      ROUND_DOWN: 'argFull',
-      ROUND_CEILING: 'argFull',
-      ROUND_FLOOR: 'argFull',
+      expr: [ 'ROUND_HALF_UP', 'ROUND_HALF_DOWN', 'ROUND_HALF_EVEN',
+        'ROUND_UP', 'ROUND_DOWN', 'ROUND_CEILING', 'ROUND_FLOOR' ],
     },
   ],
-};
+  TRIM: [
+    {
+      intro: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      expr: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  EXTRACT: [
+    {
+      expr: [ 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  COUNT: [
+    {
+      expr: [ '*' ],
+      intro: [ 'ALL', 'DISTINCT' ],
+    },
+  ],
+  MIN: 'COUNT',
+  MAX: 'COUNT',
+  SUM: 'COUNT',
+  AVG: 'COUNT',
+  STDDDEV: 'COUNT',
+  VAR: 'COUNT',
+  LOCATE_REGEXPR: [
+    {
+      intro: [ 'START', 'AFTER' ],
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+  OCCURRENCES_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM' ],
+    },
+  ],
+  REPLACE_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'WITH', 'FROM', 'OCCURRENCE' ],
+      expr: [ 'ALL' ],
+    },
+  ],
+  SUBSTRING_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+} );
+
+function compileFunctions( special ) {
+  const compiled = {};
+  for (const [ name, val ] of Object.entries( special ))
+    compiled[name] = (typeof val === 'string' ? special[val] : val).map( compileArg );
+  return compiled;
+}
+
+function compileArg( src ) {
+  if (!src)
+    return src;
+  const tgt = {
+    intro: src.intro || [],
+    expr: src.expr || [],
+    separator: src.separator || [],
+  };
+  for (const generic of [ 'intro', 'expr', 'separator' ]) { // intro before expr!
+    for (const token of src[generic] || [])
+      tgt[token] = generic;
+  }
+  if (tgt.intro)             // same token could be in both 'expr' and 'intro':
+    tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
+  return tgt;
+}
 
 /**
  * Variables that have special meaning in CDL/CSN.
@@ -96,12 +179,15 @@ const magicVariables = {
     elements: {
       from: {}, to: {},
     },
+    // Require that elements are accessed, i.e. no $at, only $at.<element>.
+    $requireElementAccess: true,
   },
   $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
     $uncheckedElements: true,
+    $requireElementAccess: true,
   },
 };
 
@@ -276,6 +362,8 @@ function initBuiltins( model ) {
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+      if (magic.$requireElementAccess)
+        art.$requireElementAccess = magic.$requireElementAccess;
 
       createMagicElements( art, magic.elements );
       if (options.variableReplacements)
@@ -312,6 +400,7 @@ function initBuiltins( model ) {
 }
 
 module.exports = {
+  typeParameters,
   functionsWithoutParens,
   specialFunctions,
   initBuiltins,

package/lib/compiler/checks.js

@@ -24,6 +24,7 @@ function check( model ) {       // = XSN
     error, warning, message,
   } = model.$messageFunctions;
   forEachDefinition( model, checkArtifact );
+  checkSapCommonLocale( model, model.$messageFunctions );
   return;
 
   function checkArtifact( art ) {
@@ -447,80 +448,10 @@ function check( model ) {       // = XSN
         // params are limited to actual values and params
         if (pathStep.args)
           checkExpression(pathStep.args);
-
-        if (!path[0] || !path[0]._navigation) { // TODO: Discuss (see #4108)
-          checkPathForMissingArguments(pathStep);
-        }
       }
     });
   }
 
-  /**
-   * 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) {
-    // _artifact may not be set, e.g. for functions like `convert_currency( amount => 3 )`
-    // _navigation must not be set or we would (for example) check each field of an entity
-    if (!pathStep._artifact || pathStep._navigation)
-      return;
-
-    const isAssociation = !!pathStep._artifact.target;
-    if (isAssociation) {
-      const targetFinalType = pathStep._artifact.target._artifact &&
-            pathStep._artifact.target._artifact._effectiveType;
-      const finalTypeParams = targetFinalType ? targetFinalType.params : null;
-      compareActualNamedArgsWithFormalNamedArgs(pathStep.args, finalTypeParams);
-    }
-    else {
-      // Parameters can only be provided when navigating along associations, so because this path
-      // is for non-associations, checking arguments along a navigation is unnecessary and faulty.
-      compareActualNamedArgsWithFormalNamedArgs(pathStep.args, pathStep._artifact.params);
-    }
-
-    /**
-     * Compare two argument dictionaries for correct argument count.
-     * @param {object}   actualArgs
-     * @param {object}   formalArgs
-     */
-    function compareActualNamedArgsWithFormalNamedArgs(actualArgs, formalArgs) {
-      actualArgs = actualArgs || {};
-      formalArgs = formalArgs || {};
-
-      const aArgsCount = Object.keys(actualArgs).length;
-      const expectedNames = Object.keys(formalArgs);
-
-      const missingArgs = [];
-      for (const fAName in formalArgs) {
-        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) {
-        error(null, [ pathStep.location, pathStep ],
-              { names: missingArgs, expected: expectedNames.length, given: aArgsCount },
-              'Expected $(EXPECTED) arguments but $(GIVEN) given; missing: $(NAMES)');
-      }
-      // Note:
-      // Unknown arguments are already handled by messages
-      // args-expected-named and args-undefined-param
-    }
-  }
-
-
   function checkAssociation(elem) {
     // TODO: yes, a check similar to this could make it into the compiler)
     // when virtual element is part of association
@@ -956,6 +887,27 @@ function check( model ) {       // = XSN
   }
 }
 
+/**
+ * Checks that sap.common.Locale is of type cds.String.  This limitation may
+ * be lifted later on.
+ *
+ * @param {XSN.Model} model
+ * @param {object} messageFunctions
+ */
+function checkSapCommonLocale( model, messageFunctions ) {
+  const localeArt = model.definitions['sap.common.Locale'];
+  if (localeArt) {
+    const type = localeArt._effectiveType;
+    const isCdsString = type && type.name && type.name.absolute === 'cds.String';
+    if (!isCdsString) {
+      const { message } = messageFunctions;
+      message('type-expected-builtin', [ localeArt.name.location, localeArt ],
+              { name: 'sap.common.Locale' },
+              'Expected $(NAME) to be a string type');
+    }
+  }
+}
+
 // For each property named 'path' in 'node' (recursively), call callback(path, node)
 //
 // TODO: remove - this is not a good way to traverse expressions