@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/checks/invalidTarget.js

@@ -3,6 +3,7 @@
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 const { ModelError } = require('../base/error');
+const { setProp } = require('../base/model');
 
 /**
  * Assert that targets of associations and compositions are entities.
@@ -38,18 +39,16 @@ function invalidTarget(member) {
         );
       }
     }
-    else if (mem.type && mem.type.ref) {
-      // type of
-      checkForInvalidTarget(this.artifactRef(mem.type));
+    // elements have precedence over type
+    else if (mem.elements) {
+      handleStructured(mem);
     }
-    else {
-      // type T
-      const type = this.csn.definitions[mem.type];
-      if (type) {
-        if (type.elements)
-          handleStructured(type);
-        else
-          checkForInvalidTarget(type);
+    else if (mem.type) {
+      const type = mem.type.ref ? this.artifactRef(mem.type) : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        checkForInvalidTarget(type);
+        delete type.$visited;
       }
     }
   };

package/lib/checks/managedInType.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { setProp } = require('../base/model');
+
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
@@ -35,18 +37,20 @@ function checkUsedTypesForAnonymousAspectComposition(member) {
     }
     else if (mem.type && (mem.type === 'cds.Composition') && !mem.on) {
       if (!mem.target && mem.targetAspect && typeof mem.targetAspect !== 'string')
-        this.error(null, member.$path, 'Types with anonymous aspect compositions can\'t be used');
+        this.error(null, member.$path, {}, 'Types with anonymous aspect compositions can\'t be used');
     }
     else if (mem.elements) {
       handleStructured(mem, assertNoAnonymousAspectComposition);
     }
-    else if (mem.type && mem.type.ref) { // type of
-      const type = this.artifactRef(mem.type);
-      assertNoAnonymousAspectComposition(type);
-    }
-    else if (mem.type && this.csn.definitions[mem.type]) { // type T
-      const type = this.csn.definitions[mem.type];
-      assertNoAnonymousAspectComposition(type);
+    else if (mem.type) {
+      const type = mem.type.ref
+        ? this.artifactRef(mem.type)
+        : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        assertNoAnonymousAspectComposition(type);
+        delete type.$visited;
+      }
     }
   };
 
@@ -62,13 +66,15 @@ function checkUsedTypesForAnonymousAspectComposition(member) {
     else if (mem.elements) {
       handleStructured(mem, checkTypeUsages);
     }
-    else if (mem.type && mem.type.ref) { // type of
-      const type = this.artifactRef(mem.type);
-      assertNoAnonymousAspectComposition(type);
-    }
-    else if (mem.type && this.csn.definitions[mem.type]) { // type T where T might contain items
-      const type = this.csn.definitions[mem.type];
-      assertNoAnonymousAspectComposition(type);
+    else if (mem.type) { // type of
+      const type = mem.type.ref
+        ? this.artifactRef(mem.type)
+        : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        assertNoAnonymousAspectComposition(type);
+        delete type.$visited;
+      }
     }
   };
 

package/lib/checks/nullableKeys.js

@@ -7,7 +7,7 @@
  */
 function checkExplicitlyNullableKeys(element) {
   if (element.key && element.notNull === false)
-    this.error(null, element.$path, 'Expecting primary key element to be not nullable');
+    this.error(null, element.$path, {}, 'Expecting primary key element to be not nullable');
 }
 
 module.exports = checkExplicitlyNullableKeys;

package/lib/checks/onConditions.js

