@sap/cds-compiler 4.6.0 → 4.7.4

package/lib/json/to-csn.js

@@ -14,7 +14,7 @@
 const { locationString } = require('../base/messages');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { pathName } = require('../compiler/utils');
-const { CompilerAssertion, ModelError } = require('../base/error');
+const { CompilerAssertion } = require('../base/error');
 
 const compilerVersion = require('../../package.json').version;
 const creator = `CDS Compiler v${ compilerVersion }`;
@@ -212,116 +212,10 @@ const castProperties = [
 ];
 
 const csnDictionaries = [
-  'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
+  'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions', 'vocabularies',
 ];
 const csnDirectValues = [ 'val' ]; // + all starting with '@' - TODO: still relevant
 
-/**
- * Sort property names of CSN according to sequence which is also used by the compactModel function
- * Only returns enumerable properties, except for certain hidden properties
- * if requested (cloneOptions != false): $location, elements.
- *
- * If cloneOptions is false or if either cloneOptions.testMode or cloneOptions.testSortCsn
- * are set, definitions are also sorted.
- *
- * @param {object} csn
- * @param {CSN.Options|false} cloneOptions
- */
-function sortCsn( csn, cloneOptions = false ) {
-  if (cloneOptions && typeof cloneOptions === 'object')
-    initModuleVars( cloneOptions );
-
-  if (Array.isArray(csn))
-    return csn.map( v => (!v || typeof v !== 'object' ? v : sortCsn(v, cloneOptions) ) );
-  const r = {};
-  for (const n of Object.keys(csn).sort( compareProperties ) ) {
-    const sortDict = n === 'definitions' &&
-                     (!cloneOptions || cloneOptions.testMode || cloneOptions.testSortCsn);
-    const val = csn[n];
-    if (!val || typeof val !== 'object' || csnDirectValues.includes(n))
-      r[n] = val;
-    else if (n.charAt(0) === '@')
-      r[n] = cloneAnnotationValue( val );
-    else if (csnDictionaries.includes(n) && !Array.isArray(val))
-      // Array check for property `args` which may either be a dictionary or an array.
-      r[n] = csnDictionary( val, sortDict, cloneOptions );
-
-    else
-      r[n] = sortCsn(val, cloneOptions);
-  }
-  if (cloneOptions && typeof csn === 'object') {
-    if ({}.hasOwnProperty.call( csn, '$sources' ) && !r.$sources)
-      setHidden( r, '$sources', csn.$sources );
-    if ({}.hasOwnProperty.call( csn, '$location' ) && !r.$location)
-      setHidden( r, '$location', csn.$location );
-    if ({}.hasOwnProperty.call( csn, '$path' )) // used in generic reference flattener
-      setHidden( r, '$path', csn.$path );
-    if ({}.hasOwnProperty.call( csn, '$paths' )) // used in generic reference flattener
-      setHidden( r, '$paths', csn.$paths );
-    if (hasNonEnumerable( csn, 'elements' ) && !r.elements) // non-enumerable 'elements'
-      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;
-}
-
-function cloneAnnotationValue( val ) {
-  if (typeof val !== 'object') // scalar
-    return val;
-  return JSON.parse( JSON.stringify( val ) );
-}
-
-/**
- * Check whether the given object has non enumerable property.
- * Ensure that we don't take it from the prototype, only "directly" - we accidentally
- * cloned elements with a cds.linked input otherwise.
- *
- * @param {object} object
- * @param {string} property
- * @returns
- */
-function hasNonEnumerable( object, property ) {
-  return {}.hasOwnProperty.call( object, property ) &&
-    !{}.propertyIsEnumerable.call( object, property );
-}
-
-/**
- * @param {object} csn
- * @param {boolean} sort
- * @param {CSN.Options | false} cloneOptions If != false,
- *   cloneOptions.dictionaryPrototype is used and cloneOptions are
- *   passed to sort().
- * @returns {object}
- */
-function csnDictionary( csn, sort, cloneOptions = false ) {
-  if (!csn || Array.isArray(csn)) // null or strange CSN
-    return csn;
-  const proto = cloneOptions && (typeof cloneOptions === 'object') &&
-                cloneOptions.dictionaryPrototype;
-  // eslint-disable-next-line no-nested-ternary
-  const dictProto = (typeof proto === 'object') // including null
-    ? proto
-    : (proto) ? Object.prototype : null;
-  const r = Object.create( dictProto );
-  for (const n of (sort) ? Object.keys(csn).sort() : Object.keys(csn)) {
-    // CSN does not allow any dictionary that are not objects.
-    // The compiler handles it, but a pre-transformed OData CSN won't trigger recompilation.
-    if (csn[n] && typeof csn[n] === 'object')
-      r[n] = sortCsn(csn[n], cloneOptions);
-    else
-      throw new ModelError(`Found non-object dictionary entry: "${ n }" of type "${ typeof csn[n] }"`);
-  }
-
-  return r;
-}
-
 /**
  * Compact the given XSN model and transform it into CSN.
  *
@@ -1320,7 +1214,7 @@ function exprInternal( node, xprParens ) {
     return extra( call, node );
   }
   if (node.query)
-    return query( node.query, null, null, null, 1 );
+    return query( node.query, null, null, null, (node.$parens ? 1 - node.$parens.length : 1) );
   if (!node.op)                 // parse error
     return { xpr: [] };
 
@@ -1336,7 +1230,7 @@ function exprInternal( node, xprParens ) {
       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
+    default: {   // CSN v0 input (A2J: '='/'and'): binary (n-ary) and unary prefix
       if (!node.args.length)
         return { xpr: [] };
       const nary = [];
@@ -1345,7 +1239,7 @@ function exprInternal( node, xprParens ) {
       val = 'nary';
       node = {
         op: { val },
-        args: (nary.length > 2 ? nary.slice(1) : nary), // length 1,2 only with CSN v0
+        args: (nary.length > 2 ? nary.slice(1) : nary),
         $parens: node.$parens,
       };
     }
@@ -1361,6 +1255,7 @@ function flattenInternalXpr( array, op ) {
     return array.flat( Infinity );
   if (array.length < 5 || op !== 'nary')
     return array;
+  // nary: [ ‹a›, '+', ‹b›, '+', ‹c› ] → [ [ ‹a›, '+', ‹b› ], '+', ‹c› ]
   let left = array.slice( 0, 3 );
   let index = 3;
   while (index < array.length)
@@ -1612,12 +1507,10 @@ function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
 }
 
 module.exports = {
-  cloneCsnDictionary: (csn, options) => csnDictionary(csn, false, options),
-  cloneAnnotationValue,
   compactModel,
   compactQuery,
   compactExpr,
-  sortCsn,
   csnDictionaries,
   csnDirectValues,
+  csnPropertyOrder: propertyOrder,
 };

package/lib/language/genericAntlrParser.js

@@ -103,6 +103,7 @@ Object.assign(GenericAntlrParser.prototype, {
   fragileAlias,
   identAst,
   pushXprToken,
+  pushOpToken,
   argsExpression,
   valuePathAst,
   fixNewKeywordPlacement,
@@ -360,6 +361,8 @@ function attachLocation( art ) {
     art.location = this.tokenLocation(this._ctx.start, this._ctx.stop);
     return art;
   }
+  if (!this._ctx.stop)
+    return art;
 
   // The last token (this._ctx.stop) may be a multi-line string literal, in which
   // case we can't rely on `this._ctx.stop.line`.
@@ -639,14 +642,16 @@ function surroundByParens( expr, open, close, asQuery = false ) {
     expr.$parens.push( location );
   else
     expr.$parens = [ location ];
+  if (expr.$opPrecedence)
+    expr.$opPrecedence = null;
   return (asQuery) ? { query: expr, location } : expr;
 }
 
 
-function tokensToStringRepresentation( matchedRule ) {
+function tokensToStringRepresentation( start, stop ) {
   const tokens = this._input.getTokens(
-    matchedRule.start.tokenIndex,
-    matchedRule.stop.tokenIndex + 1, null
+    start.tokenIndex,
+    stop.tokenIndex + 1, null
   ).filter(tok => tok.channel === antlr4.Token.DEFAULT_CHANNEL);
   if (tokens.length === 0)
     return '';
@@ -772,33 +777,6 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   return { id, $delimited: true, location: this.tokenLocation( token ) };
 }
 
-// only to be used in @after
-// TODO: remove compatible stuff (A2J/checks use op: 'and'/'=')
-function argsExpression( args, nary, location ) {
-  // console.log('AE:',args);
-  if (args.length === 1)
-    return args[0];
-  if (nary && args.length === 3 && args[1]?.val === nary) {
-    return this.attachLocation( {
-      op: { val: nary, location: args[1].location },
-      args: [ args[0], args[2] ],
-      location: undefined,
-    } );
-  }
-  // eslint-disable-next-line no-nested-ternary
-  const val = nary === '?:' ? nary
-    : (nary && nary !== '=' ? 'nary' : 'ixpr');
-  const op = {
-    val, // there is no n-ary in rule conditionTerm
-    location: this.startLocation(),
-  };
-  return this.attachLocation( {
-    op,
-    args,
-    location: location && { __proto__: CsnLocation.prototype, ...location },
-  } );
-}
-
 function pushXprToken( args ) {
   const token = this._input.LT(-1);
   args.push( {
@@ -910,11 +888,11 @@ function fixNewKeywordPlacement( args ) {
   args.push(ixpr);
 }
 
-function expressionAsAnnotationValue( assignment, cond ) {
-  if (!cond.cond) // parse error
+function expressionAsAnnotationValue( assignment, cond, start, stop ) {
+  if (!cond) // parse error
     return;
-  Object.assign(assignment, cond.cond);
-  assignment.$tokenTexts = this.tokensToStringRepresentation(cond);
+  Object.assign(assignment, cond);
+  assignment.$tokenTexts = this.tokensToStringRepresentation( start, stop );
 }
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
@@ -1030,7 +1008,22 @@ function assignAnnotationValue( anno, value ) {
 }
 
 function relevantDigits( val ) {
-  return val.replace( /0*(e.+)?$/i, '' ).replace( /\./, '' ).replace( /^[-+0]+/, '' );
+  val = val.replace( /e.+$/i, '' );
+
+  // To avoid the super-linear RegEx `0+$`, use the non-backtracking version and
+  // simply check if we're at the end.
+  const trailingZeroes = /0+/g;
+  let re;
+  while ((re = trailingZeroes.exec(val)) !== null) {
+    if (trailingZeroes.lastIndex === val.length) {
+      val = val.slice(0, re.index);
+      break;
+    }
+  }
+
+  return val
+    .replace( /\./, '' )
+    .replace( /^[-+0]+/, '' );
 }
 
 // Create AST node for quoted literals like string and e.g. date'2017-02-22'.
@@ -1277,25 +1270,90 @@ function createSource() {
   return new XsnSource();
 }
 
+const operatorPrecedences = {
+  // query:
+  union: 1,
+  except: 1,
+  minus: 1,
+  intersect: 2,
+};
+
 // Create AST node for binary operator `op` and arguments `args`
-function leftAssocBinaryOp( left, opToken, eToken, right, extraProp = 'quantifier' ) {
-  const op = this.valueWithTokenLocation( opToken.text.toLowerCase(), opToken);
+function leftAssocBinaryOp( expr, right, opToken, eToken, extraProp ) {
+  if (!right)
+    return expr;
+  const op = this.valueWithTokenLocation( opToken.text.toLowerCase(), opToken );
   const extra = eToken
     ? this.valueWithTokenLocation( eToken.text.toLowerCase(), eToken )
     : undefined;
-  if (!left.$parens &&
-      (left.op && left.op.val) === (op && op.val) &&
-      (left[extraProp] && left[extraProp].val) === (extra && extra.val)) {
-    left.args.push( right );
-    return left;
-  }
-  else if (extra) {
-    return {
-      op, [extraProp]: extra, args: [ left, right ], location: left.location,
-    };
+  if (!expr.$parens && expr.op?.val === op.val && expr[extraProp]?.val === extra?.val) {
+    expr.args.push( right );
+    return expr;
+  }
+  const opPrec = operatorPrecedences[op.val] || 0;
+  let left = expr;
+  let args;
+  while (opPrec > nodePrecedence( left )) {
+    args = left.args;
+    left = args[args.length - 1];
+  }
+  // TODO: location correct?
+  const node = (extra)          // eslint-disable-next-line
+    ? { op, [extraProp]: extra, args: [ left, right ], location: left.location }
+    : { op, args: [ left, right ], location: left.location };
+  if (!args)
+    return node;
+  args[args.length - 1] = node;
+  return expr;
+}
+
+function nodePrecedence( node ) {
+  const { op } = node;
+  return op && !node.$parens && operatorPrecedences[op.val] || Infinity;
+}
+
+function pushOpToken( args, precedence ) { // for nary only; uses LT(-1) as operator token
+  let node = null;
+  let left = args;
+  while (left?.$opPrecedence && left.$opPrecedence < precedence) {
+    args = left;
+    node = args[args.length - 1]; // last sub node of left side
+    left = node.args;
+  }
+
+  if (left?.$opPrecedence === precedence ) { // nary
+    args = left;
+  }
+  else if (node) {
+    const sub = this.argsExpression( [ node, null ], true );
+    args[args.length - 1] = sub;
+    args = sub.args;
+    args.length = 1;
+  }
+  else if (args.length > 1) {   // new top-level op & op on left
+    args[0] = this.argsExpression( [ ...args ], args.$opPrecedence != null ); // finish expresion
+    args.length = 1;
   }
+  args.$opPrecedence = precedence;
+  // TODO (if necessary): `location` for sub expessions, top-level is be properly set
+  this.pushXprToken( args );
+  return args;
+}
 
-  return { op, args: [ left, right ], location: left.location };
+// only to be used in @after or via pushOpToken
+function argsExpression( args, nary ) {
+  if (args.length === 1)        // args.length === 0 is ok (for OVER…)
+    return args[0];
+  const $parens = args[0]?.$parens;
+  const loc = ($parens) ? $parens[$parens.length - 1] : args[0]?.location;
+  const location = loc ? { __proto__: CsnLocation.prototype, ...loc } : this.startLocation();
+  // console.log('AE:',args);
+  const op = {
+    // eslint-disable-next-line no-nested-ternary
+    val: nary === '?:' ? nary : nary ? 'nary' : 'ixpr',
+    location,
+  };
+  return this.attachLocation( { op, args, location } );
 }
 
 const maxCardinalityKeywords = { 1: 'one', '*': 'many' };

package/lib/model/cloneCsn.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const { csnPropertyOrder } = require('../json/to-csn');
+const { ModelError } = require('../base/error');
+const { setHidden } = require('../utils/objectUtils');
+const { isAnnotationExpression } = require('../compiler/builtins');
+
+const csnDictionaries = [
+  'args',
+  'params',
+  'enum',
+  'mixin',
+  'elements',
+  'actions',
+  'definitions',
+  'vocabularies',
+];
+
+function shallowCopy( val, _options, _sort ) {
+  return val;
+}
+
+const internalCsnProps = {
+  $sources: shallowCopy,
+  $location: shallowCopy,
+  $path: shallowCopy,
+  $paths: shallowCopy,
+  elements: cloneCsnDict,
+  $tableConstraints: shallowCopy,
+};
+const internalCsnPropertyNames = Object.keys(internalCsnProps);
+
+
+/**
+ * Deeply clone the given CSN model and return it.
+ * In testMode (or with testSortCsn), definitions are sorted.
+ *
+ * This function is CSN aware! Don't put annotation values into it, or
+ * keys such as "elements" will be interpreted according to CSN rules!
+ *
+ * @see cloneAnnotationValue()
+ * @see cloneCsnDict()
+ *
+ * @param {object} csn Top-level CSN.  You can pass non-dictionary values.
+ * @param {CSN.Options} options CSN Options, only used for `dictionaryPrototype`, `testMode`, and `testSortCsn`.
+ * @param {boolean} sort Whether to sort CSN properties.
+ */
+function cloneCsn( csn, options, sort ) {
+  if (!csn || typeof csn !== 'object')
+    return csn;
+  if (Array.isArray(csn))
+    return csn.map( v => cloneCsn(v, options, sort) );
+
+  const keys = Object.keys(csn);
+  if (sort)
+    keys.sort( compareProperties );
+
+  const r = {};
+  for (const n of keys) {
+    const val = csn[n];
+    if (!val || typeof val !== 'object') {
+      r[n] = val;
+    }
+    else if (n.charAt(0) === '@') {
+      r[n] = cloneAnnotationValue(val, options, false); // TODO: pass 'sort'
+    }
+    else if (csnDictionaries.includes(n) && !Array.isArray(val)) {
+      const sortDict = n === 'definitions' &&
+        (!options || options.testMode || options.testSortCsn);
+      // Array check for property `args` which may either be a dictionary or an array.
+      r[n] = cloneCsnDict(val, options, sort, sortDict);
+    }
+    else {
+      r[n] = cloneCsn(val, options, sort);
+    }
+  }
+
+  // Note: internal properties with value `undefined` are _not_ cloned!
+  // The `hasNonEnumerable()` is required to work with cds.linked() CSN!
+  // It _must_ appear before csn[prop] or it may invoke getters!
+  internalCsnPropertyNames.forEach((prop) => {
+    if (r[prop] === undefined && hasNonEnumerable( csn, prop ) && csn[prop] !== undefined)
+      setHidden( r, prop, internalCsnProps[prop](csn[prop], options, sort) );
+  });
+  options?.hiddenPropertiesToClone?.forEach((prop) => {
+    if (r[prop] === undefined && hasNonEnumerable( csn, prop ) && csn[prop] !== undefined)
+      setHidden( r, prop, csn[prop] );
+  });
+
+  return r;
+}
+
+function hasNonEnumerable( object, property ) {
+  return Object.prototype.hasOwnProperty.call( object, property ) &&
+    !Object.prototype.propertyIsEnumerable.call( object, property );
+}
+
+/**
+ * Deeply clone the given CSN dictionary and return it.
+ * This function does _not_ sort the given dictionary.
+ * See cloneCsnNonDict() if you want sorted definitions.
+ *
+ * This function is CSN aware! Don't put annotation values into it, or
+ * keys such as "elements" will be interpreted according to CSN rules!
+ *
+ * @see cloneAnnotationValue
+ * @see cloneCsnNonDict
+ *
+ * @param {object} csn
+ * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
+ *                              used and cloneOptions are passed to sortCsn().
+ */
+function cloneCsnDict( csn, options, sortProps, sortDict ) {
+  const proto = options?.dictionaryPrototype;
+  const dictProto = (typeof proto === 'object') // including null
+    ? proto
+    : null;
+  const r = Object.create( dictProto );
+  const keys = Object.keys(csn);
+  if (sortDict)
+    keys.sort();
+  for (const n of keys) {
+    // CSN does not allow any dictionary that are not objects.
+    // The compiler handles it, but a pre-transformed OData CSN won't trigger recompilation.
+    if (csn[n] && typeof csn[n] === 'object')
+      r[n] = cloneCsn(csn[n], options, sortProps);
+    else
+      throw new ModelError(`Found non-object dictionary entry: "${ n }" of type "${ typeof csn[n] }"`);
+  }
+  return r;
+}
+
+/**
+ * Clones the given annotation _value_.  `value` must not be an object with annotations,
+ * but the annotation value itself, e.g. `[ { a: 1 } ]`, not `@anno: [...]`.
+ *
+ * @param {any} value
+ * @param {object} options
+ * @param {boolean} sort Whether to sort properties inside expressions.
+ * @returns {any}
+ */
+function cloneAnnotationValue( value, options, sort ) {
+  if (!value || typeof value !== 'object') // scalar
+    return value;
+  if (!Array.isArray(value) && isAnnotationExpression( value ))
+    return cloneCsn( value, options, sort );
+  return JSON.parse( JSON.stringify( value ) );
+}
+
+/**
+ * Sorts the definition dictionary in tests mode.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @returns The input csn model.
+ */
+function sortCsnDefinitionsForTests( csn, options ) {
+  if (!options.testMode && !options.testSortCsn)
+    return csn;
+  const sorted = Object.create(null);
+  Object.keys(csn.definitions || {}).sort().forEach((name) => {
+    sorted[name] = csn.definitions[name];
+  });
+  csn.definitions = sorted;
+  return csn;
+}
+
+function sortCsnForTests( csn, options ) {
+  if (options.testMode)
+    return cloneCsn(csn, options, true);
+  if (options.testSortCsn)
+    return sortCsnDefinitionsForTests( csn, options );
+  return csn;
+}
+
+// Difference to to-csn.js: Annotations are always sorted
+function compareProperties( a, b ) {
+  if (a === b)
+    return 0;
+  const oa = csnPropertyOrder[a] || csnPropertyOrder[a.charAt(0)] || 9999;
+  const ob = csnPropertyOrder[b] || csnPropertyOrder[b.charAt(0)] || 9999;
+  return oa - ob || (a < b ? -1 : 1);
+}
+
+module.exports = {
+  cloneCsnDict(csn, options) {
+    return cloneCsnDict(csn, options, false, false);
+  },
+  cloneCsnNonDict(csn, options) {
+    return cloneCsn(csn, options, false);
+  },
+  cloneFullCsn(csn, options) {
+    return cloneCsn(csn, options, false);
+  },
+  cloneAnnotationValue(csn) {
+    return cloneAnnotationValue(csn, {}, false);
+  },
+  sortCsn(csn, options) {
+    return cloneCsn(csn, options, true);
+  },
+  sortCsnDefinitionsForTests,
+  sortCsnForTests,
+};

package/lib/model/csnRefs.js

@@ -171,6 +171,8 @@
 //   hierarchy, query number, table aliases and links from a column to its
 //   respective inferred element.
 
+// TODO: some `name` property would be useful (also set with `initDefinition`)
+
 // Properties in cache:
 //
 // - _effectiveType on def/member/items: cached result of effectiveType()
@@ -896,9 +898,14 @@ function queryOrMain( query, main ) {
 /**
  * Traverse query in pre-order
  *
+ * The callback is called on the following XSN nodes inside the query `query`:
+ * - a query node, which has property `SET` or `SELECT` (or `projection`),
+ * - a query source node inside `from` if it has property `ref`,
+ * - NOT on a `join` node inside `from`.
+ *
  * @param {CSN.Query} query
- * @param {CSN.QuerySelect} fromSelect
- * @param {CSN.Query} parentQuery
+ * @param {CSN.QuerySelect} fromSelect: for query in `from`
+ * @param {CSN.Query} parentQuery: for a sub query (ex those in `from`)
  * @param {(query: CSN.Query&CSN.QueryFrom, select: CSN.QuerySelectEnriched, parentQuery: CSN.Query) => void} callback
  */
 function traverseQuery( query, fromSelect, parentQuery, callback ) {
@@ -1006,7 +1013,8 @@ function pathId( item ) {
 }
 
 function implicitAs( ref ) {
-  const id = pathId( ref[ref.length - 1] );
+  const item = ref[ref.length - 1];
+  const id = (typeof item === 'string') ? item : item.id; // inlined `pathId`
   return id.substring( id.lastIndexOf('.') + 1 );
 }