@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/json/to-csn.js

@@ -30,9 +30,9 @@ const normalizedKind = {
 let gensrcFlavor = true;       // good enough here...
 let universalCsn = false;
 let strictMode = false;        // whether to dump with unknown properties (in standard)
-let parensAsStrings = false;
 let projectionAsQuery = false;
 let withLocations = false;
+let structXpr = false;
 let dictionaryPrototype = null;
 
 // Properties for dictionaries, set in compileX() and TODO: parseX(), must be
@@ -93,7 +93,7 @@ const transformers = {
   where: condition,             // also pathItem after 'cardinality' before 'args'
   having: condition,
   args,                        // also pathItem after 'where', before 'on'/'orderBy'
-  suffix: node => [].concat( ...node.suffix.map( xprArg ) ),
+  suffix: ignore,              // handled in exprInternal()
   orderBy: arrayOf( orderBy ), // TODO XSN: make `sort` and `nulls` sibling properties
   sort: value,
   nulls: value,
@@ -191,41 +191,6 @@ const typeProperties = [
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
 ];
 
-const operators = {
-  // standard is: binary infix (and corresponding n-ary), unary prefix
-  isNot: [ 'is', 'not' ],       // TODO XSN: 'is not'
-  isNull: postfix( [ 'is', 'null' ] ),
-  isNotNull: postfix( [ 'is', 'not', 'null' ] ),
-  in: binaryRightParen( [ 'in' ] ),
-  notIn: binaryRightParen( [ 'not', 'in' ] ),
-  between: ternary( [ 'between' ], [ 'and' ] ),
-  notBetween: ternary( [ 'not', 'between' ], [ 'and' ] ),
-  like: ternary( [ 'like' ], [ 'escape' ] ),
-  notLike: ternary( [ 'not', 'like' ], [ 'escape' ] ),
-  when: exprs => [ 'when', ...exprs[0], 'then', ...exprs[1] ],
-  case: exprs => [ 'case' ].concat( ...exprs, [ 'end' ] ),
-  over: exprs => [ 'over', { xpr: [].concat( ...exprs ) } ],
-  orderBy: exprs => [ // ORDER BY in generic functions
-    ...exprs[0], ...operators.overOrderBy(exprs.slice(1)),
-  ],
-  overOrderBy: exprs => [ // ORDER BY in OVER() clause
-    'order', 'by', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
-  ],
-  partitionBy: exprs => [
-    'partition', 'by', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
-  ],
-  rows: exprs => [
-    'rows', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
-  ],
-  preceding: postfix( [ 'preceding' ] ),
-  unboundedPreceding: [ 'unbounded', 'preceding' ],
-  currentRow: [ 'current', 'row' ],
-  unboundedFollowing: [ 'unbounded', 'following' ],
-  following: postfix( [ 'following' ] ),
-  frameBetween: exprs => [ 'between', ...exprs[0], 'and', ...exprs[1] ],
-  ixpr: exprs => [].concat( ...exprs ), // xpr extra, due to extra parentheses
-};
-
 const csnDictionaries = [
   'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
 ];
@@ -281,7 +246,7 @@ function sortCsn( csn, cloneOptions = false ) {
   return r;
 }
 
-function cloneAnnotationValue(val) {
+function cloneAnnotationValue( val ) {
   if (typeof val !== 'object') // scalar
     return val;
   return JSON.parse( JSON.stringify( val ) );
@@ -296,7 +261,7 @@ function cloneAnnotationValue(val) {
  * @param {string} property
  * @returns
  */
-function hasNonEnumerable(object, property) {
+function hasNonEnumerable( object, property ) {
   return {}.hasOwnProperty.call( object, property ) &&
     !{}.propertyIsEnumerable.call( object, property );
 }
@@ -346,7 +311,7 @@ function compactModel( model, options = model.options || {} ) {
   for (const first in srcDict) {
     const { namespace } = srcDict[first];
     if (namespace && namespace.path)
-      csn.namespace = namespace.path.map( i => i.id ).join('.');
+      csn.namespace = pathName( namespace.path );
     break;
   }
   set( 'definitions', csn, model );
@@ -740,8 +705,11 @@ function annotationsAndDocComment( node ) {
     if (sub !== undefined)
       csn[prop] = sub;
   }
-  if (node.doc)
-    csn.doc = transformers.doc(node.doc);
+  if (node.doc) {
+    const doc = transformers.doc(node.doc);
+    if (doc !== undefined)
+      csn.doc = doc;
+  }
   return csn;
 }
 
@@ -829,21 +797,18 @@ function dictionary( dict, keys, prop ) {
 }
 
 function foreignKeys( dict, csn, node ) {
-  if (universalCsn) {
-    if (!target( node.target, csn, node ) || dict[$inferred] === 'keys')
-      return;
-  }
-  if (gensrcFlavor && node._origin && node._origin.$inferred === 'REDIRECTED')
-    dict = node._origin.foreignKeys;
-  const keys = [];
-  for (const n in dict) {
-    const d = definition( dict[n] );
-    if (d !== undefined)
-      keys.push( d );
-    else
+  if (universalCsn && dict[$inferred] === 'keys' || !target( node.target, csn, node ) )
+    return;
+
+  if (gensrcFlavor) {
+    if (node._origin?.$inferred === 'REDIRECTED')
+      dict = node._origin.foreignKeys;
+    if (dict[$inferred])
       return;
   }
-  csn.keys = keys;
+  csn.keys = [];
+  for (const n in dict)
+    csn.keys.push( definition( dict[n] ) );
 }
 
 function returns( art, csn, _node, prop ) {
@@ -1231,7 +1196,7 @@ function renderArtifactPath( node, path, terse, scope ) {
     const name = item._artifact && item._artifact.name;
     // In localization views, the _artifact link of `item` is important
     const id = name && name.absolute ||
-               path.slice( 0, scope ).map( i => i.id ).join('.');
+               pathName( path.slice( 0, scope ) );
     path = [ Object.assign( {}, item, { id } ), ...path.slice( scope ) ];
   }
   const ref = path.map( pathItem );
@@ -1255,7 +1220,7 @@ function args( node ) {
     return node.map( expression );
   const dict = Object.create( dictionaryPrototype );
   for (const param in node)
-    dict[param] = expression( node[param], true );
+    dict[param] = expression( node[param] );
   return dict;
 }
 
@@ -1298,7 +1263,7 @@ function enumValue( v, csn, node ) {
     return;
   // (with gensrc, the symbol itself would not make it into the CSN)
   if (node.kind === 'enum' || node._parent && node._parent.kind === 'extend')
-    Object.assign( csn, expression( v, true ) );
+    Object.assign( csn, expression( v ) );
 }
 
 
@@ -1313,128 +1278,89 @@ function onCondition( cond, csn, node ) {
 }
 
 function condition( node ) {
-  const expr = expression( node );
-  // we do not set a hidden $parens on array - we could still do it if requested
-  return !expr.cast && !expr.func && expr.xpr || [ expr ];
+  const expr = exprInternal( node, 'no' );
+  return (Array.isArray( expr ))
+    ? flattenenInternalXpr( expr )
+    : !expr.cast && !expr.func && expr.xpr || [ expr ];
+}
+
+function expression( node ) {
+  const expr = exprInternal( node, 'no' );
+  return (Array.isArray( expr ))
+    ? { xpr: flattenenInternalXpr( expr ) }
+    : expr;
 }
 
-function expression( node, dollarExtra ) {
-  const dollarExtraNode = dollarExtra !== 'ignoreExtra' && node;
+function exprInternal( node, xprParens ) {
   if (typeof node === 'string')
     return node;
   if (!node)                    // make to-csn robst
     return {};
   if (node.scope === 'param') {
     if (node.path)
-      return extra( { ref: node.path.map( pathItem ), param: true }, dollarExtraNode );
+      return extra( { ref: node.path.map( pathItem ), param: true }, node );
     return { ref: [ node.param.val ], param: true }; // CDL rule for runtimes
   }
   if (node.path) {
     const ref = node.path.map( pathItem );
-    if (node.path.$prefix)
+    if (node.path.$prefix)      // auto-corrected ORDER BY refs without table alias
       ref.unshift( node.path.$prefix );
     // we would need to consider node.global here if we introduce that
-    return extra( { ref }, dollarExtraNode );
+    return extra( { ref }, node );
   }
   if (node.literal) {
     if (typeof node.val === node.literal || node.val === null)
-      return extra( { val: node.val }, dollarExtraNode );
+      return extra( { val: node.val }, node );
     else if (node.literal === 'enum')
-      return extra( { '#': node.sym.id }, dollarExtraNode );
+      return extra( { '#': node.sym.id }, node );
     else if (node.literal === 'token')
       return node.val;          // * in COUNT(*)
-    return extra( { val: node.val, literal: node.literal }, dollarExtraNode );
+    return extra( { val: node.val, literal: node.literal }, node );
   }
   if (node.func) {              // TODO XSN: remove op: 'call', func is no path
     const call = { func: node.func.path[0].id };
-    if (node.args) {       // no args from CSN input for CURRENT_DATE etc
+    if (node.args)       // no args from CSN input for CURRENT_DATE etc
       call.args = args( node.args );
-      const arg0 = call.args[0];
-      const { quantifier } = node.func.path[0];
-      if (arg0 && quantifier) {
-        if (typeof arg0 !== 'object' || !arg0.xpr)
-          call.args[0] = { xpr: [ quantifier.val, arg0 ] };
-        else
-          arg0.xpr.unshift( quantifier.val );
-      }
-    }
     if (node.suffix)
-      call.xpr = [].concat( ...node.suffix.map( xprArg ) );
-    return extra( call, dollarExtraNode );
+      call.xpr = condition( { op: { val: 'ixpr' }, args: node.suffix } );
+    // remark: node.suffix.map( expression ) would add $parens: 1 for xpr after "over"
+    return extra( call, node );
   }
   if (node.query)
     return query( node.query, null, null, null, 1 );
   if (!node.op)                 // parse error
     return { xpr: [] };
-  else if (node.op.val === 'xpr')
-    // do not use xpr() for xpr, as it would flatten inner xpr's
-    return extra({ xpr: node.args.map( expression ) }, dollarExtraNode, 1 );
-  else if (node.op.val === 'cast')
-    return cast( expression( node.args[0] ), dollarExtraNode );
-  // from here on: CDL input (no $extra possible - but $parens)
-  else if (node.op.val !== ',')
-    return extra( { xpr: xpr( node ) }, dollarExtraNode, (dollarExtra === 'sub-xpr' ? 1 : 0) );
-  return (parensAsStrings)
-    ? { xpr: [ '(', ...xpr( node ), ')' ] }
-    // the inner parens belong to the tuple construct, i.e. won't count as parens
-    : extra( { list: node.args.map( expression ) }, dollarExtraNode, 0 );
-}
-
-function xpr( node ) {
-  // if (!node.op) console.log(node)
-  const op = operators[node.op.val] || node.op.val.split(' ');
-  const exprs = node.args.map( xprArg );
-  if (op instanceof Function)
-    return op( exprs );
-  if (node.quantifier)
-    op.push( node.quantifier.val );
-  if (exprs.length < 2)
-    return [ ...op, ...exprs[0] || [] ];
-  return exprs[0].concat( ...exprs.slice(1).map( a => [ ...op, ...a ] ) );
-}
-
-function xprArg( sub ) {
-  const realXpr = sub.op && sub.op.val === 'xpr';
-  const expr = expression( sub, 'sub-xpr' );
-  // `sort`/`nulls` will be attached to arguments of orderBy
-  // which might be either `path`s or `xpr`s
-  const sortAndNulls = [];
-  if (sub.sort)
-    sortAndNulls.push( sub.sort.val );
-  if (sub.nulls)
-    sortAndNulls.push( ...[ 'nulls', sub.nulls.val ] );
-  // return !sub.$parens && !expr.cast && !expr.func && expr.xpr || [ expr ];
-  // if parensAsStrings is gone
-  if (realXpr || expr.cast || expr.func || !expr.xpr || sub.$parens && !parensAsStrings)
-    return [ expr, ...sortAndNulls ];
-  else if (sub.$parens && sub.op.val !== ',')
-    return [ '(', ...expr.xpr, ')' ];
-
-  expr.xpr.push( ...sortAndNulls );
-  return expr.xpr;
-}
-
-function ternary( op1, op2 ) {
-  return function ternaryOp( exprs ) {
-    return (exprs[2])
-      ? [ ...exprs[0], ...op1, ...exprs[1], ...op2, ...exprs[2] ]
-      : [ ...exprs[0], ...op1, ...exprs[1] ];
-  };
-}
 
-function postfix( op ) {
-  return function postfixOp( exprs ) {
-    return [ ...exprs[0], ...op ];
-  };
+  const { val } = node.op;
+  switch (val) {
+    case 'ixpr':
+    case 'xpr':
+      break;
+    case 'cast':
+      return cast( expression( node.args[0] ), node );
+    case 'list':
+      return extra( { list: node.args.map( expression ) }, node, 0 );
+    default: {          // '=', 'and', CSN v0 input: binary (n-ary) and unary prefix
+      if (!node.args.length)
+        return { xpr: [] };
+      const nary = [];
+      for (const item of node.args)
+        nary.push( { val, literal: 'token' }, item );
+      node = {
+        op: { val: 'ixpr' },
+        args: (nary.length > 2 ? nary.slice(1) : nary),
+        $parens: node.$parens,
+      };
+    }
+  }
+  const rargs = node.args.map( exprInternal );
+  if (val === 'xpr' || node.$parens)
+    return extra( { xpr: flattenenInternalXpr( rargs ) }, node, (xprParens === 'no' ? 0 : 1) );
+  return rargs.length === 1 ? rargs[0] : rargs;
 }
 
-function binaryRightParen( op ) {
-  return ( exprs ) => {
-    const right = exprs[1].length === 1 ? exprs[1][0] : {};
-    return (right.xpr || right.list || !right.$parens)
-      ? [ ...exprs[0], ...op, ...exprs[1] ]
-      : [ ...exprs[0], ...op, { xpr: exprs[1] } ];
-  };
+function flattenenInternalXpr( array ) {
+  return (structXpr) ? array : array.flat( Infinity );
 }
 
 function query( node, csn, xsn, _prop, expectedParens = 0 ) {
@@ -1538,7 +1464,7 @@ function addElementAsColumn( elem, cols ) {
     gensrcFlavor = gensrcFlavor || 'column';
     set( 'virtual', col, elem );
     set( 'key', col, elem );
-    const expr = expression( elem.value, true );
+    const expr = expression( elem.value );
     Object.assign( col, (expr.cast ? { xpr: [ expr ] } : expr) );
     gensrcFlavor = gensrcSaved; // for not having annotations in inline etc
     if (elem.expand)
@@ -1574,7 +1500,7 @@ function orderBy( node ) {
     expr.sort = node.sort.val;
   if (node.nulls)
     expr.nulls = node.nulls.val;
-  return extra( expr, node );   // extra properties after sort/nulls
+  return expr;              // extra properties are before sort/nulls - who cares?
 }
 
 function extra( csn, node, expectedParens = 0 ) {
@@ -1639,19 +1565,18 @@ function compactQuery( q ) {    // TODO: options
 
 function compactExpr( e ) {     // TODO: options
   initModuleVars();
-  return e && expression( e, true );
+  return e && expression( e );
 }
 
 /**
  * @param {CSN.Options} options
  */
 function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
-  gensrcFlavor = options.parseCdl || options.csnFlavor === 'gensrc' ||
-               ( options.toCsn && options.toCsn.flavor === 'gensrc');
-  universalCsn = ( options.csnFlavor === 'universal' ||
-                   ( options.toCsn && options.toCsn.flavor === 'universal') ) &&
-                  isBetaEnabled( options, 'enableUniversalCsn' ) &&
-                  !options.parseCdl;
+  const flavor = options.csnFlavor || options.toCsn?.flavor;
+  gensrcFlavor = options.parseCdl || flavor === 'gensrc';
+  universalCsn = flavor === 'universal' &&
+                 isBetaEnabled( options, 'enableUniversalCsn' ) &&
+                 !options.parseCdl;
   strictMode = options.testMode;
   const proto = options.dictionaryPrototype;
   // eslint-disable-next-line no-nested-ternary
@@ -1659,7 +1584,7 @@ function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
     ? proto
     : (proto) ? Object.prototype : null;
   withLocations = options.withLocations;
-  parensAsStrings = isDeprecatedEnabled( options, '_parensAsStrings' );
+  structXpr = options.structXpr;
   projectionAsQuery = isDeprecatedEnabled( options, '_projectionAsQuery' );
 }
 

package/lib/language/.eslintrc.json

@@ -1,7 +1,4 @@
 {
   "root": true,
-  "extends": "../../.eslintrc-ydkjsi.json",
-  "rules": {
-    "cds-compiler/space-in-func-decl": "error"
-  }
+  "extends": "../../.eslintrc-ydkjsi.json"
 }

package/lib/language/genericAntlrParser.js

@@ -86,15 +86,15 @@ Object.assign(GenericAntlrParser.prototype, {
   previousTokenAtLocation,
   combinedLocation,
   surroundByParens,
+  secureParens,
   unaryOpForParens,
   leftAssocBinaryOp,
   classifyImplicitName,
   warnIfColonFollows,
   fragileAlias,
   identAst,
-  functionAst,
-  setLastAsXpr,
-  xprToken,
+  pushXprToken,
+  argsExpression,
   valuePathAst,
   signedExpression,
   numberLiteral,
@@ -249,9 +249,15 @@ const genericTokenTypes = {
   intro: 'GenericIntro',
 };
 
+/**
+ * @memberOf GenericAntlrParser
+ *
+ * @param pathItem
+ * @param [expected]
+ */
 function prepareGenericKeywords( pathItem, expected = null ) {
   const length = pathItem?.args?.length || 0;
-  const argPos = (expected ? length - 1 : length);
+  const argPos = length;
   const func = pathItem?.id && specialFunctions[pathItem.id.toUpperCase()];
   const spec = func && func[argPos] || specialFunctions[''][argPos ? 1 : 0];
   this.$genericKeywords = spec;
@@ -477,7 +483,7 @@ function tokenLocation( token, endToken = null ) {
 function isMultiLineToken( token ) {
   return (
     token.type === this.constructor.DocComment ||
-    token.type === this.constructor.String ||
+    token.type === this.constructor.String || // TODO: do not check every string content
     token.type === this.constructor.UnterminatedLiteral
   );
 }
@@ -547,6 +553,23 @@ function combinedLocation( start, end ) {
   return locUtils.combinedLocation( start, end );
 }
 
+// make sure that the parens of `IN (…)` do not disappear:
+function secureParens( expr ) {
+  const op = expr?.op?.val;
+  const $parens = expr?.$parens;
+  if (!$parens || expr.query || op && op !== 'call' && op !== 'cast')
+    return expr;
+  // ensure that references, literals and functions keep their surrounding parentheses
+  // (is for expressions the case anyway)
+  delete expr.$parens;
+  return {
+    op: { val: 'xpr', location: this.startLocation() },
+    args: [ expr ],
+    location: { ...expr.location },
+    $parens,
+  };
+}
+
 function surroundByParens( expr, open, close, asQuery = false ) {
   if (!expr)
     return expr;
@@ -657,33 +680,27 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   return { id, $delimited: true, location: this.tokenLocation( token ) };
 }
 
-function functionAst( token, xpr ) { // only for special function TRIM and EXTRACT
-  // TODO: XSN func cleanup
-  const location = this.tokenLocation( token );
-  const args = xpr
-    ? [ { op: { location, val: 'ixpr' }, args: [], location: this.tokenLocation( xpr ) } ]
-    : [];
-  return {
-    op: { location, val: 'call' },
-    func: { path: [ { id: token.text, location, args } ], location },
-    args,
-    location,
-  };
-}
-
-function setLastAsXpr( args ) {
-  const pos = args.length - 1;
-  const last = args[pos];
-  if (!last || last?.op?.val === 'ixpr') // actuall an internal xpr, which is always flattened
-    return last;
-  const location = { ...last.location };
-  args[pos] = { op: { location, val: 'ixpr' }, args: [ last ], location };
-  return args[pos].args;
+// only to be used in @after
+// TODO: remove compatible stuff (A2J/checks use op: 'and'/'=')
+function argsExpression( args, useFirstLocation, compatible = null ) {
+  // console.log('AE:',args);
+  if (args.length === 1)
+    return args[0];
+  const location = useFirstLocation && args[0] && { ...args[0].location };
+  const op = compatible && args.length === 3 && args[1].val === compatible && args[1];
+  const expr = (op)
+    ? { op: { val: op.val, location: op.location }, args: [ args[0], args[2] ], location }
+    : { op: { val: 'ixpr', location: this.startLocation() }, args, location };
+  return this.attachLocation( expr );
 }
 
-function xprToken() {
+function pushXprToken( args ) {
   const token = this._input.LT(-1);
-  return { location: this.tokenLocation( token ), val: token.text, literal: 'token' };
+  args.push( {
+    location: this.tokenLocation( token ),
+    val: token.text.toLowerCase(), // TODO: remove toLowerCase() ?
+    literal: 'token',
+  } );
 }
 
 function valuePathAst( ref ) {
@@ -720,10 +737,11 @@ function valuePathAst( ref ) {
 
 // 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( signToken, expr ) {
-  const sign = this.valueWithTokenLocation( signToken.text, signToken );
+function signedExpression( args, expr ) {
+  // if (args.length !== 1) throw Error()
+  const sign = args[0];
   const nval
-        = (signToken.text === '-' &&
+        = (sign.val === '-' &&
         expr && // expr may be null if `-` rule can't be parsed
         expr.literal === 'number' &&
         sign.location.endLine === expr.location.line &&
@@ -731,11 +749,14 @@ function signedExpression( signToken, expr ) {
         (typeof expr.val === 'number'
           ? expr.val >= 0 && -expr.val
           : !expr.val.startsWith('-') && `-${ expr.val }`)) || false;
-  if (nval === false)
-    return { op: sign, args: expr ? [ expr ] : [] };
-  expr.val = nval;
-  --expr.location.col;
-  return expr;
+  if (nval === false) {
+    args.push( expr );
+  }
+  else {
+    expr.val = nval;
+    --expr.location.col;
+    args[0] = expr;
+  }
 }
 
 // Return AST for number token `token` with optional token `sign`.  Represent
@@ -756,7 +777,7 @@ function numberLiteral( token, sign, text = token.text ) {
   const num = Number.parseFloat( text || '0' ); // not Number.parseInt() !
   if (!Number.isSafeInteger(num)) {
     if (sign == null) {
-      this.error( 'syntax-expecting-integer', token,
+      this.error( 'syntax-expecting-unsigned-int', token,
                   { '#': !text.match(/^[0-9]*$/) ? 'normal' : 'unsafe' } );
     }