@@ -61,7 +61,7 @@ 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' ]),
+      this.warning(null, path.concat([ 'on' ]), {},
                    'Unexpected nullability constraint defined on managed composition');
     }
     for (let i = 0; i < member.on.length; i++) {
@@ -83,24 +83,24 @@ function validateOnCondition(member, memberName, property, path) {
           if (_links[j].art.target && !((_links[j].art === member) || ref[j] === '$self' || ref[j] === '$projection' || (validDollarSelf && j === _links.length - 1))) {
             if (_links[j].art.on) {
               // It's an unmanaged association - traversal is always forbidden
-              this.error(null, csnPath, { id, elemref }, 'ON-Conditions can\'t follow unmanaged associations, step $(ID) of path $(ELEMREF)');
+              this.error(null, csnPath, { id, elemref }, 'ON-conditions can\'t follow unmanaged associations, step $(ID) of path $(ELEMREF)');
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
               const nextRef = ref[j + 1].id || ref[j + 1];
               if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
-                this.error(null, csnPath, { id, elemref }, 'ON-Conditions can only follow managed associations to the foreign keys of the managed association, step $(ID) of path $(ELEMREF)');
+                this.error(null, csnPath, { id, elemref }, 'ON-conditions can only follow managed associations to the foreign keys of the managed association, step $(ID) of path $(ELEMREF)');
             }
           }
 
           if (_links[j].art.virtual)
-            this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-Conditions, step $(ID) of path $(ELEMREF)');
+            this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-conditions, step $(ID) of path $(ELEMREF)');
 
           if (ref[j].where)
-            this.error(null, csnPath, { id, elemref }, 'ON-Conditions must not contain filters, step $(ID) of path $(ELEMREF)');
+            this.error(null, csnPath, { id, elemref }, 'ON-conditions must not contain filters, step $(ID) of path $(ELEMREF)');
 
           if (ref[j].args)
-            this.error(null, csnPath, { id, elemref }, 'ON-Conditions must not contain parameters, step $(ID) of path $(ELEMREF)');
+            this.error(null, csnPath, { id, elemref }, 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)');
         }
         if (_art && $scope !== '$self') {
           _art = resolveArtifactType.call(this, _art);
@@ -117,15 +117,15 @@ function validateOnCondition(member, memberName, property, path) {
              /* 2) */ (_art.target && validDollarSelf)) &&
              !_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },
-                       'The last path of an on-condition must be a scalar value, path $(ELEMREF)');
+                       'The last path of an ON-condition must be a scalar value, path $(ELEMREF)');
           }
           else if (_art.items && !_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },
-                       'ON-Conditions can\'t use array-like elements, path $(ELEMREF)');
+                       'ON-conditions can\'t use array-like elements, path $(ELEMREF)');
           }
           else if (_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },
-                       'Virtual elements can\'t be used in ON-Conditions, path $(ELEMREF)');
+                       'Virtual elements can\'t be used in ON-conditions, path $(ELEMREF)');
           }
         }
       }

package/lib/checks/parameters.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { isPersistedOnDatabase } = require('../model/csnUtils.js');
+
+/**
+ * Check that we don't have parameterized views - as we don't know yet how to represent them on postgres
+ *
+ * @param {object} parent Object with .params
+ * @param {string} name Name of the params property on parent
+ * @param {object} params params
+ * @param {CSN.Path} path
+ */
+function checkForParams(parent, name, params, path) {
+  const artifact = this.csn.definitions[path[1]];
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && !(parent.kind !== 'entity')) {
+    this.error('ref-unexpected-params', [ ...path, 'params' ], { value: this.options.sqlDialect },
+               'Parameterized views can\'t be used with sqlDialect $(VALUE)');
+  }
+}
+
+module.exports = {
+  params: checkForParams,
+};

package/lib/checks/queryNoDbArtifacts.js

@@ -101,7 +101,7 @@ function checkQueryForNoDBArtifacts(query) {
         this.error(null,
                    obj.$path,
                    { id: pathStep, elemref: obj },
-                   `Path step $(ID) of $(ELEMREF) has no foreign keys`);
+                   'Path step $(ID) of $(ELEMREF) has no foreign keys');
       }
 
       if (art.on) {

package/lib/checks/selectItems.js

@@ -106,7 +106,7 @@ function validateSelectItems(query) {
   if (this.options.transformation === 'hdbcds') {
     transformers.xpr = (parent) => {
       if (parent.func) {
-        this.error(null, parent.$path,
+        this.error(null, parent.$path, {},
                    'Window functions are not supported by SAP HANA CDS');
       }
     };

package/lib/checks/sql-snippets.js

@@ -13,15 +13,15 @@
  */
 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`);
+    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` );
+    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` );
+      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` );
+      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);
   }
@@ -37,7 +37,7 @@ function checkSqlAnnotationOnElement(member, memberName, prop, path) {
 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)` );
+      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);
   }
@@ -52,20 +52,22 @@ function checkValidAnnoValue(carrier, annotation, path, error, options) {
 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)` );
