@sap/cds-compiler 3.6.2 → 3.7.2

package/lib/inspect/inspectPropagation.js

@@ -192,6 +192,8 @@ function isContainedInParentLocation( art, parent ) {
   const parentLoc = parent.location;
   if (artLoc.file !== parentLoc.file)
     return false;
+  // Warning is correct, but we have a "TODO" below.
+  // eslint-disable-next-line sonarjs/prefer-single-boolean-return
   if (artLoc.line < parentLoc.line || artLoc.line > parentLoc.endLine)
     return false;
   // Good enough for now

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
@@ -90,6 +90,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 +122,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 +164,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 +259,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
   },
@@ -592,6 +597,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: ignore,
+            xorGroups: null, // reset xorGroup; allow '=' for all :expr
+          },
+        },
+      },
+    },
   },
   abstract: {                   // v1: with 'abstract', an entity becomes an aspect
     type: abstract,
@@ -620,7 +638,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 +749,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 +783,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)
@@ -1283,21 +1306,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() };
+      r.value = 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 +1344,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 +1363,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;
@@ -1628,10 +1659,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 +1681,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 +1724,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 +1744,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 +1868,7 @@ function popLocation( obj ) {
 function resetHeapModuleVars() {
   vocabInDefinitions = null;
   dollarLocations = [];
+  userOptions = null;
   message = () => undefined;
   error = () => undefined;
   warning = () => undefined;
@@ -1848,6 +1893,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
   arrayLevelCount = 0;
   inExtensions = null;
   vocabInDefinitions = null;
+  userOptions = options;
 
   const xsn = { $frontend: 'json' };
 

package/lib/json/to-csn.js

@@ -55,7 +55,7 @@ const transformers = {
   kind,
   id: n => n,                   // in path item
   doc: value,
-  '@': value,
+  '@': anno,
   virtual: value,
   key: value,
   unique: value,
@@ -73,6 +73,17 @@ const transformers = {
   // type properties (without 'elements') ------------------------------------
   localized: value,
   type,
+  $typeArgs: (node, csn, xsn) => {
+    const typeArgs = xsn.$typeArgs;
+    // One or two arguments are interpreted as either length or precision/scale.
+    if (typeArgs?.length === 1) {
+      csn.length = value(typeArgs[0]);
+    }
+    else if (typeArgs?.length === 2) {
+      csn.precision = value(typeArgs[0]);
+      csn.scale = value(typeArgs[1]);
+    }
+  },
   length: value,
   precision: value,
   scale: value,
@@ -190,6 +201,7 @@ const typeProperties = [
   'cardinality', // for association publishing in views
   'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
+  '$typeArgs', // for unresolved type arguments, e.g. through parseCql
 ];
 
 const csnDictionaries = [
@@ -243,6 +255,12 @@ function sortCsn( csn, cloneOptions = false ) {
       setHidden( r, 'elements', csnDictionary( csn.elements, false, cloneOptions ) );
     if (hasNonEnumerable( csn, '$tableConstraints' ) && !r.$tableConstraints)
       setHidden( r, '$tableConstraints', csn.$tableConstraints );
+    if (cloneOptions.hiddenPropertiesToClone) {
+      cloneOptions.hiddenPropertiesToClone.forEach((property) => {
+        if ({}.hasOwnProperty.call( csn, property )) // used in generic reference flattener
+          setHidden( r, property, csn[property] );
+      });
+    }
   }
   return r;
 }
@@ -812,12 +830,12 @@ function foreignKeys( dict, csn, node ) {
     csn.keys.push( definition( dict[n] ) );
 }
 
-function returns( art, csn, _node, prop ) {
+function returns( art, csn, node, prop ) {
   // TODO: currently, the `returns` structure might just have been created by the propagator
   // if that is the case, there should be no reason to store it in universal CSN
-  if (universalCsn && art.$inferred === 'proxy')
+  if (universalCsn && (art.$inferred === 'proxy' || node.$expand === 'origin'))
     return undefined;
-  return definition( art, csn, _node, prop );
+  return definition( art, csn, node, prop );
 }
 
 function definition( art, _csn, _node, prop ) {
@@ -872,10 +890,10 @@ function includesOrigin( includes, art ) {
     for (const prop in aspect) {
       if ((prop.charAt(0) === '@' || prop === 'doc') &&
           (!art[prop] || art[prop].$inferred)) {
-        const anno = aspect[prop];
-        if (anno.val !== null)
-          // matererialize non-null annos (whether direct or inherited)
-          result[prop] = value( Object.create( anno, { $inferred: { value: null } } ) );
+        const annoVal = aspect[prop];
+        if (annoVal.val !== null)
+          // materialize non-null annos (whether direct or inherited)
+          result[prop] = value( Object.create( annoVal, { $inferred: { value: null } } ) );
       }
     }
   }
@@ -926,14 +944,20 @@ function addOrigin( csn, xsn, node ) {
     return;
   }
   // from here on: member:
+  // TODO: write a xsnNode._csnOrigin, which is useful to decide whether to write
+  // $origins for its members
   const parent = getParent( xsn );
   const parentOrigin = getOrigin( parent );
+  // console.log( 'X:',xsn, origin, parent, parentOrigin, getParent( origin ) );
   if (!origin) {
-    if (parentOrigin && !(parent.enum && !parent.$origin && parent.type))
+    if (parent && parentOrigin &&
+        (parent.kind !== 'select' || parent === parent._main._leadingQuery) &&
+        !(parent.enum && !parent.$origin && parent.type))
       csn.$origin = null;
     return;
   }
-  if (parentOrigin === getParent( origin )) {
+  if (parent?.kind !== 'select' && parentOrigin?.kind !== 'select' &&
+      parentOrigin === getParent( origin )) {
     // implicit prototype or shortened reference
     const { id } = origin.name || {};
     if (id && xsn.name && id !== xsn.name.id)
@@ -1034,13 +1058,13 @@ function getOrigin( art ) {
   if (art.$noOrigin)
     return undefined;
   const { _origin } = art;
-  if (_origin)
-    return (_origin.kind === 'builtin') ? undefined : _origin; // not $dollarVariable
+  if (_origin)                  // also for query entities
+    return (_origin.kind === 'builtin') ? undefined : _origin;
+
   if (hasExplicitProp( art.type, 'cast' ))
     return art.type._artifact;
-  if (art._from)
-    return art._from[0]._origin;
-  // must come after _from, since queries can have includes as well.
+  // must come after checking _origin, since entities can have both queries and
+  // includes as well -> the query wins
   if (art.includes)
     return art.includes[0]._artifact;
   return undefined;
@@ -1230,6 +1254,13 @@ function args( node ) {
   return dict;
 }
 
+function anno( node ) {
+  if (node.value) // expressions in annotation values
+    // TODO: actual string representation and not placeholder "42"
+    return Object.assign({ '=': '42' }, expression( node.value ));
+  return value(node);
+}
+
 function value( node ) {
 // "Short" value form, e.g. for annotation assignments
   if (!node)
@@ -1300,7 +1331,7 @@ function expression( node ) {
 function exprInternal( node, xprParens ) {
   if (typeof node === 'string')
     return node;
-  if (!node)                    // make to-csn robst
+  if (!node)                    // make to-csn robust
     return {};
   if (node.scope === 'param') {
     if (node.path)

package/lib/language/errorStrategy.js

@@ -101,6 +101,7 @@ Object.assign( KeywordErrorStrategy.prototype, {
 
 // Attempt to recover from problems in subrules, except if rule has defined a
 // local variable `_sync` with value 'nop'
+// TODO: consider performance - see #8800
 function sync( recognizer ) {
   // If already recovering, don't try to sync
   if (this.inErrorRecoveryMode(recognizer))

package/lib/language/genericAntlrParser.js

@@ -19,6 +19,7 @@ const {
 } = require('../compiler/builtins');
 const { pathName } = require('../compiler/utils');
 const { isBetaEnabled } = require('../base/model');
+const { weakLocation } = require('../base/messages');
 
 const $location = Symbol.for('cds.$location');
 
@@ -73,6 +74,7 @@ Object.assign(GenericAntlrParser.prototype, {
   info(...args) {
     return _message( this, 'info', ...args );
   },
+  isBetaEnabled,
   attachLocation,
   assignAnnotation,
   addAnnotation,
@@ -96,6 +98,7 @@ Object.assign(GenericAntlrParser.prototype, {
   pushXprToken,
   argsExpression,
   valuePathAst,
+  fixNewKeywordPlacement,
   signedExpression,
   numberLiteral,
   quotedLiteral,
@@ -120,6 +123,7 @@ Object.assign(GenericAntlrParser.prototype, {
   associationInSelectItem,
   reportExpandInline,
   checkTypeFacet,
+  checkTypeArgs,
   csnParseOnly,
   noAssignmentInSameLine,
   noSemicolonHere,
@@ -361,15 +365,12 @@ function assignAnnotation( art, anno, prefix = '' ) {
 }
 
 function addAnnotation( art, prop, anno ) {
-  // TODO: just overwrite after having reported the error
-  dictAddArray( art, prop, anno, (n, location, a) => {
-    // if we would make it a warning, we would still need to keep it an error
-    // with '...'; otherwise parse.cdl would have to split annotate statements
-    this.error( 'syntax-duplicate-anno', [ location ], { anno: n },
-                'Duplicate assignment with $(ANNO)' );
-    a.$errorReported = 'syntax-duplicate-anno';
-    // do not report again later as anno-duplicate-xyz
-  } );
+  const old = art[prop];
+  if (old) {
+    this.error( 'syntax-duplicate-anno', old.name.location, { anno: prop },
+                'Assignment for $(ANNO) is overwritten by another one below' );
+  }
+  art[prop] = anno;
 }
 
 const extensionDicts = {
@@ -652,7 +653,7 @@ function fragileAlias( ast, safe = false ) {
   return ast;
 }
 
-// Return AST for identifier token `token`.  Also check that identifer is not empty.
+// Return AST for identifier token `token`.  Also check that identifier is not empty.
 function identAst( token, category, noTokenTypeCheck = false ) {
   token.isIdentifier = category;
   let id = token.text;
@@ -713,37 +714,107 @@ function pushXprToken( args ) {
 }
 
 function valuePathAst( ref ) {
-  // TODO: XSN representation of functions is a bit strange - rework if methods
-  // are introduced
+  // TODO: XSN representation of functions is a bit strange - rework
   const { path } = ref;
   if (!path || path.broken)
     return ref;
   if (path.length !== 1) {
     const item = path.find( i => i.args && i.$syntax !== ':' );
-    if (!item)
+    if (!item) // also covers empty paths
       return ref;
-    this.error( 'syntax-unsupported-method', item.location, {},
-                'Methods in expressions are not supported yet' );
-    path.broken = true;
-    path.length = 1;
   }
-  const { args, id, location } = path[0];
-  if (args
+  else if (path.length === 1) {
+    const { args, id, location } = path[0];
+    if (args
       ? path[0].$syntax === ':'
       : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
-    return ref;
+      return ref;
+
+    const implicit = this.previousTokenAtLocation( location );
+    if (implicit && implicit.isIdentifier)
+      implicit.isIdentifier = 'func';
+    const op = { location, val: 'call' };
+    return (args)
+      ? {
+        op, func: ref, location: ref.location, args,
+      }
+      : { op, func: ref, location: ref.location };
+  }
 
-  const implicit = this.previousTokenAtLocation( location );
-  if (implicit && implicit.isIdentifier)
-    implicit.isIdentifier = 'func';
-  const op = { location, val: 'call' };
-  return (args)
-    ? {
-      op, func: ref, location: ref.location, args,
+  // method call ---------------------------
+
+  const args = [];
+  const pathRest = [ ...path ];
+  let pathHead = pathRest.shift();
+
+  if (pathHead.args) {
+    args.push({
+      op: { location: pathHead.location, val: 'call' },
+      func: { path: [ pathHead ] },
+      location: pathHead.location,
+      args: pathHead.args || [],
+    });
+    pathHead = pathRest.shift();
+  }
+  else {
+    const refPath = [];
+    while (pathHead && !pathHead.args) {
+      refPath.push(pathHead);
+      pathHead = pathRest.shift();
     }
-    : { op, func: ref, location: ref.location };
+    args.push({ path: refPath, location: refPath[0].location });
+  }
+
+  if (pathHead?.args)
+    pathRest.unshift(pathHead);
+
+  for (const method of pathRest) {
+    args.push({
+      // TODO: Update parser to have proper location for `.`?
+      location: weakLocation(method.location),
+      val: '.',
+      literal: 'token',
+    });
+    const func = {
+      op: { location: method.location, val: 'call' },
+      func: { path: [ method ] },
+      location: method.location,
+    };
+    if (method.args)
+      func.args = method.args;
+    args.push(func);
+  }
+
+  return {
+    op: {
+      val: 'ixpr',
+      location: this.startLocation(),
+    },
+    args,
+    location: ref.location,
+  };
 }
 
+
+/**
+ * Adds the first argument of `args` ('new' keyword) to the second argument, if it's a method-ixpr.
+ *
+ * @todo Cleanup, remove.
+ * @param args
+ */
+function fixNewKeywordPlacement( args ) {
+  // TODO: Currently, the parser creates an args-array with `new` and an `ixpr` for
+  //      `new P().abc()`.  That is, "new" is separate from the methods.
+  //      This function tries to work around it, but its more of a hack.
+  if (args.length !== 2 || !args[1].args || args[1].op?.val !== 'ixpr')
+    return;
+  const ixpr = args[1];
+  ixpr.args.unshift(args[0]);
+  args.length = 0;
+  args.push(ixpr);
+}
+
+
 // If a '-' is directly before an unsigned number, consider it part of the number;
 // otherwise (including for '+'), represent it as extra unary prefix operator.
 function signedExpression( args, expr ) {
@@ -1174,4 +1245,14 @@ function checkTypeFacet( art, argIdent ) {
   return false;
 }
 
+function checkTypeArgs( art ) {
+  const args = art.$typeArgs;
+  // One or two arguments are interpreted as either length or precision/scale.
+  if (args.length > 2) {
+    const loc = args[2].location;
+    this.error( 'syntax-unexpected-argument', loc, {}, 'Too many type arguments' );
+    art.$typeArgs = undefined;
+  }
+}
+
 module.exports = GenericAntlrParser;