@sap/cds-compiler 2.7.0 → 2.10.2

package/CHANGELOG.md

@@ -7,6 +7,109 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 2.10.2 - 2021-10-29
+
+### Fixed
+
+- to.sql/hdi/hdbcds: Correctly handle `exists` in conjunction with mixin-associations
+
+## Version 2.10.0 - 2021-10-28
+
+### Added
+
+- Support arbitrary paths after `$user` - similar to `$session`.
+- Support scale `floating` and `variable` for `cds.Decimal` in CDL and CSN. Backend specific handling is descibed in their sections.
+- Allow select item wildcard (`*`) in a `select`/`projection` at any position, not just the first.
+
+- to.edm(x):
+  + In Odata V4 generate transitive navigation property binding paths along containment hierarchies and terminate on the
+    first non-containment association. The association target is either an explicit Edm.EntitySet in the same EntityContainer
+    or in a referred EntityContainer (cross service references) or an implicit EntitySet identified by the containment path
+    originating from an explicit EntitySet. This enhancement has an observable effect only in structured format with containment
+    turned on.
+  + Support for scales `variable` and `floating`:
+    + V4: `variable` and `floating` are rendered as `Scale="variable"`. Since V4 does not support `floating`, it is aproximated as `variable`.
+    + V2: `variable` and `floating` are announced via property annotation `sap:variable-scale="true"`
+  
+- to.sql/hdi/hdbcds:
+  + Reject scale `floating` and `variable`.
+  + Reject arbitrary `$user` or `$session` paths that cannot be translated to valid SQL.
+  + Following a valid `exists`, further `exists` can be used inside of the filter-expression: `exists assoc[exists another[1=1]]`
+  + `exists` can now be followed by more than one association step.
+  `exists assoc.anotherassoc.moreassoc` is semantically equivalent to `exists assoc[exists anotherassoc[exists moreassoc]]`
+
+### Removed
+
+### Changed
+
+- to.odata: Inform when overwriting draft action annotations like @Common.DraftRoot.ActivationAction.
+
+### Fixed
+
+## Version 2.9.0 - 2021-10-15
+
+### Changed
+
+- to.edm(x): Raise `odata-spec-violation-type` to a downgradable error.
+
+### Fixed
+
+- to.edm(x):
+  + Fix a bug in annotation propagation to foreign keys.
+  + Don't render annotations for not rendered stream element in V2.
+- to.hdi:
+  + for naming mode "hdbcds" and "quoted" parameter definitions are not quoted anymore.
+- to.hdi/sql/hdbcds:
+  + Correctly handle explicit and implicit alias during flattening.
+  + Raise an error for `@odata.draft.enabled` artifacts with elements without types - instead of crashing with internal assertions.
+
+## Version 2.8.0 - 2021-10-07
+
+### Added
+
+- Allow defining unmanaged associations in anonymous aspects of compositions.
+- Enable extensions of anonymous aspects for managed compositions of aspects.
+- When the option `addTextsLanguageAssoc` is set to true and
+  the model contains an entity `sap.common.Languages` with an element `code`,
+  all generated texts entities additionally contain an element `language`
+  which is an association to `sap.common.Languages` using element `local`.
+- for.odata:
+  + In `--odata-format=flat`, structured view parameters are flattened like elements.
+- to.hdbcds
+  + Use "smart quotes" for naming mode "plain" - automatically quote identifier which are reserved keywords or non-regular.
+
+### Changed
+
+- for.odata:
+  + In `--data-format=structured`, anonymous sub elements of primary keys and parameters are set to `notNull:true`,
+    an existing `notNull` attribute is _not_ overwritten. Referred named types are _not_ modified.
+- to.edm(x):
+  + Improve specification violation checks of (nested) keys:
+    + All (sub-)elements must be `Nullable: false` (error).
+    + Must represent a single value (error).
+    + In V4 must be a specification compliant Edm.PrimitiveType (warning).
+- to.hdi/hdbcds/sql: $user.\<xy\> now has \<xy\> added as alias - "$user.\<xy\> as \<xy\>"
+
+### Fixed
+
+- Properly generate auto-exposed entities for associations in parameters.
+- Correctly apply extensions to anonymous array item types.
+- Correctly apply/render annotations to anonymous action return types.
+- With CSN flavor `plain` (`gensrc`), correctly render annotations on elements
+  of referred structure types as `annotate` statements in the CSN's `extensions` property.
+- to.cdl:
+  + Correctly render extensions on array item types
+  + Correctly render annotations on action return types
+- to/for: Correctly handle CSN input where the prototype of objects is not the "default"
+- to.hdi:
+  + for naming mode "hdbcds" and "quoted" parameter definitions are now quoted.
+  + for naming mode "plain", smart quotation is applied to parameter definitions if they are reserved words.
+- to.hdi/hdbcds/sql:
+  + Ensure that cdl-style casts to localized types do not lose their localized property
+  + Fix a small memory leak during rendering of SQL/HDBCDS.
+- to.edm(x): Remove ambiguous `Partner` attribute from `NavigationProperty`. A forward association referred
+  to by multiple backlinks (`$self` comparisons) is no longer partner to an arbitrary backlink.
+
 ## Version 2.7.0 - 2021-09-22
 
 ### Added