+      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)` );
+      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` );
+      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`);
+  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);
 }

package/lib/checks/types.js

@@ -33,7 +33,7 @@ function checkDecimalScale(member, memberName, prop, path) {
  */
 function checkTypeIsScalar(member, memberName, prop, path) {
   if ( prop === 'params' && this.csnUtils.isStructured(member))
-    this.error(null, path, 'View parameter type must be scalar');
+    this.error(null, path, {}, 'View parameter type must be scalar');
 }
 
 /**
@@ -69,7 +69,7 @@ function checkElementTypeDefinitionHasType(member, memberName, prop, path) {
     }
     else if (member._type) {
       if ( this.isAspect(member._type) || member._type.kind === 'type' && member._type.$syntax === 'aspect')
-        this.error('ref-sloppy-type', path, 'A type or an element is expected here');
+        this.error('ref-sloppy-type', path, {}, 'A type or an element is expected here');
     }
     return;
   }

package/lib/checks/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../model/csnUtils');
-
+const { RelationalOperators } = require('../transform/transformUtilsNew');
 /**
  * Prepare the ref steps so that they are loggable
  *
@@ -17,17 +17,27 @@ function logReady(refStep) {
  * structured that can be used for tuple expansion. This can either be a
  * real 'elements' thing or a managed association/composition with foreign keys.
  *
+ * The RHS may be 'null' or any value
+ *
  * @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));
-
+  if (on[startIndex - 1] && RelationalOperators.includes(on[startIndex - 1])) {
+    const lhs = on[startIndex - 2];
+    // if ever lhs is allowed to be a value uncomment this
+    return /* lhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, lhs?._art));
+  }
+  else if (on[startIndex + 1] && RelationalOperators.includes(on[startIndex + 1])) {
+    const op = on[startIndex + 1];
+    const rhs = on[startIndex + 2];
+    if (op === 'is')
+      // check for unary operator 'is [not] null' as token stream
+      return rhs === 'null' || (rhs === 'not' && on[startIndex + 3] === 'null');
+    // if ever rhs is allowed to be a value uncomment this
+    return /* rhs?.val !== undefined || */ isOk(resolveArtifactType.call(this, rhs?._art));
+  }
   return false;
 
   /**

package/lib/checks/validator.js

@@ -6,12 +6,14 @@ const {
 } = require('../model/csnUtils');
 const enrich = require('./enricher');
 
-// forHana
+// forRelationalDB
 const { validateSelectItems } = require('./selectItems');
 const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const checkForEmptyOrOnlyVirtual = require('./emptyOrOnlyVirtual');
+const checkForHanaTypes = require('./checkForTypes');
+const checkForParams = require('./parameters');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
 const { checkActionOrFunction } = require('./actionsFunctions');
@@ -26,7 +28,9 @@ const {
   checkTypeDefinitionHasType, checkElementTypeDefinitionHasType,
   checkTypeIsScalar, checkDecimalScale,
 } = require('./types');
-const { checkPrimaryKey, checkVirtualElement, checkManagedAssoc } = require('./elements');
+const {
+  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+} = require('./elements');
 const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
@@ -38,7 +42,7 @@ const {
   checkSqlAnnotationOnElement,
 } = require('./sql-snippets');
 
-const forHanaMemberValidators
+const forRelationalDBMemberValidators
 = [
   // For HANA CDS specifically, reject any default parameter values, as these are not supported.
   rejectParamDefaultsInHanaCds,
@@ -51,7 +55,7 @@ const forHanaMemberValidators
   checkSqlAnnotationOnElement,
 ];
 
-const forHanaArtifactValidators
+const forRelationalDBArtifactValidators
 = [
   // @cds.persistence has no impact on odata
   validateCdsPersistenceAnnotation,
@@ -61,12 +65,12 @@ const forHanaArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forHanaCsnValidators = [ nonexpandableStructuredInExpression ];
+const forRelationalDBCsnValidators = [ nonexpandableStructuredInExpression ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */
-const forHanaQueryValidators = [
-  // TODO reason why this is forHana exclusive
+const forRelationalDBQueryValidators = [
+  // TODO reason why this is forRelationalDB exclusive
   validateSelectItems,
   checkQueryForNoDBArtifacts,
 ];
@@ -103,7 +107,12 @@ const commonMemberValidators
   checkVirtualElement, checkElementTypeDefinitionHasType ];
 
 // TODO: checkManagedAssoc is a forEachMemberRecursively!
-const commonArtifactValidators = [ checkTypeDefinitionHasType, checkPrimaryKey, checkManagedAssoc ];
+const commonArtifactValidators = [
+  checkTypeDefinitionHasType,
+  checkPrimaryKey,
+  checkManagedAssoc,
+  checkRecursiveTypeUsage,
+];
 // TODO: Does it make sense to run the on-condition check as part of a CSN validator?
 const commonQueryValidators = [ validateMixinOnCondition ];
 
@@ -181,16 +190,29 @@ function mergeCsnValidators(csnValidators, that) {
   return remapped;
 }
 
+/**
+ * Depending on the dialect we need to run different validations.
+ *
+ * @param {CSN.Options} options
+ * @returns {any[]} Array of validator functions (or objects?)
+ */
+function getDBCsnValidators(options) {
+  if (options.sqlDialect === 'postgres' || options.sqlDialect === 'h2')
+    return [ ...forRelationalDBCsnValidators, checkForHanaTypes, checkForParams ];
+
+  return forRelationalDBCsnValidators;
+}
+
 /**
  * @param {CSN.Model} csn CSN to check
  * @param {object} that Will be provided to the validators via "this"
  * @returns {Function} the validator function with the respective checks for the HANA backend
  */
-function forHana(csn, that) {
+function forRelationalDB(csn, that) {
   return _validate(csn, that,
-                   forHanaCsnValidators,
-                   forHanaMemberValidators.concat(commonMemberValidators),
-                   forHanaArtifactValidators.concat(commonArtifactValidators).concat(
+                   getDBCsnValidators(that.options),
+                   forRelationalDBMemberValidators.concat(commonMemberValidators),
+                   forRelationalDBArtifactValidators.concat(commonArtifactValidators).concat(
                      // why is this hana exclusive
                      (artifact) => {
                        /*  the validation itself performs a recursive check on structured elements.
@@ -200,7 +222,7 @@ function forHana(csn, that) {
                        forEachMember(artifact, checkUsedTypesForAnonymousAspectComposition.bind(that));
                      }
                    ),
-                   forHanaQueryValidators.concat(commonQueryValidators),
+                   forRelationalDBQueryValidators.concat(commonQueryValidators),
                    {
                      skipArtifact: artifact => artifact.abstract ||
                                                 hasAnnotationValue(artifact, '@cds.persistence.skip') ||
@@ -235,4 +257,4 @@ function forOdata(csn, that) {
                    });
 }
 
-module.exports = { forHana, forOdata };
+module.exports = { forRelationalDB, forOdata };

package/lib/compiler/assert-consistency.js

@@ -229,11 +229,13 @@ function assertConsistency( model, stage ) {
     elements: { kind: true, inherits: 'definitions', also: [ 0 ] }, // 0 for cyclic expansions
     // specified elements in query entities (TODO: introduce real "specified elements" instead):
     elements$: { kind: true, enumerable: false, test: TODO },
+    enum$: { kind: true, enumerable: false, test: TODO },
     actions: { kind: true, inherits: 'definitions' },
     enum: { kind: true, inherits: 'definitions' },
     foreignKeys: { kind: true, inherits: 'definitions' },
     $keysNavigation: { kind: true, test: TODO },
     params: { kind: true, inherits: 'definitions' },
+    _extendType: { kind: true, test: TODO },
     mixin: { inherits: 'definitions' },
     query: {
       kind: true,
@@ -293,7 +295,7 @@ function assertConsistency( model, stage ) {
       none: { optional: () => true }, // parse error
     },
     columns: {
-      kind: [ 'extend' ],
+      kind: [ 'extend', '$column' ],
       test: isArray( column ),
       optional: thoseWithKind,
       enum: [ '*' ],
@@ -307,6 +309,7 @@ function assertConsistency( model, stage ) {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
       requires: [ 'location', 'name' ],
+      optional: [ '$duplicates' ],
     },
     orderBy: { inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
@@ -330,7 +333,7 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
-        'scope', '_artifact', '$inferred', '$expand', '$tableAliases', '_$next',
+        'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$tableAliases', '_$next',
         '_effectiveType',           // by propagation
       ],
     },
@@ -360,12 +363,13 @@ function assertConsistency( model, stage ) {
     suffix: { test: TODO },
     kind: {
       isRequired: !stageParser && (() => true),
+      kind: true,
       // required to be set by Core Compiler even with parse errors
       test: isString,
       enum: [
         'context', 'service', 'entity', 'type', 'aspect', 'const', 'annotation',
         'element', 'enum', 'action', 'function', 'param', 'key', 'event',
-        'annotate', 'extend',
+        'annotate', 'extend', '$column',
         'select', '$join', 'mixin',
         'source', 'namespace', 'using',
         '$tableAlias', '$navElement',
@@ -395,7 +399,7 @@ function assertConsistency( model, stage ) {
         requires: [ 'location', 'path' ],
         optional: [ 'scope', 'variant', '_artifact', '$inferred', '$parens', 'sort', 'nulls' ],
       },
-      none: { optional: [ 'location', '$parens' ] },
+      none: { optional: () => true }, // parse error
       // TODO: why optional / enough in name?
       // TODO: "yes" instead "none": val: true, optional literal/location
       val: {
@@ -504,8 +508,8 @@ function assertConsistency( model, stage ) {
       optional: [
         'enum',
         'elements', 'cardinality', 'target', 'on', 'foreignKeys', 'items',
-        '_outer', '_effectiveType', 'notNull',
-        '_origin', '_block', '$inferred', '$expand', '_deps',
+        '_outer', '_effectiveType', 'notNull', '_parent',
+        '_origin', '_block', '$inferred', '$expand', '$inCycle', '_deps',
         '$syntax',
         '_status', '_redirected',
         ...typeProperties,
@@ -602,11 +606,13 @@ function assertConsistency( model, stage ) {
       kind: true,
       test: isOneOf([
         // Uppercase values are used in logic, lowercase value are "just for us", i.e.
-        // debugging or to add non-enumerable properties such as $generated in Universal CSN.
+        // debugging or to add properties such as $generated in Universal CSN.
         // However, that is no longer true. For example, `autoexposed` is used in populate.js
         // as well.
         'IMPLICIT',
         'REDIRECTED',
+        'NULL', // from propagator
+        'prop', // from propagator
 
         '$autoElement', // for magicVars: $user is automatically changed to $user.id
         '$generated', // compiler generated annotations, e.g. @Core.Computed
@@ -618,8 +624,7 @@ function assertConsistency( model, stage ) {
         'composition-entity',
         'copy', // only used in rewriteCondition(): On-condition is copied
         'duplicate-autoexposed', // just like `autoexposed`, but with `duplicate` error.
-        'expand-element', // expanded elements
-        'expand-param',  // expanded params (difference to expand-element only for debugging)
+        'expanded', // expanded elements, items, params
         'include', // through includes, e.g. `entity E : F {}`
         'keys',
         'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
@@ -628,6 +633,8 @@ function assertConsistency( model, stage ) {
         'none', // only used in ensureColumnName(): Used in object representing empty alias
         'query', // inferred query properties, e.g. `key`
         'rewrite', // on-conditions or FKeys are rewritten
+        'parent-origin', // annotation/property copied from parent that does not come through
+        //                  $origin and is not a direct annotation
       ]),
     },
 
@@ -639,6 +646,7 @@ function assertConsistency( model, stage ) {
       // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
       test: isOneOf([ 'origin', 'annotate', 'target' ]),
     },
+    $inCycle: { kind: true, test: isBoolean },
 
     $autoexpose: { kind: [ 'entity' ], test: isBoolean, also: [ null, 'Composition' ] },
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
@@ -814,7 +822,7 @@ function assertConsistency( model, stage ) {
     const sub = Object.assign( {}, s.inherits && schema[s.inherits], s );
     if (spec.requires && sub.requires)
       sub.requires = [ ...sub.requires, ...spec.requires ];
-    if (spec.optional && sub.optional)
+    if (Array.isArray( spec.optional ) && Array.isArray( sub.optional ))
       sub.optional = [ ...sub.optional, ...spec.optional ];
     // console.log(expressionSpec(node) );
     (sub.test || standard)( node, parent, prop, sub, idx );
@@ -827,9 +835,9 @@ function assertConsistency( model, stage ) {
       return 'val';
     else if (node.query)
       return 'query';
-    else if (!node.op)
-      return 'none';
-    return 'op';
+    else if (node.op)
+      return 'op';
+    return 'none';              // parse error
   }
 
   function args( node, parent, prop, spec ) {

package/lib/compiler/builtins.js

@@ -19,6 +19,10 @@ const core = {
   DecimalFloat: { category: 'decimal', deprecated: true },
   Integer64: { category: 'integer' },
   Integer: { category: 'integer' },
+  UInt8: { category: 'integer' },
+  Int16: { category: 'integer' },
+  Int32: { category: 'integer' },
+  Int64: { category: 'integer' },
   Double: { category: 'decimal' },
   Date: { category: 'dateTime' },
   Time: { category: 'dateTime' },
@@ -54,6 +58,7 @@ const typeParameters = {
     srid: [ 'number' ],
   },
 };
+// a.k.a "typeProperties"
 typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
 
 // const hana = {
@@ -137,6 +142,7 @@ const specialFunctions = compileFunctions( {
       separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
     },
   ],
+  SUBSTR_REGEXPR: 'SUBSTRING_REGEXPR',
 } );
 
 function compileFunctions( special ) {
@@ -364,6 +370,8 @@ function isInReservedNamespace(absolute) {
  * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
  * are directly in 'cds', but not for example in 'cds.foundation'.
  *
+ * TODO: Handle `{ ref: [ "cds.Integer" ] }`
+ *
  * @param {string} type
  * @returns {boolean}
  */