@sap/cds-compiler 3.5.4 → 3.6.2

package/lib/inspect/inspectModelStatistics.js

@@ -2,6 +2,7 @@
 
 const { forEach } = require('../utils/objectUtils');
 const { term } = require('../utils/term');
+const { CompilerAssertion } = require('../base/error');
 
 /**
  * Return a string representation of the inspected results.
@@ -70,7 +71,7 @@ function countDefinitionKinds( xsn ) {
     else if (result[def.kind] !== undefined)
       ++result[def.kind];
     else
-      throw new Error(`Unhandled kind: ${ def.kind } for ${ name }`);
+      throw new CompilerAssertion(`Unhandled kind: ${ def.kind } for ${ name }`);
   });
   return result;
 }

package/lib/inspect/inspectPropagation.js

@@ -4,6 +4,7 @@ const { createMessageFunctions } = require('../base/messages');
 const { locationString } = require('../base/location');
 const { findArtifact, stringRefToPath } = require('./inspectUtils');
 const { term } = require('../utils/term');
+const { CompilerAssertion } = require('../base/error');
 
 /**
  * @param {XSN.Model} xsn
@@ -97,7 +98,7 @@ function _inspectAnnotations( artifactXsn ) {
         }
         // fallthrough
       default:
-        throw new Error(`inspect anno: Unhandled Case: ${ annoXsn.$priority }`);
+        throw new CompilerAssertion(`inspect anno: Unhandled Case: ${ annoXsn.$priority }`);
     }
 
     maxAnnoLength = Math.max(maxAnnoLength, anno.length);

package/lib/json/from-csn.js

@@ -33,7 +33,7 @@
  *                                          dictionary key by default.
  * @property {string}             [msgProp] Display name of the property. compileSchema() sets it to
  *                                          the dictionary key (+ optional '[]') by default.
- * @property {string}               [msgId] Use this message id instead of the default one.
+ * @property {string}          [msgVariant] Use this message variant instead of the default one.
  *                                          Allows more precise and detailed error messages.
  * @property {string|string[]|false} [requires] If the value is a string, then the given sub-
  *                                              property is required. If 'undefined', then at
@@ -63,7 +63,7 @@
  * @property {boolean}            [inValue] Puts the value into an XSN property "value",
  *                                          e.g. { value: ... }
  * @property {string}            [xorGroup] Corresponding xor group. It references a value of
- *                                          $xorGroups. If set then only one property of of the
+ *                                          xorGroups. If set then only one property of of the
  *                                          xorGroup may be set, e.g. if target is set, elements
  *                                          may not.
  * @property {string}               [xsnOp] Defines the operator to be used for XSN. Used for SET
@@ -89,6 +89,7 @@
 
 const { dictAdd } = require('../base/dictionaries');
 const { quotedLiteralPatterns } = require('../compiler/builtins');
+const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for('cds.$location');
 
@@ -97,7 +98,7 @@ let inExtensions = null;
 let vocabInDefinitions = null;  // must be reset!
 
 // CSN property names reserved for CAP
-const ourpropsRegex = /^[_$]?[a-zA-Z]+[0-9]*$/;
+const ourpropsRegex = /^(?:[_$=#@][a-zA-Z]*[0-9]*|[a-zA-Z]+[0-9]*)$/;
 
 // Sync with definition in to-csn.js:
 const typeProperties = [
@@ -120,7 +121,7 @@ const xorGroups = {
   ':expr': [                    // see also xorException property in schema
     'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET', 'expand',
     '=', 'path', 'value', 'op', // '='/'path' is CSN v0.1.0 here
-  ],
+  ],           // also set xorGroupTwo ':col' for 'expand' and 'inline'
   ':ext': [ 'annotate', 'extend' ], // TODO: better msg for test/negative/UnexpectedProperties.csn
   ':assoc': [ 'on', 'keys', 'foreignKeys', 'onCond' ], // 'foreignKeys'/'onCond' is CSN v0.1.0
   // TODO - improve consequential errors: assume no name given with `join` or `inline`?
@@ -138,7 +139,7 @@ const schemaClasses = {
   condition: {
     arrayOf: exprOrString,
     type: condition,
-    msgId: 'syntax-expecting-term',
+    msgVariant: 'or-string',    // for 'syntax-expecting-object'
     // TODO: also specify requires here, and adapt onlyWith()
     optional: exprProperties,
   },
@@ -148,11 +149,11 @@ const schemaClasses = {
   },
   natnumOrStar: {
     type: natnumOrStar,
-    msgId: 'syntax-expecting-cardinality',
+    msgVariant: 'or-asterisk',  // for 'syntax-expecting-unsigned-int'
   },
   columns: {
     arrayOf: selectItem,
-    msgId: 'syntax-expecting-column',
+    msgVariant: 'or-asterisk',  // for 'syntax-expecting-object'
     defaultKind: '$column',
     validKinds: [], // pseudo kind '$column'
     // A column with only as+cast.type is a new association
@@ -251,10 +252,12 @@ const schema = compileSchema( {
   expand: {
     class: 'columns',
     xorException: 'ref',        // see xorGroup :expr
+    xorGroupTwo: ':col',
     inKind: [ '$column' ],      // only valid in $column
   },
   inline: {
     class: 'columns',
+    xorGroupTwo: ':col',
     onlyWith: 'ref',
     inKind: [ '$column' ], // only valid in $column
   },
@@ -296,20 +299,20 @@ const schema = compileSchema( {
   // type properties (except: elements, enum, keys, on): ---------------------
   type: {
     type: artifactRef,
-    msgId: 'syntax-expecting-reference',
+    msgVariant: 'or-object',    // for 'syntax-expecting-string',
     optional: [ 'ref', 'global' ],
     inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation', 'extend' ],
   },
   targetAspect: {
     type: artifactRef,
-    msgId: 'syntax-expecting-reference',
+    msgVariant: 'or-object',    // for 'syntax-expecting-string',
     requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc aspect compositions
     inKind: [ 'element', 'type' ],
   },
   target: {
     type: artifactRef,
-    msgId: 'syntax-expecting-reference',
+    msgVariant: 'or-object',    // for 'syntax-expecting-string',
     requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc COMPOSITION OF (gensrc style CSN)
     inKind: [ 'element', 'type', 'mixin', 'param' ],
@@ -376,7 +379,7 @@ const schema = compileSchema( {
   ref: {
     arrayOf: refItem,
     type: renameTo( 'path', arrayOf( refItem ) ),
-    msgId: 'syntax-expecting-reference',
+    msgVariant: 'or-object',    // for 'syntax-expecting-string',
     minLength: 1,
     requires: 'id',
     optional: [ 'id', 'args', 'cardinality', 'where' ],
@@ -424,20 +427,21 @@ const schema = compileSchema( {
   },
   val: {
     type: value,
-    inKind: [ '$column', 'enum', 'element' ],
+    inKind: [ '$column', 'enum' ],
+    // see also extra handling for 'element' in extension, see definition()
   },
   literal: {
     type: literal,
     onlyWith: 'val',
-    inKind: [ '$column', 'enum' ],
+    inKind: [ '$column', 'enum' ], // 'element' sometimes in extension
   },
   '#': {
     noPrefix: true,             // schema spec for '#', not for '#whatever'
     type: symbol,
     // Note: We emit a warning if '#' is used in enums.  Because the compiler
     // can generate CSN like this, we need to be able to parse it.
-    // Also, in "extensions", an entity's element of type enum has kind "element".
-    inKind: [ '$column', 'enum', 'element' ],
+    inKind: [ '$column', 'enum' ],
+    // see also extra handling for 'element' in extension, see definition()
   },
   path: {                     // in CSN v0.1.0 'foreignKeys'
     vZeroFor: 'ref',
@@ -446,6 +450,7 @@ const schema = compileSchema( {
     type: vZeroRef,
   },
   '=': {                        // v0.1.0 { "=": "A.B" } for v1.0 { "ref": ["A", "B"] }
+    noPrefix: true,             // schema spec for '=', not for '=whatever'
     vZeroFor: 'ref',
     inKind: [],                 // still used in annotation assignments...
     type: vZeroRef,             // ...see property '@' / function annotation()
@@ -579,10 +584,12 @@ const schema = compileSchema( {
   // miscellaneous properties in definitions: --------------------------------
   doc: {
     type: stringValOrNull,
+    msgVariant: 'or-null',      // for 'syntax-expecting-string'
     inKind: () => true,         // allowed in all definitions (including columns and extensions)
   },
   '@': {                        // for all properties starting with '@'
-    prop: '@<anno>',            // which property name do messages use for annotation assignments?
+    noPrefix: false,            // just '@' is no CSN property
+    prop: '@‹anno›',            // which property name do messages use for annotation assignments?
     type: annotation,
     inKind: () => true,         // allowed in all definitions (including columns and extensions)
   },
@@ -646,9 +653,10 @@ const schema = compileSchema( {
     type: ignore,
   },
   value: {
-    vZeroFor: 'val',             // CSN v0.1.0 property for `val` in enum def
-    type: annoValue,
-    // inKind: [ 'enum' ],
+    class: 'expression',        // calculated elements
+    vZeroFor: 'val',            // CSN v0.1.0 property for `val` in enum def
+    // type: annoValue,
+    inKind: [ 'element' ],
   },
   // ignored: ----------------------------------------------------------------
   $location: {                  // special
@@ -679,8 +687,16 @@ const schema = compileSchema( {
   $generated: {
     type: string,
   },
-  $: { type: ignore, ignore: true }, // including $origin
-  _: { type: ignore, ignore: true },
+  $: {
+    noPrefix: false,            // just '$' is no CSN property
+    type: ignore,
+    ignore: true,
+  }, // including $origin
+  _: {
+    noPrefix: false,            // just '_' is no CSN property
+    type: ignore,
+    ignore: true,
+  },
 } );
 
 const topLevelSpec = {
@@ -745,7 +761,7 @@ function compileSchema( specs, proto = null ) {
       else if (s.dictionaryOf)
         s.type = dictionaryOf( s.dictionaryOf );
       else
-        throw new Error( `Missing type specification for property "${ p }"` );
+        throw new CompilerAssertion( `Missing type specification for property "${ p }"` );
     }
   }
   // Set property 'xorGroup' in main and sub schema:
@@ -814,6 +830,7 @@ function extra( node, spec, xsn ) {
   if (!xsn.$extra)
     xsn.$extra = Object.create(null);
   xsn.$extra[spec.prop] = node;
+  return ignore( node );
 }
 
 function eventualCast( obj, spec, xsn ) {
@@ -887,13 +904,22 @@ function definition( def, spec, xsn, csn, name ) {
   }
   pushLocation( def );
   const savedInExtensions = inExtensions;
-  const kind = calculateKind( def, spec ); // might set inExtensions
+  let kind = calculateKind( def, spec ); // might set inExtensions
   const r = (kind === '$column') ? { location: location() } : { location: location(), kind };
   const xor = {};
   const { prop } = spec;
   const kind0 = (spec.validKinds.length || spec.prop === 'extensions') && kind;
   const csnProps = Object.keys( def );
 
+  // If we have `extend … with { name = 3 }`, it could mean adding an element or an enum.
+  // We use `elements: { name: { val: 3 } }` to represent this ambiguity.
+  if (savedInExtensions === '' && prop === 'elements' && !def.value &&
+      (def.val !== undefined || def['#'] !== undefined) &&
+      def.virtual === undefined && def.key === undefined && def.masked === undefined &&
+      def.type === undefined && def.elements === undefined) {
+    r.$syntax = 'enum';
+    kind = 'enum';              // for function expected()
+  }
   if (csnProps.length) {
     const valueName = (prop === 'keys' || prop === 'foreignKeys' ? 'targetElement' : 'value');
     // the next is basically object() + the inValue handling
@@ -964,7 +990,7 @@ function dictionaryOf( elementFct ) {
     for (const name of allNames) {
       if (!name) {
         message( 'syntax-invalid-name', location(true),
-                 { '#': 'csn', parentprop: spec.prop } );
+                 { '#': 'dict', parentprop: spec.prop } );
       }
       const val = elementFct( dict[name], spec, r, dict, name );
       if (val !== undefined)
@@ -992,6 +1018,7 @@ function keys( array, spec, xsn ) {
   xsn.foreignKeys = r;
 }
 
+// Use with spec.msgVariant: 'or-asterisk'
 function selectItem( def, spec, xsn, csn ) {
   if (def === '*')              // compile() will complain about repeated '*'s
     return { val: '*', location: location() };
@@ -1083,9 +1110,14 @@ function validKind( val, spec, xsn ) {
   return ignore( val );
 }
 
+// Use with spec.msgVariant: 'or-object'
 function artifactRef( ref, spec ) {
-  if (!ref || typeof ref !== 'string')
-    return object( ref, spec );
+  if (!ref || typeof ref !== 'string') {
+    if (ref && typeof ref === 'object' && !Array.isArray( ref ))
+      return object( ref, spec );
+    // use error message 'syntax-expecting-string' (string more likely than object):
+    return string( ref, spec );
+  }
   if (spec.prop !== 'type')
     return stringRef( ref, spec );
   // now the CSN v0.1.0 type of: 'Artifact..e1.e2'; error if not csnVersionZero
@@ -1096,7 +1128,7 @@ function artifactRef( ref, spec ) {
     warning( 'syntax-deprecated-value', location(true),
              { '#': 'zero-replace', prop: spec.msgProp, value: '{ ref: […] }' } );
   }
-  const r = refSplit( ref.substring( idx + 2 ), spec.msgProp );
+  const r = refSplit( ref.substring( idx + 2 ), 'type' );
   r.path.unshift( { id: ref.substring( 0, idx ), location: location() } );
   return r;
 }
@@ -1106,10 +1138,14 @@ function stringRef( ref, spec ) {
     { path: [ { id: ref, location: location() } ], location: location() };
 }
 
+// with spec.msgVariant: 'or-object'
 function refItem( item, spec ) {
   if (typeof item === 'string' && item)
     return { id: item, location: location() };
-  return object( item, spec );
+  if (item && typeof item === 'object' && !Array.isArray( item ))
+    return object( item, spec );
+  // use error message 'syntax-expecting-string' (string more likely than object):
+  return string( item, spec );
 }
 
 function asScope( scope, spec, xsn ) {
@@ -1143,8 +1179,8 @@ function boolOrNull( val, spec ) {
 function string( val, spec ) {
   if (typeof val === 'string' && val)
     return val;
-  error( 'syntax-expecting-string', location(true), { prop: spec.msgProp },
-         'Expecting non-empty string for property $(PROP)' );
+  error( 'syntax-expecting-string', location(true),
+         { '#': spec.msgVariant, prop: spec.msgProp } );
   return ignore( val );
 }
 
@@ -1175,14 +1211,12 @@ function natnum( val, spec ) {
     //  XSN TODO: do not require literal
     return { val, literal: 'number', location: location() };
   const loc = location(true);
-  if (spec.msgId)
-    error( spec.msgId, loc, { prop: spec.msgProp } );
-  else
-    error( 'syntax-expecting-unsigned-int', loc, { '#': 'csn', prop: spec.msgProp } );
+  error( 'syntax-expecting-unsigned-int', loc,
+         { '#': spec.msgVariant || 'csn', prop: spec.msgProp, op: '*' } );
   return ignore( val );
 }
 
-// Use with spec.msgId !
+// Use with spec.msgVariant !
 function natnumOrStar( val, spec ) {
   return (val === '*')
     ? { val, literal: 'string', location: location() }
@@ -1196,7 +1230,14 @@ function symbol( id, spec, xsn ) { // for CSN property '#'
   xsn.sym = { id, location: location() };
 }
 
-// returns: false = no "...", true = "..." without UP TO, 'upTo' = "..." with UP TO
+/**
+ * returns:
+ *  - false = no "...",
+ *  - true = "..." without UP TO,
+ *  - 'upTo' = "..." with UP TO
+ *
+ * @returns {string|boolean}
+ */
 function isEllipsis( val ) {
   return val && typeof val === 'object' && '...' in val && Object.keys(val).length === 1 &&
     (val['...'] === true || 'upTo');
@@ -1244,12 +1285,11 @@ function annoValue( val, spec ) {
   }
   if (typeof val['#'] === 'string') {
     if (Object.keys( val ).length === 1) {
-      virtualLine += 2;
-      return {
-        sym: { id: val['#'], location: location() },
-        literal: 'enum',
-        location: location(),
-      };
+      ++virtualLine;
+      const xsn = { location: location() };
+      symbol( val['#'], schema['#'], xsn );
+      ++virtualLine;
+      return xsn;
     }
   }
   else if (typeof val['='] === 'string') {
@@ -1287,7 +1327,7 @@ function annotation( val, spec, xsn, csn, name ) {
   const absolute = (xsn ? name.substring(1) : name);
   // TODO: really care about variant (qualifier parts)?
   const variantIndex = absolute.indexOf('#') + 1 || absolute.length;
-  const n = refSplit( absolute.substring( 0, variantIndex ), spec.msgProp );
+  const n = refSplit( absolute.substring( 0, variantIndex ), !xsn && '{}' );
   if (!n)
     return undefined;
   n.absolute = absolute;
@@ -1300,35 +1340,50 @@ function annotation( val, spec, xsn, csn, name ) {
 
 // Expressions, conditions (std signature) -----------------------------------
 
-function value( val, spec, xsn ) { // for CSN property 'val'
-  if ((val == null) ? val === null : typeof val !== 'object') {
-    if (!xsn.literal) // might be overwritten; only set if literal type is valid
-      xsn.literal = (val === null) ? 'null' : typeof val;
-    return val;
+function value( val, spec, xsn, csn ) { // for CSN property 'val'
+  if (val && typeof val === 'object') {
+    error( 'syntax-expecting-scalar', location(true), { prop: spec.msgProp },
+           'Expecting scalar values for property $(PROP)' );
+    return ignore( val );
   }
-  error( 'syntax-expecting-scalar', location(true), { prop: spec.msgProp },
-         'Only scalar values are supported for property $(PROP)' );
-  return ignore( val );
+  if (!xsn.literal) // might be overwritten; only set if literal type is valid
+    xsn.literal = (val === null) ? 'null' : typeof val;
+
+  const valType = (val == null) ? val === null && 'null' : typeof val;
+  const pattern = typeof csn.literal === 'string' && quotedLiteralPatterns[csn.literal];
+  if (pattern && valType &&
+      (valType === pattern.json_type || valType === pattern.secondary_json_type)) {
+    if (pattern.test_fn && !pattern.test_fn( val )) {
+      warning( 'syntax-invalid-literal', location(),
+               { '#': pattern.test_variant, prop: spec.msgProp } );
+    }
+    if (pattern.unexpected_char && pattern.unexpected_char.test( val ))
+      warning( 'syntax-invalid-literal', location(), { '#': pattern.unexpected_variant } );
+  }
+  return val;
 }
 
 function literal( lit, spec, xsn, csn ) {
-  // TODO: general: requires other property (here: 'val')
-  if (!string( lit ))
+  if (!string( lit, spec ))
     return undefined;
-  const type = (csn.val == null) ? 'null' : typeof csn.val;
-  if (lit === type)            // also for 'object' which is an error for 'val'
-    return lit;
-  const p = quotedLiteralPatterns[lit];
-  if (p?.json_type === type) {
-    // TODO: wrong position, we complain about the format here, that is in 'val',
-    // TODO: make it then also more CSN-specific?  Next change
-    if (p && p.test_fn && !p.test_fn(csn.val))
-      warning( 'syntax-invalid-literal', location(), { '#': p.test_variant } );
-    return lit;
+  const valType = (csn.val == null) ? csn.val === null && 'null' : typeof csn.val;
+  const pattern = quotedLiteralPatterns[lit];
+  if (!pattern) {
+    error( 'syntax-invalid-string', location(true), { prop: spec.msgProp } );
+  }
+  else if (valType &&
+           valType !== pattern.json_type && valType !== pattern.secondary_json_type) {
+    warning( 'syntax-invalid-literal', location(), {
+      // 'literal' value can be different to 'string' with JSON string type:
+      '#': (valType === 'string') ? 'typeof' : 'expecting',
+      otherprop: 'val',
+      rawvalue: lit,
+      op: valType,
+    } );
   }
-  if (lit === 'number' && type === 'string') // special case, not a quoted literal in CDL
+  else {
     return lit;
-  error( 'syntax-invalid-string', location(true), { prop: spec.msgProp } );
+  }
   return ignore( lit );
 }
 
@@ -1430,6 +1485,7 @@ function expr( e, spec ) {
   return object( e, spec );
 }
 
+// with spec.msgVariant: 'or-string'
 function exprOrString( val, spec ) {
   return (typeof val === 'string' && !csnVersionZero)
     ? { val, literal: 'token', location: location() }
@@ -1555,8 +1611,8 @@ function translations( keyVal, spec, xsn, csn, textKey ) {
 function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
   const p0 = schema[prop] ? prop : prop.charAt(0);
   const s = (parentSpec.schema || schema)[p0];
-  if (!s || s.noPrefix && prop !== p0 ) {
-    if (!ourpropsRegex.test( prop ))
+  if (!s || s.noPrefix === (prop !== p0) ) {
+    if (prop && !ourpropsRegex.test( prop ))
       return { prop, type: extra };
     // TODO v4: No warning with --sloppy
     warning( 'syntax-unknown-property', location(true), { prop },
@@ -1594,7 +1650,8 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
              kind,
            } );
   }
-  else if (checkAndSetXorGroup( s.xorGroup, s.xorException, prop, xor )) {
+  else if (checkAndSetXorGroup( s.xorGroup, s.xorException, prop, xor ) &&
+           checkAndSetXorGroup( s.xorGroupTwo, s.xorException, prop, xor ) ) {
     onlyWith( s, s.onlyWith, csn, prop, xor, expected );
     return s;
   }
@@ -1697,26 +1754,22 @@ function isObject( obj, spec ) {
   if (obj && typeof obj === 'object' && !Array.isArray( obj ))
     return obj;
   const loc = location(true);
-  if (spec.msgId)
-    error( spec.msgId, loc, { prop: spec.msgProp });
-  else
-    error( 'syntax-expecting-object', loc, { prop: spec.msgProp });
+  error( 'syntax-expecting-object', loc,
+         { '#': spec.msgVariant || 'std', prop: spec.msgProp, op: '*' });
   return ignore( obj );
 }
 
 function refSplit( name, prop ) {
   const path = name.split('.');
-  if (!path.every( id => id)) {
-    warning( 'syntax-expecting-name', location(true), { prop }, // TODO: re-check
-             'Expecting correct name for property $(PROP)' );
-  }
+  if (prop && (prop === '{}' || prop === '#' ? !name : !path.every( id => id)))
+    message( 'syntax-invalid-name', location(true), { '#': prop, prop } );
   return { path: path.map( id => ({ id, location: location() }) ), location: location() };
 }
 
-function replaceZeroValue( spec, msgid, otherprop ) {
+function replaceZeroValue( spec, msgVariant, otherprop ) {
   if (!csnVersionZero && !spec.vZeroFor) {
     warning( 'syntax-deprecated-value', location(true),
-             { '#': msgid, prop: spec.msgProp, otherprop } );
+             { '#': msgVariant, prop: spec.msgProp, otherprop } );
   }
 }