@sap/cds-compiler 2.5.0 → 2.10.4

package/lib/checks/nonexpandableStructured.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { otherSideIsExpandableStructure, resolveArtifactType } = require('./utils');
+
+/**
+ * Check the given expression for non-expandable structure usage
+ *
+ * @param {object} parent Object with the expression as a property
+ * @param {string} name Name of the expression property on parent
+ * @param {Array} expression Expression to check - .on .xpr .having and .where
+ */
+function nonexpandableStructuredInExpression(parent, name, expression) {
+  for (let i = 0; i < expression.length; i++) {
+    if (expression[i].ref) {
+      const { ref } = expression[i];
+      // eslint-disable-next-line prefer-const
+      let { _art, $scope } = expression[i];
+      if (!_art)
+        continue;
+      const validStructuredElement = otherSideIsExpandableStructure.call(this, expression, i);
+      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
+          this.error(null, expression[i].$path, { elemref: { ref } },
+                     'Unexpected usage of structured type $(ELEMREF)');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  on: nonexpandableStructuredInExpression,
+  having: nonexpandableStructuredInExpression,
+  where: nonexpandableStructuredInExpression,
+  xpr: nonexpandableStructuredInExpression,
+};

package/lib/checks/onConditions.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { forEachGeneric, isBuiltinType } = require('../model/csnUtils');
+const { forEachGeneric } = require('../model/csnUtils');
+const { otherSideIsExpandableStructure, resolveArtifactType } = require('./utils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -42,48 +43,6 @@ function otherSideIsValidDollarSelf(on, startIndex) {
   return false;
 }
 
-/**
- * Check that the opposite operand to a relational term is something
- * structured that can be used for tuple expansion. This can either be a
- * real 'elements' thing or a managed association/composition with foreign keys.
- *
- * @param {Array} on the on condition which to check
- * @param {number} startIndex the index of the relational term in the on condition array
- * @returns {boolean} indicates whether the other side of a relational term is expandable
- */
-function otherSideIsExpandableStructure(on, startIndex) {
-  if (on[startIndex - 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex - 1]))
-    return isOk(resolveArtifactType.call(this, on[startIndex - 2]._art));
-
-  else if (on[startIndex + 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex + 1]))
-    return isOk(resolveArtifactType.call(this, on[startIndex + 2]._art));
-
-  return false;
-
-  /**
-   * Artifact is structured or a managed association/compoisition
-   *
-   * @param {CSN.Artifact} art Artifact
-   * @returns {boolean} True if expandable
-   */
-  function isOk(art) {
-    return !!(art && (art.elements || (art.target && art.keys)));
-  }
-}
-
-/**
- * Get the real type of an artifact
- *
- * @param {object} art Whatever _art by csnRefs can be - element or artifact
- * @returns {object} final artifact type
- */
-function resolveArtifactType(art) {
-  if (art && art.type && !isBuiltinType(art.type))
-    return this.getFinalBaseType(art);
-
-  return art;
-}
-
 /**
  * Validate an on-condition
  *
@@ -100,6 +59,11 @@ function resolveArtifactType(art) {
  */
 function validateOnCondition(member, memberName, property, path) {
   if (member && member.on) {
+    // complain about nullability constraint on managed composition
+    if (member.targetAspect && {}.hasOwnProperty.call(member, 'notNull')) {
+      this.warning(null, path.concat([ 'on' ]),
+                   'Unexpected nullability constraint defined on managed composition');
+    }
     for (let i = 0; i < member.on.length; i++) {
       if (member.on[i].ref) {
         const { ref } = member.on[i];
@@ -148,8 +112,8 @@ function validateOnCondition(member, memberName, property, path) {
           // 2) Path ends on an association (managed or unmanaged) and the other operand is a '$self'
 
           // If this path ends structured or on an association, perform the check:
-          if ((_art.elements || _art.target) &&
-             !( /* 1) */ (_art.elements || _art.target && _art.keys) && validStructuredElement ||
+          if ((_art.target) &&
+             !( /* 1) */ (_art.target && _art.keys) && validStructuredElement ||
              /* 2) */ (_art.target && validDollarSelf)) &&
              !_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },

package/lib/checks/queryNoDbArtifacts.js

@@ -69,13 +69,31 @@ function checkQueryForNoDBArtifacts(query) {
       const pathStep = obj.ref[i].id ? obj.ref[i].id : obj.ref[i];
       const name = art.target ? art.target : pathStep;
       if (!isPersistedOnDatabase(endArtifact)) {
-        const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
-        this.error( null, obj.$path, {
-          id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
-        }, {
-          std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
-          abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
-        } );
+        const nextElement = obj.ref[i + 1];
+        /**
+         * if we only navigate to foreign keys of the managed association in a view, we do not need to join,
+         * thus we can produce the view even if the target of the association is not persisted
+         *
+         * @param {CSN.Element} assoc association in ref
+         * @param {string} nextStep the ref step following the association
+         * @returns {boolean} true if no join will be generated
+         */
+        const isJoinRelevant = (assoc, nextStep) => {
+          if (!assoc.keys)
+            return true;
+          const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art.type);
+          return !assoc.keys
+            .some(fk => fk.ref[0] === nextStep && !isExposedColumnAssocOrComposition);
+        };
+        if (isJoinRelevant(art, nextElement)) {
+          const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
+          this.error( null, obj.$path, {
+            id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+          }, {
+            std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
+            abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
+          } );
+        }
       }
       // check managed association to have foreign keys array filled
       if (art.keys && leafCount(art) === 0) {

package/lib/checks/selectItems.js

@@ -11,7 +11,7 @@ const { forEachGeneric } = require('../model/csnUtils');
  */
 function validateSelectItems(query) {
   const { SELECT } = query;
-  if (!SELECT || !SELECT.columns)
+  if (!SELECT)
     return;
 
   forEachGeneric(SELECT, 'columns', (selectItem) => {
@@ -24,5 +24,28 @@ function validateSelectItems(query) {
       }
     }
   });
+  // .call() with 'this' to ensure we have access to the options
+  rejectManagedAssociationsAndStructuresForHdbcsNames.call(this, SELECT, SELECT.$path);
 }
-module.exports = validateSelectItems;
+
+
+/**
+ * For the to.hdbcds transformation with naming mode 'hdbcds', structures and managed associations are not flattened/resolved.
+ * It is therefore not possible to publish such elements in a view.
+ * This function iterates over all published elements of a query artifact and asserts that no such elements are published.
+ *
+ * @param {CSN.Artifact} queryArtifact the query artifact which should be checked
+ * @param {CSN.Path} artifactPath the path to that artifact
+ */
+function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, artifactPath) {
+  if (this.options.transformation === 'hdbcds' && this.options.sqlMapping === 'hdbcds') {
+    forEachGeneric(queryArtifact, 'elements', (selectItem, elemName, prop, elementPath) => {
+      if (this.csnUtils.isManagedAssociationElement(selectItem))
+        this.error('query-unexpected-assoc-hdbcds', elementPath);
+      if (this.csnUtils.isStructured(selectItem))
+        this.error('query-unexpected-structure-hdbcds', elementPath);
+    }, artifactPath);
+  }
+}
+
+module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcsNames };

package/lib/checks/types.js

@@ -1,9 +1,28 @@
 'use strict';
 
-const { getUtils, isBuiltinType } = require('../model/csnUtils');
+const { getUtils, isBuiltinType, hasAnnotationValue } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
+/**
+ * Scale must not be 'variable' or 'floating'
+ *
+ * scale property is always propagated
+ *
+ * @param {CSN.Element} member the element to be checked
+ * @param {string} memberName the elements name
+ * @param {string} prop which kind of member are we looking at -> only prop "elements"
+ * @param {CSN.Path} path the path to the member
+ */
+function 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'))
+    return;
+  if (member.scale && [ 'variable', 'floating' ].includes(member.scale))
+    this.error(null, path, { name: member.scale }, 'Unexpected scale $(NAME)');
+}
+
 /**
  * View parameter for hana must be of scalar type
  *
@@ -165,4 +184,9 @@ function hasArtifactTypeInformation(artifact) {
     artifact.type;     // => `type A : [type of] Integer`
 }
 
-module.exports = { checkTypeDefinitionHasType, checkElementTypeDefinitionHasType, checkTypeIsScalar };
+module.exports = {
+  checkTypeDefinitionHasType,
+  checkElementTypeDefinitionHasType,
+  checkTypeIsScalar,
+  checkDecimalScale,
+};

package/lib/checks/unknownMagic.js

@@ -0,0 +1,38 @@
+'use strict';
+
+// We only care about the "wild" ones - $at is validated by the compiler
+const magicVariables = {
+  $user: [
+    'id',     // $user.id
+    'locale', // $user.locale
+  ],
+  $session: [
+    // no valid ways for this
+  ],
+};
+
+/**
+ * Check that the given ref does not use magic variables for which we don't have
+ * a valid way of rendering.
+ *
+ * Valid ways:
+ * - We know what to do -> $user.id on HANA
+ * - The user tells us what to do -> options.magicVars
+ *
+ * @param {object} parent Object with the ref as a property
+ * @param {string} name Name of the ref property on parent
+ * @param {Array} ref to check
+ */
+function unknownMagicVariable(parent, name, ref) {
+  if (parent.$scope && parent.$scope === '$magic') {
+    const [ head, ...rest ] = ref;
+    const tail = rest.join('.');
+    const magicVariable = magicVariables[head];
+    if (magicVariable && magicVariable.indexOf(tail) === -1)
+      this.error(null, parent.$location, { id: tail, elemref: parent }, 'Magic variable is not supported - path $(ELEMREF), step $(ID)');
+  }
+}
+
+module.exports = {
+  ref: unknownMagicVariable,
+};

package/lib/checks/utils.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const { isBuiltinType } = require('../model/csnUtils');
+
+/**
+ * Prepare the ref steps so that they are loggable
+ *
+ * @param {any} refStep part of a ref
+ * @returns {string} Loggable string
+ */
+function logReady(refStep) {
+  return refStep.id || refStep;
+}
+
+/**
+ * Check that the opposite operand to a relational term is something
+ * structured that can be used for tuple expansion. This can either be a
+ * real 'elements' thing or a managed association/composition with foreign keys.
+ *
+ * @param {Array} on the on condition which to check
+ * @param {number} startIndex the index of the relational term in the on condition array
+ * @returns {boolean} indicates whether the other side of a relational term is expandable
+ */
+function otherSideIsExpandableStructure(on, startIndex) {
+  if (on[startIndex - 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex - 1]))
+    return isOk(resolveArtifactType.call(this, on[startIndex - 2]._art));
+
+  else if (on[startIndex + 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex + 1]))
+    return isOk(resolveArtifactType.call(this, on[startIndex + 2]._art));
+
+  return false;
+
+  /**
+   * Artifact is structured or a managed association/compoisition
+   *
+   * @param {CSN.Artifact} art Artifact
+   * @returns {boolean} True if expandable
+   */
+  function isOk(art) {
+    return !!(art && (art.elements || (art.target && art.keys)));
+  }
+}
+
+/**
+ * Get the real type of an artifact
+ *
+ * @param {object} art Whatever _art by csnRefs can be - element or artifact
+ * @returns {object} final artifact type
+ */
+function resolveArtifactType(art) {
+  if (art && art.type && !isBuiltinType(art.type))
+    return this.getFinalBaseType(art);
+
+  return art;
+}
+
+module.exports = {
+  logReady,
+  otherSideIsExpandableStructure,
+  resolveArtifactType,
+};

package/lib/checks/validator.js

@@ -2,13 +2,13 @@
 
 const {
   forEachDefinition, forEachMemberRecursively, forAllQueries,
-  forEachMember, getNormalizedQuery, hasAnnotationValue,
+  forEachMember, getNormalizedQuery, hasAnnotationValue, applyTransformations,
 } = require('../model/csnUtils');
 const enrich = require('./enricher');
 
 // forHana
-const validateSelectItems = require('./selectItems');
-const { rejectParamDefaultsInHanaCds } = require('./defaultValues');
+const { validateSelectItems } = require('./selectItems');
+const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const checkForEmptyOrOnlyVirtual = require('./emptyOrOnlyVirtual');
@@ -23,19 +23,28 @@ const {
 // both
 const { validateOnCondition, validateMixinOnCondition } = require('./onConditions');
 const validateForeignKeys = require('./foreignKeys');
-const { checkTypeDefinitionHasType, checkElementTypeDefinitionHasType, checkTypeIsScalar } = require('./types');
+const {
+  checkTypeDefinitionHasType, checkElementTypeDefinitionHasType,
+  checkTypeIsScalar, checkDecimalScale,
+} = require('./types');
 const { checkPrimaryKey, checkVirtualElement, checkManagedAssoc } = require('./elements');
 const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
+const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
+const unknownMagic = require('./unknownMagic');
+const managedWithoutKeys = require('./managedWithoutKeys');
 
 const forHanaMemberValidators
 = [
   // For HANA CDS specifically, reject any default parameter values, as these are not supported.
   rejectParamDefaultsInHanaCds,
   checkTypeIsScalar,
+  checkDecimalScale,
   checkExplicitlyNullableKeys,
+  managedWithoutKeys,
+  warnAboutDefaultOnAssociationForHanaCds,
 ];
 
 const forHanaArtifactValidators
@@ -46,8 +55,11 @@ const forHanaArtifactValidators
   checkForEmptyOrOnlyVirtual,
 ];
 
-const forHanaQueryValidators
-= [
+const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];
+/**
+ * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
+ */
+const forHanaQueryValidators = [
   // TODO reason why this is forHana exclusive
   validateSelectItems,
   checkQueryForNoDBArtifacts,
@@ -57,6 +69,7 @@ const forOdataMemberValidators
 = [
   // OData allows only simple values, no expressions or functions
   validateDefaultValues,
+  managedWithoutKeys,
 ];
 
 const forOdataArtifactValidators
@@ -75,6 +88,8 @@ const forOdataArtifactValidators
   checkReadOnlyAndInsertOnly,
 ];
 
+const forOdataCsnValidators = [ nonexpandableStructuredInExpression ];
+
 const forOdataQueryValidators = [];
 
 const commonMemberValidators
@@ -91,6 +106,7 @@ const commonQueryValidators = [ validateMixinOnCondition ];
  *
  * @param {CSN.Model} csn CSN to check
  * @param {object} that Will be provided to the validators via "this"
+ * @param {object[]} [csnValidators=[]] Validations on whole CSN using applyTransformations
  * @param {Function[]} [memberValidators=[]] Validations on member-level
  * @param {Function[]} [artifactValidators=[]] Validations on artifact-level
  * @param {Function[]} [queryValidators=[]] Validations on query-level
@@ -98,12 +114,15 @@ const commonQueryValidators = [ validateMixinOnCondition ];
  * @returns {Function} Function taking no parameters, that cleans up the attached helpers
  */
 function _validate(csn, that,
+                   csnValidators = [],
                    memberValidators = [],
                    artifactValidators = [],
                    queryValidators = [],
                    iterateOptions = {}) {
   const { cleanup } = enrich(csn);
 
+  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], true, { drillRef: true });
+
   forEachDefinition(csn, (artifact, artifactName, prop, path) => {
     artifactValidators.forEach((artifactValidator) => {
       artifactValidator.bind(that)(artifact, artifactName, prop, path);
@@ -118,12 +137,44 @@ function _validate(csn, that,
     }
 
     if (queryValidators.length && getNormalizedQuery(artifact).query)
-      forAllQueries(getNormalizedQuery(artifact).query, queryValidators.map(v => v.bind(that)), path.concat([ 'query' ]));
+      forAllQueries(getNormalizedQuery(artifact).query, queryValidators.map(v => v.bind(that)), path.concat([ artifact.projection ? 'projection' : 'query' ]));
   }, iterateOptions);
 
   return cleanup;
 }
 
+/**
+ * Ensure the CSN validators adhere to the applyTransformation format - also, supply correct this value for each subfunction
+ *
+ * @param {object[]} csnValidators Validators
+ * @param {object} that Value for this
+ * @returns {object} Remapped validators.
+ */
+function mergeCsnValidators(csnValidators, that) {
+  const remapped = {};
+  for (const validator of csnValidators) {
+    for (const [ n, fns ] of Object.entries(validator)) {
+      if (!remapped[n])
+        remapped[n] = [];
+
+      if (Array.isArray(fns)) {
+        remapped[n].push((parent, name, prop, path) => fns.forEach(
+          fn => fn.bind(that)(parent, name, prop, path)
+        ));
+      }
+      else {
+        remapped[n].push((parent, name, prop, path) => fns.bind(that)(parent, name, prop, path));
+      }
+    }
+  }
+
+  for (const [ n, fns ] of Object.entries(remapped))
+    remapped[n] = (parent, name, prop, path) => fns.forEach(fn => fn.bind(that)(parent, name, prop, path));
+
+
+  return remapped;
+}
+
 /**
  * @param {CSN.Model} csn CSN to check
  * @param {object} that Will be provided to the validators via "this"
@@ -131,6 +182,7 @@ function _validate(csn, that,
  */
 function forHana(csn, that) {
   return _validate(csn, that,
+                   forHanaCsnValidators,
                    forHanaMemberValidators.concat(commonMemberValidators),
                    forHanaArtifactValidators.concat(commonArtifactValidators).concat(
                      // why is this hana exclusive
@@ -160,6 +212,7 @@ function forHana(csn, that) {
  */
 function forOdata(csn, that) {
   return _validate(csn, that,
+                   forOdataCsnValidators,
                    forOdataMemberValidators.concat(commonMemberValidators),
                    forOdataArtifactValidators.concat(commonArtifactValidators).concat(
                      (artifact, artifactName) => {

package/lib/compiler/assert-consistency.js

@@ -97,6 +97,7 @@ function assertConsistency( model, stage ) {
         '_entities', '$entity',
         '$blocks',
         '$newfeatures',
+        '$messageFunctions',
       ],
     },
     ':parser': {                // top-level from parser
@@ -245,8 +246,8 @@ function assertConsistency( model, stage ) {
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
-          '_projections', '_block', '_parent', '_main', '_effectiveType',
-          '$tableAliases', 'kind', '_$next', '_combined',
+          '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
+          '$tableAliases', 'kind', '_$next', '_combined', '$inlines',
         ],
       },
       none: { optional: () => true }, // parse error
@@ -310,6 +311,7 @@ function assertConsistency( model, stage ) {
     rows: { inherits: 'value' },
     offset: { inherits: 'value' },
     _combined: { test: TODO },
+    $inlines: { test: TODO },
     type: {
       kind: true,
       requires: [ 'location', 'path' ],
@@ -322,7 +324,7 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'path', 'elements', '_outer',
-        'scope', '_artifact', '$inferred',
+        'scope', '_artifact', '$inferred', '$expand',
         '_effectiveType',           // by propagation
       ],
     },
@@ -349,6 +351,7 @@ function assertConsistency( model, stage ) {
     $delimited: { parser: true, test: isBoolean },
     scope: { test: isScope },
     func: { test: TODO },
+    suffix: { test: TODO },
     kind: {
       isRequired: !stageParser && (() => true),
       // required to be set by Core Compiler even with parse errors
@@ -396,6 +399,7 @@ function assertConsistency( model, stage ) {
         optional: [
           'args',
           'func',
+          'suffix',
           'quantifier',
           '$inferred',
           '$parens',
@@ -424,7 +428,7 @@ function assertConsistency( model, stage ) {
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
-      optional: [ 'name', '$duplicate', '$expected' ],
+      optional: [ 'name', '$duplicate', '$expected', 'args', 'suffix' ],
       test: args,
     },
     on: { kind: true, inherits: 'value', test: expression },
@@ -527,11 +531,11 @@ function assertConsistency( model, stage ) {
         // query specific
         'op', 'from', 'elements',
         '_combined',
-        '$tableAliases',
+        '$tableAliases', '$inlines',
       ],
       optional: [
         '_effectiveType', '$parens',
-        '_deps',
+        '_deps', '$expand',
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
@@ -572,13 +576,18 @@ function assertConsistency( model, stage ) {
     $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 },
-    $expand: { kind: true, test: isString },
+
+    // Helper property for the XSN-to-CSN transformation, see function setExpandStatus():
+    // client, universal: render expanded elements?  gensrc: produce annotate statements?
+    $expand: { kind: true, test: isString }, // TODO: rename it to $elementsExpand ?
+
     $autoexpose: { kind: [ 'entity' ], test: isBoolean, also: [ null, 'Composition' ] },
     $a2j: { kind: true, enumerable: true, test: TODO },
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
     $withLocalized: { test: isBoolean },
     $sources: { parser: true, test: isArray( isString ) },
     $expected: { parser: true, test: isString },
+    $messageFunctions: { test: TODO },
   };
   let _noSyntaxErrors = null;
   assertProp( model, null, stageParser ? ':parser' : ':model', null, true );

package/lib/compiler/builtins.js

@@ -83,6 +83,8 @@ const specialFunctions = {
 const magicVariables = {
   $user: {
     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

package/lib/compiler/checks.js

@@ -13,16 +13,16 @@
 
 'use strict';
 
-const { makeMessageFunction } = require('../base/messages');
 // const { hasArtifactTypeInformation } = require('../model/csnUtils')
 const builtins = require('../compiler/builtins');
-const { forEachGeneric, forEachDefinition, forEachMember } = require('../base/model');
+const {
+  forEachGeneric, forEachDefinition, forEachMember,
+} = require('../base/model');
 
 function check( model ) {       // = XSN
-  const { options } = model;
   const {
     error, warning, message,
-  } = makeMessageFunction( model, options, 'compile' );
+  } = model.$messageFunctions;
   forEachDefinition( model, checkArtifact );
   return;
 
@@ -66,6 +66,8 @@ function check( model ) {       // = XSN
   }
 
   function checkName( construct ) {
+    if (model.options.$skipNameCheck)
+      return;
     // TODO: Move a corrected version of this check to definer (but do not rely
     // on it!): The code below misses to consider CSN input.
     if (construct.name.id && construct.name.id.indexOf('.') !== -1) {