@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/inspect/inspectPropagation.js

@@ -4,7 +4,13 @@ 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');
+
+const inferredNiceOutput = {
+  '*': 'wildcard',
+  'aspect-composition': 'composition',
+  prop: 'propagation',
+  $generated: 'generated',
+};
 
 /**
  * @param {XSN.Model} xsn
@@ -77,29 +83,16 @@ function _inspectAnnotations( artifactXsn ) {
   for (const anno of annos) {
     const annoXsn = artifactXsn[anno];
     const loc = locationString(annoXsn.name.location);
+
     let origin;
-    switch (annoXsn.$priority) {
-      case false:
-        if (annoXsn.$inferred)
-          origin = 'propagation';
-        else
-          origin = 'direct';
-        break;
-
-      case 'extend':
-      case 'annotate':
-        origin = annoXsn.$priority;
-        break;
-
-      case undefined:
-        if (annoXsn.$inferred === '$generated') {
-          origin = 'generated';
-          break;
-        }
-        // fallthrough
-      default:
-        throw new CompilerAssertion(`inspect anno: Unhandled Case: ${ annoXsn.$priority }`);
-    }
+    if (annoXsn.$inferred === '$generated')
+      origin = 'generated';
+    else if (annoXsn.$inferred)
+      origin = inferredNiceOutput[annoXsn.$inferred] || annoXsn.$inferred;
+    else if (isContainedInParentLocation(annoXsn.name, artifactXsn))
+      origin = 'direct';
+    else
+      origin = 'annotate';      // ...or `extend`
 
     maxAnnoLength = Math.max(maxAnnoLength, anno.length);
 
@@ -122,11 +115,6 @@ function _inspectElements( artifactXsn ) {
   const result = [];
   const elements = Object.keys(artifactXsn.elements);
 
-  const inferredNiceOutput = {
-    '*': 'wildcard',
-    'aspect-composition': 'composition',
-  };
-
   let maxElemLength = 12;
   let maxOriginLength = 6;
 
@@ -153,7 +141,7 @@ function _inspectElements( artifactXsn ) {
         origin = elementXsn.$inferred;
     }
     else if (!isContainedInParentLocation(elementXsn, artifactXsn)) {
-      // just a heuristic
+      // just a heuristic - a good enough one
       origin = 'extend';
     }
     else {
@@ -192,11 +180,9 @@ function isContainedInParentLocation( art, parent ) {
   const parentLoc = parent.location;
   if (artLoc.file !== parentLoc.file)
     return false;
-  if (artLoc.line < parentLoc.line || artLoc.line > parentLoc.endLine)
-    return false;
-  // Good enough for now
-  // TODO: Check columns
-  return true;
+  const startDiff = artLoc.line - parentLoc.line || artLoc.col - parentLoc.col;
+  const endDiff = artLoc.endLine - parentLoc.endLine || artLoc.endCol - parentLoc.endCol;
+  return startDiff >= 0 && endDiff <= 0;
 }
 
 module.exports = {

package/lib/json/from-csn.js

@@ -62,8 +62,8 @@
  * @property {number}           [minLength] Minimum number of elements that an array must have.
  * @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
+ * @property {string[]}         [xorGroups] Corresponding xor groups. It references a value of
+ *                                          xorGroups. If set then only one property 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
@@ -75,6 +75,8 @@
  *                                          it.
  * @property {string}        [xorException] A property name that is allowed besides another property
  *                                          of an xorGroup (as an exception to the rule).
+ * @property {boolean}        [ignoreExtra] Whether extra properties are ignored and not put
+ *                                          into $extra.
  */
 
 /**
@@ -90,6 +92,7 @@
 const { dictAdd } = require('../base/dictionaries');
 const { quotedLiteralPatterns } = require('../compiler/builtins');
 const { CompilerAssertion } = require('../base/error');
+const { isBetaEnabled } = require('../base/model');
 
 const $location = Symbol.for('cds.$location');
 
@@ -121,7 +124,8 @@ 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'
+  ],
+  ':col': [ 'expand', '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`?
@@ -162,10 +166,15 @@ const schemaClasses = {
       xpr: {
         class: 'condition',
         type: xprInValue,
-        xorException: 'func',   // see xorGroup :expr
+        xorException: 'func', // see xorGroup :expr; for window functions
         inKind: [ '$column' ],
         inValue: true,
       },
+      '=': {
+        // by not setting `vZeroFor`, we disallow `=` in `columns`.
+        // CSN v0.1 didn't have columns, so this isn't breaking v0.1 compatibility.
+        type: ignore,
+      },
     },
   },
 };
@@ -252,12 +261,10 @@ 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
   },
@@ -298,10 +305,20 @@ const schema = compileSchema( {
   },
   // type properties (except: elements, enum, keys, on): ---------------------
   type: {
-    type: artifactRef,
+    type: typeArtifactRef,
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
     optional: [ 'ref', 'global' ],
     inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation', 'extend' ],
+    schema: {
+      ref: {
+        arrayOf: typeRefItem,
+        type: renameTo( 'path', typeRef ),
+        minLength: 1,
+        requires: 'id',
+        optional: [ 'id' ],
+        ignoreExtra: true, // custom properties inside `ref` ignored.
+      },
+    },
   },
   targetAspect: {
     type: artifactRef,
@@ -424,6 +441,7 @@ const schema = compileSchema( {
   list: {
     class: 'condition',
     type: list,
+    inKind: [ '$column' ],
   },
   val: {
     type: value,
@@ -592,6 +610,19 @@ const schema = compileSchema( {
     prop: '@‹anno›',            // which property name do messages use for annotation assignments?
     type: annotation,
     inKind: () => true,         // allowed in all definitions (including columns and extensions)
+    schema: {
+      '-expr': { // '-expr' and '-' must not exist top-level
+        prop: '@‹anno›',
+        type: object,
+        optional: [ '=', '#', 'xpr', 'ref', 'val', 'list', 'literal', 'func', 'args' ],
+        schema: {
+          '=': {
+            type: renameTo( '$tokenTexts', string ),
+            xorGroups: null, // reset xorGroup; allow '=' for all :expr
+          },
+        },
+      },
+    },
   },
   abstract: {                   // v1: with 'abstract', an entity becomes an aspect
     type: abstract,
@@ -607,7 +638,7 @@ const schema = compileSchema( {
   },
   notNull: {
     type: boolOrNull,
-    inKind: [ 'element', 'param' ], // TODO: $column  - or if so: in 'cast'?
+    inKind: [ 'element', 'param', 'type' ], // TODO: $column  - or if so: in 'cast'?
   },
   virtual: {
     type: boolOrNull,
@@ -620,7 +651,7 @@ const schema = compileSchema( {
     // 2. Inside "xpr"     => inside expressions
     // Because of (1) we have to set this property to false.
     inValue: false,
-    optional: typeProperties,
+    optional: typeProperties, // TODO: only in CDL-style cast, otherwise just length,…
     inKind: [ '$column' ],
   },
   default: {
@@ -731,6 +762,8 @@ let virtualLine = 1;
 /** @type {CSN.Location[]} */
 let dollarLocations = [];
 let arrayLevelCount = 0;