package/lib/api/main.js

@@ -494,19 +494,17 @@ function edmall(csn, options = {}) {
   if (internalOptions.version === 'v2')
     error(null, null, 'OData JSON output is not available for OData V2');
 
-  let servicesAll;
-
   const result = {};
+  let oDataCsn = csn;
 
-  if (isPreTransformed(csn, 'odata')) {
+  if (isPreTransformed(csn, 'odata'))
     checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-    servicesAll = backends.preparedCsnToEdmAll(csn, internalOptions);
-  }
-  else {
-    const oDataCsn = odataInternal(csn, internalOptions);
-    servicesAll = backends.preparedCsnToEdmAll(oDataCsn, internalOptions);
-  }
-  const services = servicesAll.edmj;
+
+  else
+    oDataCsn = odataInternal(csn, internalOptions);
+
+  const servicesJson = backends.preparedCsnToEdmAll(oDataCsn, internalOptions);
+  const services = servicesJson.edmj;
   for (const serviceName in services) {
     const lEdm = services[serviceName];
     // FIXME: Why only metadata_json - isn't this rather a 'combined_json' ? If so, rename it!

package/lib/api/options.js

@@ -10,11 +10,13 @@ const publicOptionsNewAPI = [
   // GENERAL
   'beta',
   'deprecated',
+  'addTextsLanguageAssoc',
   'localizedLanguageFallback',  // why can't I define the option type here?
   'severities',
   'messages',
   'withLocations',
   'defaultStringLength',
+  'csnFlavor',
   // DB
   'sqlDialect',
   'sqlMapping',
@@ -68,10 +70,11 @@ const overallOptions = publicOptionsNewAPI.concat(privateOptions);
  * @param {FlatOptions} [hardRequire={}] Hard requirements to enforce
  * @param {object} [customValidators] Custom validations to run instead of defaults
  * @param {string[]} [combinationValidators] Option combinations to validate
+ * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions
  * @returns {TranslatedOptions} General cds options
  */
 function translateOptions(input = {}, defaults = {}, hardRequire = {},
-                          customValidators = {}, combinationValidators = []) {
+                          customValidators = {}, combinationValidators = [], moduleName = '') {
   const options = Object.assign({}, defaults);
   const inputOptionNames = Object.keys(input);
   for (const name of overallOptions) {
@@ -90,6 +93,7 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
   // Validate the filtered input options
   // only "new-style" options are here
   validate(options,
+           moduleName,
            // TODO: is there a better place to specify the type of option values?
            Object.assign( {
              localizedLanguageFallback: generateStringValidator([ 'none', 'coalesce' ]),
@@ -141,11 +145,11 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
 
 module.exports = {
   to: {
-    cdl: options => translateOptions(options),
+    cdl: options => translateOptions(options, undefined, undefined, undefined, undefined, 'to.cdl'),
     sql: (options) => {
       const hardOptions = { src: 'sql' };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'plain' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ]);
+      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ], 'to.sql');
 
       const result = Object.assign({}, processed);
       result.toSql = Object.assign({}, processed);
@@ -155,7 +159,7 @@ module.exports = {
     hdi: (options) => {
       const hardOptions = { src: 'hdi' };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) });
+      const processed = translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
 
       const result = Object.assign({}, processed);
       result.toSql = Object.assign({}, processed);
@@ -164,7 +168,7 @@ module.exports = {
     },
     hdbcds: (options) => {
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions, {}, { sqlDialect: generateStringValidator([ 'hana' ]) });
+      const processed = translateOptions(options, defaultOptions, {}, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdbcds');
 
       const result = Object.assign({}, processed);
       result.forHana = Object.assign({}, processed);
@@ -174,7 +178,7 @@ module.exports = {
     edm: (options) => {
       const hardOptions = { json: true, combined: true };
       const defaultOptions = { odataVersion: 'v4', odataFormat: 'flat' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, { odataVersion: generateStringValidator([ 'v4' ]) }, [ 'valid-structured' ]);
+      const processed = translateOptions(options, defaultOptions, hardOptions, { odataVersion: generateStringValidator([ 'v4' ]) }, [ 'valid-structured' ], 'to.edm');
 
       const result = Object.assign({}, processed);
       result.toOdata = Object.assign({}, processed);
@@ -186,7 +190,7 @@ module.exports = {
       const defaultOptions = {
         odataVersion: 'v4', odataFormat: 'flat',
       };
-      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ]);
+      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.edmx');
 
       const result = Object.assign({}, processed);
       result.toOdata = Object.assign({}, processed);
@@ -198,7 +202,7 @@ module.exports = {
 
     odata: (options) => {
       const defaultOptions = { odataVersion: 'v4', odataFormat: 'flat' };
-      const processed = translateOptions(options, defaultOptions, undefined, undefined, [ 'valid-structured' ]);
+      const processed = translateOptions(options, defaultOptions, undefined, undefined, [ 'valid-structured' ], 'for.odata');
 
       const result = Object.assign({}, processed);
       result.toOdata = Object.assign({}, processed);
@@ -208,7 +212,7 @@ module.exports = {
     },
     hana: (options) => {
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions);
+      const processed = translateOptions(options, defaultOptions, undefined, undefined, undefined, 'for.hana');
 
       const result = Object.assign({}, processed);
       result.forHana = Object.assign({}, processed);

package/lib/api/validate.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { makeMessageFunction, handleMessages } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 
 /* eslint-disable arrow-body-style */
 const booleanValidator = {
@@ -94,6 +94,11 @@ const validators = {
     expected: () => 'Integer literal',
     found: val => `type ${ typeof val }`,
   },
+  csnFlavor: {
+    validate: val => typeof val === 'string',
+    expected: () => 'type string',
+    found: val => `type ${ typeof val }`,
+  },
   dictionaryPrototype: {
     validate: () => true,
   },
@@ -122,16 +127,17 @@ const allCombinationValidators = {
  * Use a custom validator or "default" custom validator, fallback to Boolean validator.
  *
  * @param {object} options Flat options object to validate
+ * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions
  * @param {object} [customValidators] Map of custom validators to use
  * @param {string[]} [combinationValidators] Validate option combinations
  * @returns {void}
  * @throws {CompilationError} Throws in case of invalid option usage
  */
-function validate(options, customValidators = {}, combinationValidators = []) {
+function validate(options, moduleName, customValidators = {}, combinationValidators = []) {
   // TODO: issuing messages in this function looks very strange...
   {
     const messageCollector = { messages: [] };
-    const { error, throwWithError } = makeMessageFunction(null, messageCollector);
+    const { error, throwWithError } = makeMessageFunction(null, messageCollector, moduleName);
 
     for (const optionName of Object.keys(options)) {
       const optionValue = options[optionName];
@@ -143,7 +149,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
     throwWithError();
   }
 
-  const message = makeMessageFunction(null, options);
+  const message = makeMessageFunction(null, options, moduleName);
 
   for (const combinationValidatorName of combinationValidators.concat([ 'beta-no-test' ])) {
     const combinationValidator = allCombinationValidators[combinationValidatorName];
@@ -151,10 +157,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
       message[combinationValidator.severity]('invalid-option-combination', null, {}, combinationValidator.getMessage(options));
   }
 
-  // TODO: Replace with message.throwWithError():
-  // But be aware that it only throws with non-configurable errors and that this
-  // will lead to issues in test3. See #6037
-  handleMessages(undefined, options);
+  message.throwWithError();
 }
 /* eslint-enable jsdoc/no-undefined-types */
 

package/lib/base/keywords.js

@@ -194,7 +194,7 @@ module.exports = {
     'OTHERS',
     'TIES',
   ],
-  // HANA keywords, used to warn in 'toSql' renderer with dialect 'hana' or in 'toHana' renderer (both with 'plain' names only)
+  // HANA keywords, used for smart quoting in to-hdi.plain
   // Taken from https://help.sap.com/viewer/7c78579ce9b14a669c1f3295b0d8ca16/Cloud/en-US/28bcd6af3eb6437892719f7c27a8a285.html
   // Better use keywords in ptime/query/parser/syntax/qp_keyword.cc minus those
   // in rule unreserved_keyword_column (=…_common - "CONSTRAINT") in
@@ -673,5 +673,35 @@ module.exports = {
     'WITHIN',
     'XMLTABLE',
     'YEAR'
-  ]  
+  ],
+  // HANA CDS keywords, used for smart quoting in to-hdbcds.plain
+  hdbcds: [
+    'ALL',                'ALTER',             'AS',
+    'BEFORE',             'BEGIN',             'BOTH',
+    'CASE',               'CHAR',              'CONDITION',
+    'CONNECT',            'CROSS',             'CUBE',
+    'CURRENT_CONNECTION', 'CURRENT_DATE',      'CURRENT_SCHEMA',
+    'CURRENT_TIME',       'CURRENT_TIMESTAMP', 'CURRENT_USER',
+    'CURRENT_UTCDATE',    'CURRENT_UTCTIME',   'CURRENT_UTCTIMESTAMP',
+    'CURRVAL',            'CURSOR',            'DECLARE',
+    'DISTINCT',           'ELSE',              'ELSEIF',
+    'ELSIF',              'END',               'EXCEPT',
+    'EXCEPTION',          'EXEC',              'FOR',
+    'FROM',               'FULL',              'GROUP',
+    'HAVING',             'IF',                'IN',
+    'INNER',              'INOUT',             'INTERSECT',
+    'INTO',               'IS',                'JOIN',
+    'LEADING',            'LEFT',              'LIMIT',
+    'LOOP',               'MINUS',             'NATURAL',
+    'NEXTVAL',            'NULL',              'ON',
+    'ORDER',              'OUT',               'OUTER',
+    'PRIOR',              'RETURN',            'RETURNS',
+    'REVERSE',            'RIGHT',             'ROLLUP',
+    'ROWID',              'SELECT',            'SET',
+    'SQL',                'START',             'SYSDATE',
+    'SYSTIME',            'SYSTIMESTAMP',      'SYSUUID',
+    'TOP',                'TRAILING',          'UNION',
+    'USING',              'VALUES',            'WHEN',
+    'WHERE',              'WHILE',             'WITH'
+  ]
 }

package/lib/base/message-registry.js

@@ -132,6 +132,10 @@ const centralMessages = {
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
   'odata-spec-violation-array':  { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
+  'odata-spec-violation-type': { severity: 'Error', configurableFor: [ 'to.edmx' ] },
+  'odata-spec-violation-key-array':  { severity: 'Error' }, // more than 30 chars
+  'odata-spec-violation-key-null': { severity: 'Error' }, // more than 30 chars
+  'odata-spec-violation-key-type': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-namespace-name': { severity: 'Warning' }, // more than 30 chars
 };
@@ -246,6 +250,18 @@ const centralMessageTexts = {
   'odata-spec-violation-assoc': 'Unexpected association in structured type for $(API)',
   'odata-spec-violation-constraints': 'Partial referential constraints produced for $(API)',
   // version independent messages
+  'odata-spec-violation-key-array': {
+    std: 'Unexpected array type for element $(NAME)',
+    scalar: 'Unexpected array type'
+  },
+  'odata-spec-violation-key-null': {
+    std: 'Expected key element $(NAME) to be not nullable', // structured
+    scalar: 'Expected key element to be not nullable' // flat
+  },
+  'odata-spec-violation-key-type': {
+    std: 'Unexpected $(TYPE) mapped to $(ID) as type for key element $(NAME)', // structured
+    scalar: 'Unexpected $(TYPE) mapped to $(ID) as type for key element' // flat
+  },
   'odata-spec-violation-type': 'Expected element to have a type',
   'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(KIND)',
   'odata-spec-violation-namespace': 'Expected service name not to be one of the reserved names $(NAMES)',

package/lib/base/messages.js

@@ -649,6 +649,8 @@ const paramsTransform = {
   // more complex convenience:
   names: transformManyWith( quoted ),
   number: n => n,
+  line: l => l,
+  col: c => c,
   literal: l => l,
   art: transformArg,
   service: transformArg,

package/lib/base/model.js

@@ -28,6 +28,7 @@ const availableBetaFlags = {
   ignoreAssocPublishingInUnion: true,
   nestedProjections: true,
   enableUniversalCsn: true,
+  windowFunctions: true,
   // disabled by --beta-mode
   nestedServices: false,
 };

package/lib/checks/onConditions.js

@@ -59,6 +59,11 @@ function otherSideIsValidDollarSelf(on, startIndex) {
  */
 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];

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/validator.js

@@ -23,13 +23,17 @@ 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
@@ -37,6 +41,7 @@ const forHanaMemberValidators
   // For HANA CDS specifically, reject any default parameter values, as these are not supported.
   rejectParamDefaultsInHanaCds,
   checkTypeIsScalar,
+  checkDecimalScale,
   checkExplicitlyNullableKeys,
   managedWithoutKeys,
   warnAboutDefaultOnAssociationForHanaCds,
@@ -50,7 +55,7 @@ const forHanaArtifactValidators
   checkForEmptyOrOnlyVirtual,
 ];
 
-const forHanaCsnValidators = [ nonexpandableStructuredInExpression ];
+const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */

package/lib/compiler/assert-consistency.js

@@ -246,7 +246,7 @@ function assertConsistency( model, stage ) {
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
-          '_projections', '_block', '_parent', '_main', '_effectiveType',
+          '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines',
         ],
       },
@@ -324,7 +324,7 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'path', 'elements', '_outer',
-        'scope', '_artifact', '$inferred',
+        'scope', '_artifact', '$inferred', '$expand',
         '_effectiveType',           // by propagation
       ],
     },
@@ -351,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
@@ -398,6 +399,7 @@ function assertConsistency( model, stage ) {
         optional: [
           'args',
           'func',
+          'suffix',
           'quantifier',
           '$inferred',
           '$parens',
@@ -426,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 },
@@ -533,7 +535,7 @@ function assertConsistency( model, stage ) {
       ],
       optional: [
         '_effectiveType', '$parens',
-        '_deps',
+        '_deps', '$expand',
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
@@ -574,7 +576,11 @@ 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

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

@@ -15,7 +15,9 @@
 
 // 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 {