@sap/cds-compiler 3.5.2 → 3.6.0

package/lib/base/optionProcessorHelper.js

@@ -641,8 +641,15 @@ function createOptionProcessor() {
     // hard-coded option dependencies (they disappear with command)
     return result;
 
-    // Verify parameter value 'param' against option definition 'opt'. Return an error
-    // string or false for an accepted param. Use 'prefix' when mentioning the option name.
+    /**
+     * Verify parameter value 'param' against option definition 'opt'. Return an error
+     * string or false for an accepted param. Use 'prefix' when mentioning the option name.
+     *
+     * @param param
+     * @param opt
+     * @param prefix
+     * @return {string|boolean}
+     */
     function verifyOptionParam( param, opt, prefix ) {
       if (opt.param) {
         // Parameter is required for this option

package/lib/base/shuffle.js

@@ -0,0 +1,50 @@
+// Return shuffle functions using pseudo random functions
+
+// By <https://github.com/bryc/code/blob/c97a26ad27a9f9d4f48cd3307fd8ee6f1772d4eb/jshash/PRNGs.md>:
+
+// The random seed must be an integer between 0 and 4294967295 (or 1 and 4294967296  = 2**32)
+function shuffleGen( seed ) {
+  return (Number.isSafeInteger( seed ) && seed > 0)
+    ? { shuffleArray, shuffleDict }
+    : { shuffleArray: a => a, shuffleDict: d => d };
+
+  function random() {           // from function mulberry32() in doc above
+    seed = seed + 0x6D2B79F5 | 0;
+    let t = Math.imul( seed ^ seed >>> 15, 1 | seed );
+    t = t + Math.imul( t ^ t >>> 7, 61 | t ) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+
+  /**
+   * Shuffles array in place.
+   * https://en.wikipedia.org/wiki/Fisher–Yates_shuffle#The_modern_algorithm
+   *
+   * @param {Array} array items An array containing the items.
+   */
+  function shuffleArray( array ) {
+    let i = array.length;
+    while (i > 1) {
+      const j = Math.floor( random() * i );
+      --i;
+      const temp = array[i];
+      array[i] = array[j];
+      array[j] = temp;
+    }
+    return array;
+  }
+
+  /**
+   * Return a shuffled version of `dict`.
+   */
+  function shuffleDict( dict ) {
+    if (!dict)
+      return dict;
+    const names = shuffleArray( Object.keys( dict ) );
+    const r = Object.create( null );
+    for (const n of names)
+      r[n] = dict[n];
+    return r;
+  }
+}
+
+module.exports = shuffleGen;

package/lib/checks/actionsFunctions.js

@@ -27,8 +27,9 @@ function checkActionOrFunction( art, artName, prop, path ) {
   if (art.kind === 'entity') {
     for (const [ actName, act ] of Object.entries(art.actions)) {
       if (act.params) {
+        checkExplicitBindingParameter.call(this, act.params, path.concat([ 'actions', actName, 'params' ]));
         for (const [ paramName, param ] of Object.entries(act.params))
-          checkActionOrFunctionParameter.bind(this)(param, path.concat([ 'actions', actName, 'params', paramName ]), act.kind);
+          checkActionOrFunctionParameter.call(this, param, path.concat([ 'actions', actName, 'params', paramName ]), act.kind);
       }
       if (act.returns)
         checkReturns.bind(this)(act.returns, path.concat([ 'actions', actName, 'returns' ]), act.kind);
@@ -37,12 +38,27 @@ function checkActionOrFunction( art, artName, prop, path ) {
   else {
     if (art.params) {
       for (const [ paramName, param ] of Object.entries(art.params))
-        checkActionOrFunctionParameter.bind(this)(param, path.concat([ 'params', paramName ]), art.kind);
+        checkActionOrFunctionParameter.call(this, param, path.concat([ 'params', paramName ]), art.kind);
     }
     if (art.returns)
       checkReturns.bind(this)(art.returns, path.concat('returns'), art.kind);
   }
 
+  /**
+   *
+   * @param {object} params parameter dictionary
+   * @param {CSN.Path} currPath to the action parameter
+   */
+  function checkExplicitBindingParameter( params, currPath ) {
+    Object.entries(params).forEach(([ pn, p ], i) => {
+      const type = p.items?.type || p.type;
+      if (type === '$self' && !this.csn.definitions.$self && i > 0) {
+        this.error(null, currPath.concat(pn),
+                   'Binding parameter is expected to appear on first position only');
+      }
+    });
+  }
+
   /**
    * Check the parameters of an action
    *
@@ -51,28 +67,29 @@ function checkActionOrFunction( art, artName, prop, path ) {
    * @param {string} actKind 'action' or 'function'
    */
   function checkActionOrFunctionParameter( param, currPath, actKind ) {
-    const paramType = param.type ? this.csnUtils.getFinalTypeDef(param.type) : param;
-
-    if (!isBetaEnabled(this.options, 'optionalActionFunctionParameters') && (param.default || paramType.default)) {
-      this.message('param-default', currPath, { '#': actKind },
-                   {
-                     std: 'Artifact parameters can\'t have a default value', // Not used
-                     action: 'Action parameters can\'t have a default value',
-                     function: 'Function parameters can\'t have a default value',
-                   });
+    const paramType = param.type ? this.csnUtils.getFinalBaseTypeWithProps(param.type) : param;
+    if (!paramType)
+      return; // no type could be resolved
+
+    // "default" is always propagated to params
+    if (param.default && !isBetaEnabled(this.options, 'optionalActionFunctionParameters')) {
+      this.message('param-default', currPath, { '#': actKind }, {
+        std: 'Artifact parameters can\'t have a default value', // Not used
+        action: 'Action parameters can\'t have a default value',
+        function: 'Function parameters can\'t have a default value',
+      });
     }
 
-    if (paramType.type && this.csnUtils.isAssocOrComposition(param.type)) {
-      this.error(null, currPath, { '#': actKind },
-                 {
-                   std: 'An association is not allowed as this artifact\'s parameter type', // Not used
-                   action: 'An association is not allowed as action\'s parameter type',
-                   function: 'An association is not allowed as function\'s parameter type',
-                 });
+    if (param.type && this.csnUtils.isAssocOrComposition(param.type)) {
+      this.error(null, currPath, { '#': actKind }, {
+        std: 'An association is not allowed as this artifact\'s parameter type', // Not used
+        action: 'An association is not allowed as action\'s parameter type',
+        function: 'An association is not allowed as function\'s parameter type',
+      });
     }
 
-    if (paramType.items && paramType.items.type)
-      checkActionOrFunctionParameter.bind(this)(paramType.items, currPath.concat('items'), actKind);
+    if (paramType.items?.type)
+      checkActionOrFunctionParameter.call(this, paramType.items, currPath.concat('items'), actKind);
 
     // check if the structured & user-defined is from the current service
     checkUserDefinedType.bind(this)(paramType, param.type, currPath);

package/lib/checks/foreignKeys.js

@@ -11,8 +11,9 @@ const { setProp } = require('../base/model');
  * - no usage of unmanaged association as foreign keys (also not transitively)
  *
  * @param {object} member Member
+ * @param {string} memberName Member name
  */
-function validateForeignKeys( member ) {
+function validateForeignKeys( member, memberName ) {
   // We have a managed association
   const isManagedAssoc = mem => mem && mem.target && !mem.on;
   // We have an unmanaged association
@@ -25,7 +26,7 @@ function validateForeignKeys( member ) {
         if (!key._art)
           continue;
         // eslint-disable-next-line no-use-before-define
-        checkForItems(key._art);
+        checkForItemsOrMissingType(key._art, key.ref.join('.'));
       }
     }
   };
@@ -35,13 +36,13 @@ function validateForeignKeys( member ) {
     for (const elementName of Object.keys(mem.elements)) {
       const element = mem.elements[elementName];
       // eslint-disable-next-line no-use-before-define
-      checkForItems(element);
+      checkForItemsOrMissingType(element, elementName);
     }
   };
 
   // Recursively perform the checks on an element
   // Declared as arrow-function to keep scope the same (this value)
-  const checkForItems = (mem) => {
+  const checkForItemsOrMissingType = (mem, memName) => {
     if (mem.items) {
       this.error(null, member.$path, {}, 'Array-like properties must not be foreign keys');
     }
@@ -60,14 +61,20 @@ function validateForeignKeys( member ) {
         : this.csn.definitions[mem.type];
       if (type && !type.$visited) {
         setProp(type, '$visited', true);
-        checkForItems(type);
+        checkForItemsOrMissingType(type, memName);
         delete type.$visited;
       }
     }
+    else if (mem && !mem.type) {
+      const variant = member.type === 'cds.Composition' ? 'managedCompForeignKey' : 'managedAssocForeignKey';
+      this.error('check-proper-type-of', member.$path, {
+        '#': variant, name: memName, art: memberName,
+      });
+    }
   };
 
   if (isManagedAssoc(member))
-    checkForItems(member);
+    checkForItemsOrMissingType(member, memberName);
 }
 
 module.exports = validateForeignKeys;

package/lib/checks/nonexpandableStructured.js

@@ -24,8 +24,7 @@ function nonexpandableStructuredInExpression( parent, name, expression ) {
         if ((_art?.elements || _art?.keys && (i === 0 || expression[i - 1] !== 'exists')) && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
           this.error('ref-unexpected-structured',
                      name === 'on' ? [ ...parent.$path, name, i ] : expression[i].$path,
-                     { elemref: { ref } },
-                     'Unexpected usage of structured type $(ELEMREF)');
+                     { '#': 'std', elemref: { ref } } );
         }
       }
     }

package/lib/checks/onConditions.js

@@ -103,28 +103,30 @@ function validateOnCondition( member, memberName, property, path ) {
             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);
+          const type = resolveArtifactType.call(this, _art);
+          if (type) {
           // For error messages
-          const onPath = path.concat([ 'on', i, 'ref', ref.length - 1 ]);
-          // Paths of an ON condition may end on a structured element or an association only if:
-          // 1) Both operands in the expression end on a structured element or on
-          //    a managed association (that are both expandable)
-          // 2) Path ends on an association (managed or unmanaged) and the other operand is a '$self'
+            const onPath = path.concat([ 'on', i, 'ref', ref.length - 1 ]);
+            // Paths of an ON condition may end on a structured element or an association only if:
+            // 1) Both operands in the expression end on a structured element or on
+            //    a managed association (that are both expandable)
+            // 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.target) &&
-             !( /* 1) */ (_art.target && _art.keys) && validStructuredElement ||
-             /* 2) */ (_art.target && validDollarSelf)) &&
-             !_art.virtual) {
+            // If this path ends structured or on an association, perform the check:
+            if ((type.target) &&
+             !( /* 1) */ (type.target && type.keys) && validStructuredElement ||
+             /* 2) */ (type.target && validDollarSelf)) &&
+             !type.virtual) {
             // Do nothing - handled by lib/checks/nonexpandableStructured.js
-          }
-          else if (_art.items && !_art.virtual) {
-            this.error(null, onPath, { elemref: { ref } },
-                       '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)');
+            }
+            else if (type.items && !type.virtual) {
+              this.error(null, onPath, { elemref: { ref } },
+                         'ON-conditions can\'t use array-like elements, path $(ELEMREF)');
+            }
+            else if (type.virtual) {
+              this.error(null, onPath, { elemref: { ref } },
+                         'Virtual elements can\'t be used in ON-conditions, path $(ELEMREF)');
+            }
           }
         }
       }

package/lib/checks/parameters.js

@@ -12,7 +12,7 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  */
 function checkForParams( parent, name, params, path ) {
   const artifact = this.csn.definitions[path[1]];
-  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && !(parent.kind !== 'entity')) {
+  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)');
   }

package/lib/checks/queryNoDbArtifacts.js

@@ -25,6 +25,8 @@ function checkQueryForNoDBArtifacts( query ) {
    */
   const leafCount = (def) => {
     let c = 0;
+    if (!def)
+      return c;
     if (def.elements) {
       c += Object.values(def.elements).reduce((acc, e) => {
         acc += leafCount(e);

package/lib/checks/types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getUtils, hasAnnotationValue } = require('../model/csnUtils');
+const { hasAnnotationValue } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -46,15 +46,12 @@ function checkTypeIsScalar( member, memberName, prop, path ) {
  * @param {CSN.Path} path the path to the member
  */
 function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
+  if (prop !== 'elements' && prop !== 'params')
+    return; // no enum, etc.
   // Computed elements, e.g. "1+1 as foo" in a view don't have a valid type and
-  // are skipped here.
-  // Elements in projections are not tested as well
+  // are skipped here.  References to such columns are checked further below.
   const parent = this.csn.definitions[path[1]];
-  if (parent.projection || parent.query || prop !== 'elements')
-    return;
-
-  // should only happen with csn input, not in cdl
-  if (!hasArtifactTypeInformation(member)) {
+  if (!parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
     errorAboutMissingType(this.error, path, memberName, true);
     return;
   }
@@ -63,8 +60,8 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
   if (member.type) {
     if (member.type.ref) {
       const isSelfReference = path[1] === member.type.ref[0];
-      checkTypeOfHasProperType(
-        member, memberName, this.csn, this.error, path, isSelfReference ? member.type.ref[1] : null
+      checkTypeOfHasProperType.call(
+        this, member, memberName, this.csn, this.error, path, isSelfReference ? member.type.ref[1] : null
       );
     }
     else if (member._type) {
@@ -77,7 +74,7 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
   // many
   const { items } = member;
   if (items)
-    checkTypeOfHasProperType(items, memberName, this.csn, this.error, path );
+    checkTypeOfHasProperType.call(this, items, memberName, this.csn, this.error, path );
 }
 
 /**
@@ -102,14 +99,14 @@ function checkTypeDefinitionHasType( artifact, artifactName, prop, path ) {
 
   // Check for `type of`
   if (artifact.type) {
-    checkTypeOfHasProperType(artifact, artifactName, this.csn, this.error, path);
+    checkTypeOfHasProperType.call(this, artifact, artifactName, this.csn, this.error, path);
     return;
   }
 
   // many
   const { items } = artifact;
   if (items)
-    checkTypeOfHasProperType(items, artifactName, this.csn, this.error, path );
+    checkTypeOfHasProperType.call(this, items, artifactName, this.csn, this.error, path );
 }
 
 
@@ -129,23 +126,20 @@ function checkTypeOfHasProperType( artOrElement, name, model, error, path, deriv
   if (!artOrElement.type)
     return;
 
-  const { getFinalBaseTypeWithProps } = getUtils(model);
-  const typeOfType = getFinalBaseTypeWithProps(artOrElement.type);
+  const typeOfType = this.csnUtils.getFinalBaseTypeWithProps(artOrElement.type);
 
   if (typeOfType === null) {
-    if (artOrElement.type.ref) {
+    if (artOrElement.type.ref && this?.options?.transformation !== 'odata') {
       const typeOfArt = artOrElement.type.ref[0];
-      const typeOfElt = artOrElement.type.ref[1];
-      // TODO: using error() must be consistent to central messages!
-      error('check-proper-type-of', path, { art: derivedTypeName || typeOfArt, name: typeOfElt, '#': derivedTypeName ? 'derived' : 'std' }, {
-        std: 'Referred element $(NAME) of $(ART) does not contain proper type information',
-        derived: 'Referred type of $(ART) does not contain proper type information',
+      const typeOfElt = artOrElement.type.ref.slice(1).join('.');
+      error('check-proper-type-of', path, {
+        art: derivedTypeName || typeOfArt, name: typeOfElt, '#': derivedTypeName ? 'derived' : 'std',
       });
     }
   }
   else if (typeOfType && typeOfType.items) {
     derivedTypeName = typeof artOrElement.type === 'string' ? artOrElement.type : artOrElement.type.ref[artOrElement.type.ref.length - 1];
-    checkTypeOfHasProperType(typeOfType.items, name, model, error, path, derivedTypeName);
+    checkTypeOfHasProperType.call(this, typeOfType.items, name, model, error, path, derivedTypeName);
   }
 }
 

package/lib/compiler/assert-consistency.js

@@ -75,6 +75,12 @@ const typeProperties = [
   '_effectiveType',
 ];
 
+class InternalConsistencyError extends Error {
+  constructor(msg) {
+    super(`cds-compiler XSN consistency: ${ msg }`);
+  }
+}
+
 function assertConsistency( model, stage ) {
   const stageParser = typeof stage === 'object';
   const options = stageParser && stage || model.options || { testMode: true };
@@ -462,7 +468,7 @@ function assertConsistency( model, stage ) {
     // preliminary -----------------------------------------------------------
     doc: {
       kind: true,
-      test: locationVal( isStringOrNull ),
+      test: TODO,
     }, // doc comment
     '@': {
       kind: true,
@@ -671,25 +677,27 @@ function assertConsistency( model, stage ) {
   function assertProp( node, parent, prop, extraSpec, noPropertyTest ) {
     let spec = extraSpec || schema[prop] || schema[prop.charAt(0)];
     if (!spec)
-      throw new Error( `Property '${ prop }' has not been specified`);
+      throw new InternalConsistencyError( `Property '${ prop }' has not been specified`);
     spec = inheritSpec( spec );
 
     if (!noPropertyTest) {
       const char = prop.charAt(0);
       const parser = ('parser' in spec) ? spec.parser : char !== '_' && char !== '$';
       if (stageParser && !parser)
-        throw new Error( `Non-parser property '${ prop }' set by ${ model.$frontend || '' } parser${ at( [ node, parent ] ) }` );
+        throw new InternalConsistencyError( `Non-parser property '${ prop }' set by ${ model.$frontend || '' } parser${ at( [ node, parent ] ) }` );
       const enumerable = ('enumerable' in spec) ? spec.enumerable : char !== '_';
       if (enumerable instanceof Function
           ? !enumerable( parent, prop )
           : {}.propertyIsEnumerable.call( parent, prop ) !== enumerable)
-        throw new Error( `Unexpected enumerability ${ !enumerable }${ at( [ node, parent ], prop ) }` );
+        throw new InternalConsistencyError( `Unexpected enumerability ${ !enumerable }${ at( [ node, parent ], prop ) }` );
     }
     (spec.test || standard)( node, parent, prop, spec,
                              typeof noPropertyTest === 'string' && noPropertyTest );
   }
 
   function definition( node, parent, prop, spec, name ) {
+    if (node.builtin)
+      return;
     if (!Array.isArray( node ))
       node = [ node ];
     // TODO: else check that there is a redefinition error
@@ -704,14 +712,14 @@ function assertConsistency( model, stage ) {
   function builtin( node, parent, prop, spec, name ) {
     const type = typeof node;
     if (type !== 'string' && type !== 'boolean')
-      throw new Error(`Property '${ prop }' must be a boolean or string but was '${ typeof node }'${ at( [ node, parent ], prop, name ) }` );
+      throw new InternalConsistencyError(`Property '${ prop }' must be a boolean or string but was '${ typeof node }'${ at( [ node, parent ], prop, name ) }` );
 
     if (parent.kind !== 'namespace')
-      throw new Error(`Property '${ prop }' must be inside artifact that is a namespace but was '${ parent.kind }'${ at( [ node, parent ], prop, name ) }` );
+      throw new InternalConsistencyError(`Property '${ prop }' must be inside artifact that is a namespace but was '${ parent.kind }'${ at( [ node, parent ], prop, name ) }` );
 
     const parentName = parent.name && parent.name.absolute;
     if (parentName !== 'cds' && parentName !== 'localized')
-      throw new Error(`Property '${ prop }' must be inside namespace 'cds' or 'localized' but was '${ parentName }'${ at( [ node, parent ], prop, name ) }` );
+      throw new InternalConsistencyError(`Property '${ prop }' must be inside namespace 'cds' or 'localized' but was '${ parentName }'${ at( [ node, parent ], prop, name ) }` );
   }
 
   function column( node, ...rest ) {
@@ -740,7 +748,7 @@ function assertConsistency( model, stage ) {
       if (!names.includes(p)) {
         const req = spec.schema && spec.schema[p] && spec.schema[p].isRequired;
         if ((req || schema[p] && schema[p].isRequired || noSyntaxErrors)( node ))
-          throw new Error( `Required property '${ p }' missing in object${ at( [ node, parent ], prop, name ) }` );
+          throw new InternalConsistencyError( `Required property '${ p }' missing in object${ at( [ node, parent ], prop, name ) }` );
       }
     }
     const optional = spec.optional || [];
@@ -749,7 +757,7 @@ function assertConsistency( model, stage ) {
         ? optional.includes( n ) || optional.includes( n.charAt(0) )
         : optional( n, spec );
       if (!(opt || requires.includes( n ) || n === '$extra'))
-        throw new Error( `Property '${ n }' is not expected${ at( [ node[n], node, parent ], prop, name ) }` );
+        throw new InternalConsistencyError( `Property '${ n }' is not expected${ at( [ node[n], node, parent ], prop, name ) }` );
 
       assertProp( node[n], node, n, spec.schema && spec.schema[n] );
     }
@@ -772,7 +780,7 @@ function assertConsistency( model, stage ) {
       if (spec[choice])
         assertProp( node, parent, prop, spec[choice], choice );
       else
-        throw new Error( `No specification for computed variant '${ choice }'${ at( [ node, parent ], prop, idx ) }` );
+        throw new InternalConsistencyError( `No specification for computed variant '${ choice }'${ at( [ node, parent ], prop, idx ) }` );
     }
   }
 
@@ -787,7 +795,7 @@ function assertConsistency( model, stage ) {
       if (spec[choice])
         assertProp( node, parent, prop, spec[choice], choice );
       else
-        throw new Error( `No specification for computed variant '${ choice }'${ at( [ node, parent ], prop, idx ) }` );
+        throw new InternalConsistencyError( `No specification for computed variant '${ choice }'${ at( [ node, parent ], prop, idx ) }` );
     }
   }
 
@@ -852,7 +860,7 @@ function assertConsistency( model, stage ) {
         expression( node[n], parent, prop, spec, n );
     }
     else {
-      throw new Error( `Expected array or dictionary${ at( [ null, parent ], prop ) }` );
+      throw new InternalConsistencyError( `Expected array or dictionary${ at( [ null, parent ], prop ) }` );
     }
   }
 
@@ -871,7 +879,7 @@ function assertConsistency( model, stage ) {
       // if (!node || typeof node !== 'object' || Object.getPrototypeOf( node ))
       //   console.log(node,prop,model.$frontend)
       if (!node || typeof node !== 'object' || Object.getPrototypeOf( node ))
-        throw new Error( `Expected dictionary${ at( [ null, parent ], prop ) }` );
+        throw new InternalConsistencyError( `Expected dictionary${ at( [ null, parent ], prop ) }` );
       for (const n in node)
         func( node[n], parent, prop, spec, n );
     };
@@ -880,7 +888,7 @@ function assertConsistency( model, stage ) {
   function isArray( func = standard ) {
     return function vector( node, parent, prop, spec ) {
       if (!Array.isArray(node))
-        throw new Error( `Expected array${ at( [ null, parent ], prop ) }` );
+        throw new InternalConsistencyError( `Expected array${ at( [ null, parent ], prop ) }` );
       node.forEach( (item, n) => func( item, parent, prop, spec, n ) );
     };
   }
@@ -898,46 +906,41 @@ function assertConsistency( model, stage ) {
     if ((spec.also) ? spec.also.includes( node ) : (node === null))
       return;
     if (typeof node !== 'boolean')
-      throw new Error( `Expected boolean or null${ at( [ node, parent ], prop ) }` );
+      throw new InternalConsistencyError( `Expected boolean or null${ at( [ node, parent ], prop ) }` );
   }
 
   function isNumber( node, parent, prop, spec ) {
     if (spec.also && spec.also.includes( node ))
       return;
     if (typeof node !== 'number')
-      throw new Error( `Expected number${ at( [ node, parent ], prop ) }` );
-  }
-
-  function isStringOrNull( node, parent, prop, spec ) {
-    if (node !== null)
-      isString(node, parent, prop, spec);
+      throw new InternalConsistencyError( `Expected number${ at( [ node, parent ], prop ) }` );
   }
 
   function isOneOf( values ) {
     return function isOneOfInner( node, parent, prop ) {
       if (!values.includes(node))
-        throw new Error( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
+        throw new InternalConsistencyError( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
     };
   }
 
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
-      throw new Error( `Expected string${ at( [ node, parent ], prop ) }` );
+      throw new InternalConsistencyError( `Expected string${ at( [ node, parent ], prop ) }` );
       // TODO: also check getOwnPropertyNames(node)
     if (spec.enum && !spec.enum.includes( node ))
-      throw new Error( `Unexpected value '${ node }'${ at( [ node, parent ], prop ) }` );
+      throw new InternalConsistencyError( `Unexpected value '${ node }'${ at( [ node, parent ], prop ) }` );
   }
 
   function isVal( node, parent, prop, spec ) {
     if (Array.isArray(node))
       node.forEach( (item, n) => standard( item, parent, prop, spec, n ) );
     else if (node !== null && ![ 'string', 'number', 'boolean' ].includes( typeof node ))
-      throw new Error( `Expected array or simple value${ at( [ null, parent ], prop ) }` );
+      throw new InternalConsistencyError( `Expected array or simple value${ at( [ null, parent ], prop ) }` );
   }
 
   function isObject( node, parent, prop, spec, name ) {
     if (!node || typeof node !== 'object' || Object.getPrototypeOf( node ) !== Object.prototype)
-      throw new Error( `Expected standard object${ at( [ null, parent ], prop, name ) }` );
+      throw new InternalConsistencyError( `Expected standard object${ at( [ null, parent ], prop, name ) }` );
   }
 
   function inDefinitions( art, parent, prop, spec, name ) {
@@ -956,7 +959,7 @@ function assertConsistency( model, stage ) {
           art.name.absolute && art.name.absolute.startsWith('localized.'))
         standard( art, parent, prop, spec, name );
       else
-        throw new Error( `Expected definition${ at( [ art, parent ], prop, name ) }` );
+        throw new InternalConsistencyError( `Expected definition${ at( [ art, parent ], prop, name ) }` );
     }
   }
 
@@ -966,7 +969,7 @@ function assertConsistency( model, stage ) {
       return;
     const validValues = [ 'typeOf', 'global', 'param' ];
     if (!validValues.includes(node))
-      throw new Error( `Property '${ prop }' must be either "${ validValues.join('", "') }" or a number but was "${ node }"` );
+      throw new InternalConsistencyError( `Property '${ prop }' must be either "${ validValues.join('", "') }" or a number but was "${ node }"` );
   }
 
   function TODO() { /* no-op */ }

package/lib/compiler/builtins.js

@@ -250,6 +250,22 @@ const quotedLiteralPatterns = {
     },
     json_type: 'string',
   },
+  // and only for CSN parser:
+  null: {
+    json_type: 'null',          // modulo JSON typeof weirdness
+  },
+  boolean: {
+    json_type: 'boolean',
+  },
+  number: {
+    test_variant: 'number',
+    test_fn: (x => /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i.test( x )),
+    json_type: 'number',
+    secondary_json_type: 'string',
+  },
+  string: {
+    json_type: 'string',
+  },
 };
 
 /**
@@ -390,14 +406,13 @@ function initBuiltins( model ) {
   setMagicVariables( magicVariables );
   // namespace:"cds" stores the builtins ---
   const cds = createNamespace( 'cds', 'reserved' );
-  // setProp( model.definitions, 'cds', cds );
-  model.definitions.cds = cds; // not setProp - oData - TODO: still needed?
+  model.definitions.cds = cds;
   // Also add the core artifacts to model.definitions`
   model.$builtins = env( core, 'cds.', cds );
   model.$builtins.cds = cds;
   // namespace:"cds.hana" stores HANA-specific builtins ---
   const hana = createNamespace( 'cds.hana', 'reserved' );
-  setProp( model.definitions, 'cds.hana', hana );
+  model.definitions['cds.hana'] = hana;
   model.$builtins.hana = hana;
   cds._subArtifacts.hana = hana;
   env( coreHana, 'cds.hana.', hana );
@@ -430,6 +445,7 @@ function initBuiltins( model ) {
     const artifacts = Object.create(null);
     for (const name of Object.keys( builtins )) {
       const absolute = prefix + name;
+      // TODO: reconsider whether to set a type to itself - looks wrong
       const art = {
         kind: 'type', builtin: true, name: { absolute }, type: { path: [ { id: absolute } ] },
       };
@@ -441,7 +457,7 @@ function initBuiltins( model ) {
       Object.assign( art, builtins[name] );
       if (!art.internal)
         artifacts[name] = art;
-      setProp( model.definitions, absolute, art );
+      model.definitions[absolute] = art;
     }
     return artifacts;
   }