+/** @type {CSN.Options} */
+let userOptions = null; // must be reset!
 
 /**
  * @param {Object.<string, SchemaSpec>} specs
@@ -763,12 +796,15 @@ function compileSchema( specs, proto = null ) {
       else
         throw new CompilerAssertion( `Missing type specification for property "${ p }"` );
     }
-  }
-  // Set property 'xorGroup' in main and sub schema:
-  for (const group in xorGroups) {
-    for (const prop of xorGroups[group]) {
-      if (r[prop].xorGroup === undefined)
-        r[prop].xorGroup = group;
+
+    if (s.xorGroups === undefined) {
+      // Only set xorGroup once. Could already be set through shared sub-schema
+      // of schemaClasses or be explicitly set.
+      s.xorGroups = [];
+      for (const group in xorGroups) {
+        if (xorGroups[group].includes(p))
+          s.xorGroups.push(group);
+      }
     }
   }
   if (proto)
@@ -1110,6 +1146,14 @@ function validKind( val, spec, xsn ) {
   return ignore( val );
 }
 
+function typeArtifactRef( ref, spec ) {
+  if (ref && typeof ref === 'object' && !Array.isArray( ref )) {
+    if (ref.ref?.length === 1)
+      return artifactRef( ref, { ...spec, ignoreExtra: true } );
+  }
+  return artifactRef( ref, spec );
+}
+
 // Use with spec.msgVariant: 'or-object'
 function artifactRef( ref, spec ) {
   if (!ref || typeof ref !== 'string') {
@@ -1230,6 +1274,32 @@ function symbol( id, spec, xsn ) { // for CSN property '#'
   xsn.sym = { id, location: location() };
 }
 
+/**
+ * Wrapper around the default `ref` spec: Don't allow references of length 1 for types.
+ */
+function typeRef( val, spec, xsn, csn ) {
+  // e.g. { ref: [ 'T' ] }
+  if (Array.isArray(val) && val.length <= 1)
+    warning( 'syntax-deprecated-type-ref', location(true), { '#': 'std', prop: 'type' });
+
+  return arrayOf(spec.arrayOf)(val, spec, xsn, csn);
+}
+
+/**
+ * Similar to refItem(), but warns that the item should be a string if `id` is the only CSN
+ * property inside the ref-item.
+ */
+function typeRefItem( val, spec, xsn, csn ) {
+  // e.g. [ 'T', { id: 'elem', other_prop: true } ]
+  // avoid duplicate messages for single-item reference, see typeRef()
+  if (val && csn.ref?.length > 1 && typeof val === 'object' && val.id) {
+    const ownKeysCount = Object.keys(val).filter(key => ourpropsRegex.test(key)).length;
+    if (ownKeysCount === 1)
+      warning('syntax-deprecated-type-ref', location(true), { '#': 'ref-item', prop: 'ref[]' });
+  }
+  return refItem(val, spec);
+}
+
 /**
  * returns:
  *  - false = no "...",
@@ -1283,21 +1353,28 @@ function annoValue( val, spec ) {
     }
     return retval;
   }
-  if (typeof val['#'] === 'string') {
-    if (Object.keys( val ).length === 1) {
+  else if (typeof val['='] === 'string') {
+    const valKeys = Object.keys(val);
+    if (valKeys.length > 1 && isBetaEnabled(userOptions, 'annotationExpressions')) {
+      const s = schema['@'].schema['-expr'];
+      const r = { location: location() };
+      Object.assign(r, object(val, s));
+      return r;
+    }
+    else if (valKeys.length === 1) {
       ++virtualLine;
-      const xsn = { location: location() };
-      symbol( val['#'], schema['#'], xsn );
+      const r = refSplit( val['='], '=' );
       ++virtualLine;
-      return xsn;
+      return r;
     }
   }
-  else if (typeof val['='] === 'string') {
+  if (typeof val['#'] === 'string') {
     if (Object.keys( val ).length === 1) {
       ++virtualLine;
-      const r = refSplit( val['='], '=' );
+      const xsn = { location: location() };
+      symbol( val['#'], schema['#'], xsn );
       ++virtualLine;
-      return r;
+      return xsn;
     }
   }
   else if (val['...'] && Object.keys( val ).length === 1) {
@@ -1314,13 +1391,13 @@ function annoValue( val, spec ) {
     ++virtualLine;
     return r;
   }
-  const struct = Object.create(null);
+  const r = { struct: Object.create(null), literal: 'struct', location: location() };
   ++virtualLine;
   for (const name of Object.keys( val )) {
-    struct[name] = annotation( val[name], schema['@'], null, val, name );
+    r.struct[name] = annotation( val[name], schema['@'], null, val, name );
     ++virtualLine;
   }
-  return { struct, literal: 'struct', location: location() };
+  return r;
 }
 
 function annotation( val, spec, xsn, csn, name ) {
@@ -1333,6 +1410,7 @@ function annotation( val, spec, xsn, csn, name ) {
   n.absolute = absolute;
   if (variantIndex < absolute.length)
     n.variant = { id: name.substring( variantIndex ), location: location() };
+
   const r = annoValue( val, spec );
   r.name = n;
   return r;
@@ -1612,8 +1690,11 @@ 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 (prop && !ourpropsRegex.test( prop ))
+    if (prop && !ourpropsRegex.test( prop )) {
+      if (parentSpec.ignoreExtra)
+        return { prop, type: ignore };
       return { prop, type: extra };
+    }
     // TODO v4: No warning with --sloppy
     warning( 'syntax-unknown-property', location(true), { prop },
              'Unknown CSN property $(PROP)' );
@@ -1628,10 +1709,10 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
     }
     const zero = s.vZeroFor;
     if (zero) {                 // (potential) CSN v0.1.0 property
-      const group = s.xorGroup;
-      if (expected( zero, schema[zero] ) && !(group && xor[group])) {
+      const groups = s.xorGroups;
+      if (expected( zero, schema[zero] ) && !(groups.length && groups.every(group => xor[group]))) {
         replaceZeroProp( prop, zero );
-        if (group)
+        for (const group of groups)
           xor[group] = prop;
         onlyWith( s, s.onlyWith, csn, prop, xor, expected );
         return s;
@@ -1650,8 +1731,8 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
              kind,
            } );
   }
-  else if (checkAndSetXorGroup( s.xorGroup, s.xorException, prop, xor ) &&
-           checkAndSetXorGroup( s.xorGroupTwo, s.xorException, prop, xor ) ) {
+  else if (checkAndSetXorGroup( s.xorGroups, s.xorException, prop, xor )) {
+    // TODO: If all targets of onlyWith are xor-excluded/ignore, also exclude/ignore this one.
     onlyWith( s, s.onlyWith, csn, prop, xor, expected );
     return s;
   }
@@ -1693,7 +1774,7 @@ function onlyWith( spec, need, csn, prop, xor, expected ) {
     const allowed = need.filter( p => expected( p, spec ));
     // There should be at least one elem, otherwise the spec is wrong;
     // first try to find element which is not excluded
-    need = allowed.find( p => !xor[schema[p].xorGroup] ) || allowed[0];
+    need = allowed.find( p => !schema[p].xorGroups?.some(g => xor[g]) ) || allowed[0];
   }
   if (prop) {
     error( 'syntax-missing-property', location(true), // location at $(PROP)
@@ -1713,18 +1794,31 @@ function onlyWith( spec, need, csn, prop, xor, expected ) {
   return spec;
 }
 
-function checkAndSetXorGroup( group, exception, prop, xor ) {
-  if (!group)
-    return true;
-  const siblingprop = xor[group];
-  if (!siblingprop) {
-    xor[group] = prop;
-    return true;
-  }
-  if (siblingprop === exception)
+/**
+ * @param {string[]} groups
+ * @param {string} exception
+ * @param {string} prop
+ * @param {object} xor
+ * @return {boolean}
+ */
+function checkAndSetXorGroup( groups, exception, prop, xor ) {
+  if (!groups || groups.length === 0)
     return true;
-  error( 'syntax-unexpected-property', location(true), { '#': 'sibling', prop, siblingprop } );
-  return false;
+  let silent = false;
+  return groups.every((group) => {
+    const siblingprop = xor[group];
+    if (!siblingprop) {
+      xor[group] = prop;
+      return true;
+    }
+    if (siblingprop === exception)
+      return true;
+    if (!silent) {
+      error( 'syntax-unexpected-property', location(true), { '#': 'sibling', prop, siblingprop } );
+      silent = true;
+    }
+    return false;
+  });
 }
 
 function implicitName( ref ) {
@@ -1824,6 +1918,7 @@ function popLocation( obj ) {
 function resetHeapModuleVars() {
   vocabInDefinitions = null;
   dollarLocations = [];
+  userOptions = null;
   message = () => undefined;
   error = () => undefined;
   warning = () => undefined;
@@ -1848,6 +1943,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
   arrayLevelCount = 0;
   inExtensions = null;
   vocabInDefinitions = null;
+  userOptions = options;
 
   const xsn = { $frontend: 'json' };