@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/json/to-csn.js

@@ -33,12 +33,15 @@ let projectionAsQuery = false;
 let withLocations = false;
 let dictionaryPrototype = null;
 
+// Properties for dictionaries, set in compileX() and TODO: parseX(), must be
+// stored with symbols as keys, as we do not want to disallow any key name:
+const $inferred = Symbol.for('cds.$inferred');
+
 // IMPORTANT: the order of these properties determine the order of properties
 // in the resulting CSN !!!  Also check const `csnPropertyNames`.
 const transformers = {
   // early and modifiers (without null / not null) ---------------------------
   kind,
-  _outer: ( _, csn, node ) => addOrigin( csn, node ),
   id: n => n,                   // in path item
   doc: value,
   '@': value,
@@ -67,7 +70,7 @@ const transformers = {
   targetAspect,
   target,
   foreignKeys,
-  enum: insertOrderDict,
+  enum: enumDict,
   items,
   includes: arrayOf( artifactRef ), // also entities
   // late expressions / query properties -------------------------------------
@@ -80,6 +83,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 ) ),
   orderBy: arrayOf( orderBy ), // TODO XSN: make `sort` and `nulls` sibling properties
   sort: value,
   nulls: value,
@@ -95,7 +99,7 @@ const transformers = {
   value: enumValue,             // do not list for select items as elements
   query,
   elements,
-  actions: nonEmptyDict,        // TODO: just normal dictionary
+  actions,                      // TODO: just normal dictionary
   // special: top-level, cardinality -----------------------------------------
   sources,
   definitions: sortedDict,
@@ -191,6 +195,22 @@ const operators = {
   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', ...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] ],
   // xpr: (exprs) => [].concat( ...exprs ), see below - handled extra
 };
 
@@ -232,22 +252,36 @@ function sortCsn( csn, cloneOptions = false ) {
       r[n] = sortCsn(val, cloneOptions);
   }
   if (cloneOptions && typeof csn === 'object') {
-    if (csn.$sources && !r.$sources)
-      setHidden(r, '$sources', csn.$sources);
-    if (csn.$location && !r.$location)
-      setHidden(r, '$location', csn.$location);
-    if (csn.$path) // used in generic reference flattener
-      setHidden(r, '$path', csn.$path);
-    if (csn.$paths) // used in generic reference flattener
-      setHidden(r, '$paths', csn.$paths);
-    if (csn.elements && !r.elements) // non-enumerable 'elements'
-      setHidden(r, 'elements', csnDictionary( csn.elements, false, cloneOptions ) );
-    if (csn.$tableConstraints && !r.$tableConstraints)
-      setHidden(r, '$tableConstraints', csn.$tableConstraints);
+    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 );
   }
   return r;
 }
 
+/**
+ * Check wether 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
@@ -359,10 +393,12 @@ function usings( srcDict ) {
  * @param {object} csn
  * @param {object} model
  */
+
+
 function extensions( node, csn, model ) {
   if (model.kind && model.kind !== 'source')
     return undefined;
-  const exts = node.map( standard );
+  const exts = node.map( definition );
 
   // builtins are non-enumerable for smaller display
   for (const name of Object.getOwnPropertyNames( model.definitions || {} ).sort()) {
@@ -377,17 +413,21 @@ function extensions( node, csn, model ) {
     }
     else if (gensrcFlavor) {
       // From definitions (without redefinitions) with potential inferred elements:
-      if (!Array.isArray(art) && art.elements &&
-          (art.query || art.includes || art.$inferred)) {
-        const annos = art.$inferred && annotationsAndDocComment( art, true );
-        const elems = inferred( art.elements, art.$inferred );
-        /** @type {object} */
-        const annotate = Object.assign( { annotate: name }, annos );
-        if (Object.keys( elems ).length)
-          annotate.elements = elems;
-        if (Object.keys( annotate ).length > 1)
-          exts.push( annotate );
+      const annotate = { annotate: name };
+      if (art.$inferred)
+        Object.assign( annotate, annotationsAndDocComment( art, true ) );
+      if (art.$expand === 'annotate') {
+        if (art.actions)
+          attachAnnotations( annotate, 'actions', art.actions, art.$inferred );
+        else if (art.params)
+          attachAnnotations( annotate, 'params', art.params, art.$inferred );
+        const obj = art.returns || art;
+        const elems = (obj.items || obj).elements; // no targetAspect here
+        if (elems)
+          attachAnnotations( annotate, 'elements', elems, art.$inferred, art.returns );
       }
+      if (Object.keys( annotate ).length > 1)
+        exts.push( annotate );
     }
   }
 
@@ -395,6 +435,58 @@ function extensions( node, csn, model ) {
     (a, b) => (a.annotate || a.extend).localeCompare( b.annotate || b.extend )
   );
 
+  /*
+  function attachElementAnnos( annotate, art ) {
+    while (art.items)
+      art = art.items;
+    if (art.elements) {
+      const elems = inferred( art.elements, art.$inferred );
+      if (Object.keys( elems ).length)
+        annotate.elements = elems;
+    }
+  }
+
+  function attachParamAnnos( annotate, art ) {
+    const inferredParent = art.$inferred;
+    if (art.params) {
+      const ext = Object.create( dictionaryPrototype );
+      for (const name in art.params) {
+        const par = art.params[name];
+        if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
+          continue;
+        const render = annotationsAndDocComment( par, true );
+        const subElems = par.$expand !== 'origin' && (par.items || par).elements;
+        if (subElems) {
+          const sub = inferred( subElems, par.$inferred );
+          if (Object.keys( sub ).length)
+            render.elements = sub;
+        }
+        if (Object.keys(render).length)
+          ext[name] = render;
+      }
+      if (obj.keys( ext ))
+        annotate.params = ext;
+    }
+    if (art.returns) {
+      const par = art.returns;
+      if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
+        return;
+      const render = annotationsAndDocComment( par, true );
+      const subElems = par.$expand !== 'origin' && (par.items || par).elements;
+      if (subElems) {
+        const sub = inferred( subElems, par.$inferred );
+        if (Object.keys( sub ).length)
+          render.elements = sub;
+      }
+      if (Object.keys(render).length)
+        const sub = inferred( subElems, par.$inferred );
+      if (Object.keys( sub ).length)
+        render.elements = sub;
+    }
+  }
+  return ext;
+  */
+
   // extract namespace/builtin annotations
   function extractAnnotationsToExtension( art ) {
     const name = art.name.absolute;
@@ -456,17 +548,29 @@ function sources( srcDict, csn ) {
   }
 }
 
-function inferred( elems, inferredParent ) {
-  const ext = Object.create( dictionaryPrototype );
-  for (const name in elems) {
-    const elem = elems[name];
-    if (Array.isArray(elem) || !inferredParent && !elem.$inferred)
-      continue;
-    const csn = annotationsAndDocComment( elem, true );
-    if (Object.keys(csn).length)
-      ext[name] = csn;
+function attachAnnotations( annotate, prop, dict, inferred, returns = false ) {
+  const annoDict = Object.create( dictionaryPrototype );
+  for (const name in dict) {
+    const elem = dict[name];
+    const inf = inferred || elem.$inferred; // is probably always inferred if parent was
+    const sub = (inf) ? annotationsAndDocComment( elem, true ) : {};
+    if (elem.$expand === 'annotate') {
+      if (elem.params)
+        attachAnnotations( sub, 'params', elem.params, inf );
+      const obj = elem.returns || elem;
+      const elems = (obj.items || obj.targetAspect || obj).elements;
+      if (elems)
+        attachAnnotations( sub, 'elements', elems, inf, elem.returns );
+    }
+    if (Object.keys( sub ).length)
+      annoDict[name] = sub;
+  }
+  if (Object.keys( annoDict ).length) {
+    if (returns)
+      annotate.returns = { elements: annoDict };
+    else
+      annotate[prop] = annoDict;
   }
-  return ext;
 }
 
 function standard( node ) {
@@ -505,10 +609,13 @@ function set( prop, csn, node ) {
 }
 
 function targetAspect( val, csn, node ) {
+  const ta = (val.elements)
+    ? addLocation( val.location, standard( val ) )
+    : artifactRef( val, true );
   if (!gensrcFlavor || node.target && !node.target.$inferred)
-    return (val.elements) ? standard( val ) : artifactRef( val, true );
+    return ta;
   // For compatibility, put aspect in 'target' with parse.cdl and csn flavor 'gensrc'
-  csn.target = (val.elements) ? standard( val ) : artifactRef( val, true );
+  csn.target = ta;
   return undefined;
 }
 
@@ -527,11 +634,9 @@ function target( val, _csn, node ) {
 }
 
 function items( obj, csn, node ) {
-  if (!keepElements( node ))
-    // no 'elements' with SELECT or inferred elements with gensrc;
-    // hidden 'elements' will be set in query()
+  if (!keepElements( node, obj ))
     return undefined;
-  return standard( obj );
+  return standard( obj );   // no 'elements' with inferred elements with gensrc
 }
 
 function elements( dict, csn, node ) {
@@ -544,6 +649,18 @@ function elements( dict, csn, node ) {
   return insertOrderDict( dict );
 }
 
+function enumDict( dict, csn, node ) {
+  if (gensrcFlavor && dict[$inferred] ||
+      !keepElements( node ))
+    // no 'elements' with SELECT or inferred elements with gensrc;
+    // hidden or visible 'elements' will be set in query()
+    return undefined;
+  if (universalCsn && node.type && !node.type.$inferred && node.$expand === 'annotate')
+    // derived type of enum type with individual annotations: also set $origin
+    csn.$origin = originRef( node.type._artifact );
+  return insertOrderDict( dict );
+}
+
 function enumerableQueryElements( select ) {
   if (!universalCsn || select === select._main._leadingQuery)
     return false;
@@ -553,21 +670,35 @@ function enumerableQueryElements( select ) {
   return alias.query && (alias.query._leadingQuery || alias.query) === select;
 }
 
-// We do not optimize away elements which are potentially adapted during their
-// way from the original structure type definition to the current usage
-function keepElements( node ) {
+// Should we render the elements?  (and items?)
+function keepElements( node, line ) {
   if (universalCsn)
-    // if there are neither _origin, nor type, $expand won't be set and this
-    // function returns true automatically
+    // $expand = null/undefined: not elements not via expansion
+    // $expand = 'target'/'annotate': with redirections / individual annotations
     return node.$expand !== 'origin';
   if (!node.type || node.kind === 'type')
     return true;
+  // keep many SimpleType/Entity
+  if (line) {
+    if (!node.type)
+      return true;
+    const array = node.type._artifact; // see function items() in propagator.js
+    const ltype = line.type && line.type._artifact;
+    if (!array ||     // reference errors
+        array._main && !line.elements && !line.enum && !line.items && !line.notNull &&
+        (!ltype || !ltype._main)) // many Foo:bar -> not SimpleType
+      return true;
+  }
+  // even if expanded elements have no new target or direct annotation,
+  // they might have got one via propagation – any new target/annos during their
+  // way from the original structure type definition to the current usage
   while (node) {
     if (node.$expand !== 'origin')
       return true;
     node = node._origin;
   }
-  return false;
+  // all in _origin chain only have expanded elements with 'origin':
+  return false;                 // no need to render elements
 }
 
 // for gensrcFlavor and namespace/builtin annotation extraction:
@@ -653,17 +784,17 @@ function sortedDict( dict ) {
   return dictionary( dict, keys );
 }
 
-function nonEmptyDict( dict ) {
+function actions( dict ) {
   const keys = Object.keys( dict );
   return (keys.length)
-    ? dictionary( dict, keys )
+    ? dictionary( dict, keys, 'actions' )
     : undefined;
 }
 
-function dictionary( dict, keys ) {
+function dictionary( dict, keys, prop ) {
   const csn = Object.create( dictionaryPrototype );
   for (const name of keys) {
-    const def = definition( dict[name] );
+    const def = definition( dict[name], null, null, prop );
     if (def !== undefined)
       csn[name] = def;
   }
@@ -686,7 +817,7 @@ function foreignKeys( dict, csn, node ) {
   csn.keys = keys;
 }
 
-function definition( art ) {
+function definition( art, _csn, _node, prop ) {
   if (!art || typeof art !== 'object')
     return undefined;           // TODO: complain with strict
   // Do not include namespace definitions or inferred construct (in gensrc):
@@ -698,44 +829,150 @@ function definition( art ) {
     addLocation( art.targetElement.location, key );
     return extra( key, art );
   }
-  return standard( art );
+  const c = standard( art );
+  // The XSN of actions in extensions do not contain a returns yet - TODO?
+  const elems = c.elements;
+  if (elems && (prop === 'actions' || art.$syntax === 'returns')) {
+    delete c.elements;
+    c.returns = { elements: elems };
+  }
+  if (kind && kind !== 'key')
+    addOrigin( c, art, art._origin );
+  return c;
 }
 
-function addOrigin( csn, xsn ) {
-  if (!universalCsn)
-    return csn;
+// create $origin specification for `includes` of `art`
+function includesOrigin( includes, art ) {
+  const $origin = originRef( includes[0]._artifact );
+  if (includes.length === 1)
+    return $origin;
+  const result = { $origin };
+  for (const incl of includes.slice(1)) {
+    const aspect = incl._artifact;
+    for (const prop in aspect) {
+      if (prop.charAt(0) === '@' && (!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 } } ) );
+      }
+    }
+  }
+  return (Object.keys( result ).length === 1) ? $origin : result;
+}
+
+function addOrigin( csn, xsn, origin ) {
+  if (!universalCsn || hasExplicitProp( xsn.type ))
+    return;
   if (xsn._from) {
-    csn.$origin = originRef( xsn._from[0]._origin );
+    const source = xsn._from[0]._origin;
+    csn.$origin = originRef( source );
+    if (source.params && !xsn.params)
+      csn.params = null;        // discontinue `params` inheritance
+    if (source.actions && !xsn.actions)
+      csn.actions = null;       // discontinue `actions` inheritance
+    return;
   }
-  else if (xsn.includes && xsn.includes.length > 1) {
-    csn.$origin = { $origin: originRef( xsn.includes[0]._artifact ) };
+  else if (xsn.includes) {
+    csn.$origin = includesOrigin( xsn.includes, xsn );
+    return;
   }
-  else if (xsn._origin && !hasExplicitProp( xsn.type ) && xsn._origin.kind !== 'builtin') {
-    let origin = xsn._origin;
-    while (origin._parent && origin._parent.$expand === 'origin')
-      origin = origin._origin || origin.type._artifact;
-    csn.$origin = originRef( origin );
+  else if (!xsn._main || xsn.kind === 'select') {
+    return;
   }
-  return csn;
+  const parent = getParent( xsn );
+  const parentOrigin = getOrigin( parent );
+  if (!xsn._origin || xsn._origin.kind === 'builtin') { // or $dollarVariable
+    if (parentOrigin && (!parent.enum || parent.$origin || !parent.type))
+      csn.$origin = null;
+    return;
+  }
+  // Skip all proxies which do not make it into the CSN, as there are no
+  // individual annotations or redirection targets on it:
+  while (origin._parent && origin._parent.$expand === 'origin')
+    origin = origin._origin || origin.type._artifact;
+  // The while loop is not only for the else case below: when setting implicit
+  // prototypes, it is important that we do not have to follow the prototypes of
+  // other object; we would need to ensure a right order to avoid issues otherwise.
+  if (parentOrigin === getParent( origin )) {
+    // implicit prototype or shortened reference
+    const { id } = origin.name || {};
+    if (id && xsn.name && id !== xsn.name.id)
+      csn.$origin = id;
+    return;
+  }
+  if (origin.kind === 'mixin') {
+    // currently, target and on are always set - nothing to do here, just set type
+    csn.type = 'cds.Association';
+    return;
+  }
+  const ref = originRef( origin, xsn );
+  if (ref) {
+    csn.$origin = ref;
+    return;
+  }
+  // An element of a query with a query in FROM:
+  const anon = definition( origin );   // use $origin: {...} if necessary
+  // as there are no implicit $origin prototypes on sub query elements (yet),
+  // we do not have to care about $origin not being set
+  const { $origin } = anon;
+  if ($origin && typeof $origin === 'object' && !Array.isArray( $origin )) {
+    // repeated anon: flatten
+    csn.$origin = Object.assign( $origin, anon );
+  }
+  else if (Object.keys( anon )
+           // (we can use the properties in `csn`, because addOrigin() is called last)
+    .every( p => p in csn || p === '$origin' || p === '$location')) {
+    // nothing new in $origin: {...}
+    addOrigin( csn, xsn, origin._origin );
+  }
+  else {
+    csn.$origin = anon;
+  }
+}
+
+function getParent( art ) {
+  const parent = art._parent;
+  const main = parent._main;
+  return (main && parent === main._leadingQuery) ? main : parent;
+}
+
+function getOrigin( art ) {
+  if (art._origin)
+    return art._origin;
+  if (hasExplicitProp( art.type ))
+    return art.type._artifact;
+  if (art.includes)
+    return art.includes[0]._artifact;
+  if (art._from)
+    return art._from[0]._origin;
+  return undefined;
 }
 
 function hasExplicitProp( ref ) {
   return ref && !ref.$inferred;
 }
 
-function originRef( art ) {
+function originRef( art, user ) {
   const r = [];
   // do not use name.element, as we allow `.`s in name
-  let main = art;
-  while (main._main && main.kind !== 'select') {
-    const nkind = normalizedKind[main.kind];
-    if (main.name.id || !r.length) // { param: "" } only for return, not elements inside
-      r.push( nkind ? { [nkind]: main.name.id } : main.name.id );
-    main = main._parent;
+  let parent = art;
+  while (parent._main && parent.kind !== 'select') {
+    const nkind = normalizedKind[parent.kind];
+    if (parent.name.id || !r.length)
+      // Return parameter is in XSN - kind: 'param', name.id: ''
+      // eslint-disable-next-line no-nested-ternary, max-len
+      r.push( !nkind ? parent.name.id : parent.name.id ? { [nkind]: parent.name.id } : { return: true } );
+    parent = parent._parent;
   }
-  if (main._main)    // well, an element of an query in FROM
-    return definition( art );   // use $origin: {}
+  if (user && parent._main && parent._main === user._main && parent !== user._main._leadingQuery)
+    // well, an element of an query in FROM (TODO: try with sub elem), but not the leading query
+    return null;                // probably use $origin: {...}
   // for sub query in FROM in sub query in FROM, we could condense the info
+
+  // Now the ref, with ["absolute", "action"] instead of ["absolute", {action:"action"}]
+  if (r.length === 1 && normalizedKind[art.kind] === 'action')
+    return [ art.name.absolute, art.name.id ];
   r.push( art.name.absolute );
   r.reverse();
   return r;
@@ -750,13 +987,11 @@ function kind( k, csn, node ) {
     else if (k === 'extend')
       csn.kind = k;
   }
-  else {
-    if (![
-      'element', 'key', 'param', 'enum', 'select', '$join',
-      '$tableAlias', 'annotation', 'mixin',
-    ].includes(k))
-      csn.kind = k;
-    addOrigin( csn, node );
+  else if (![
+    'element', 'key', 'param', 'enum', 'select', '$join',
+    '$tableAlias', 'annotation', 'mixin',
+  ].includes(k)) {
+    csn.kind = k;
   }
 }
 
@@ -865,10 +1100,12 @@ function args( node ) {
   return dict;
 }
 
-// "Short" value form, e.g. for annotation assignments
 function value( node ) {
+// "Short" value form, e.g. for annotation assignments
   if (!node)
     return true;                // `@aBool` short for `@aBool: true`
+  if (universalCsn && node.$inferred === 'prop') // via propagator.js
+    return undefined;
   if (node.$inferred && gensrcFlavor)
     return undefined;
   if (node.path) {
@@ -892,7 +1129,10 @@ function value( node ) {
 
 function enumValue( v, csn, node ) {
   // Enums can have values but if enums are extended, their kind is 'element',
-  // so we check whether the node is inside an extension.
+  // so we check whether the node is inside an extension. (TODO: still?)
+  if (universalCsn && v.$inferred)
+    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 ) );
 }
@@ -911,7 +1151,7 @@ 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.xpr || [ expr ];
+  return !expr.cast && !expr.func && expr.xpr || [ expr ];
 }
 
 function expression( node, dollarExtra ) {
@@ -951,10 +1191,12 @@ function expression( node, dollarExtra ) {
           arg0.xpr.unshift( quantifier.val );
       }
     }
+    if (node.suffix)
+      call.xpr = [].concat( ...node.suffix.map( xprArg ) );
     return extra( call, dollarExtraNode );
   }
   if (node.query)
-    return query( node.query, null, null, 1 );
+    return query( node.query, null, null, null, 1 );
   if (!node.op)                 // parse error
     return { xpr: [] };
   else if (node.op.val === 'xpr')
@@ -964,7 +1206,7 @@ function expression( node, dollarExtra ) {
     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, 1 );
+    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
@@ -974,15 +1216,7 @@ function expression( node, dollarExtra ) {
 function xpr( node ) {
   // if (!node.op) console.log(node)
   const op = operators[node.op.val] || node.op.val.split(' ');
-  const exprs = node.args.map( ( sub ) => {
-    const expr = expression( sub );
-    // return !sub.$parens && !expr.cast && expr.xpr || [ expr ]; if parensAsStrings is gone
-    if (expr.cast || !expr.xpr || sub.$parens && !parensAsStrings)
-      return [ expr ];
-    else if (sub.$parens && sub.op.val !== ',')
-      return [ '(', ...expr.xpr, ')' ];
-    return expr.xpr;
-  } );
+  const exprs = node.args.map( xprArg );
   if (op instanceof Function)
     return op( exprs );
   if (node.quantifier)
@@ -992,6 +1226,27 @@ function xpr( node ) {
   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])
@@ -1015,7 +1270,7 @@ function binaryRightParen( op ) {
   };
 }
 
-function query( node, csn, xsn, expectedParens = 0 ) {
+function query( node, csn, xsn, _prop, expectedParens = 0 ) {
   if (node.op.val === 'SELECT') {
     if (xsn && xsn.query === node && xsn.$syntax === 'projection' &&
        node.from && node.from.path && !projectionAsQuery) {
@@ -1065,7 +1320,7 @@ function columns( xsnColumns, csn, xsn ) {
         addElementAsColumn( col, csnColumns );
     }
   }
-  else {                        // null = use elements
+  else {            // null = use elements - TODO: still used by A2J? -> remove
     for (const name in xsn.elements)
       addElementAsColumn( xsn.elements[name], csnColumns );
   }
@@ -1087,7 +1342,7 @@ function from( node ) {
     return extra( join, node );
   }
   else if (node.query) {
-    return addExplicitAs( query( node.query, null, null, 1 ), node.name );
+    return addExplicitAs( query( node.query, null, null, null, 1 ), node.name );
   }
   else if (!node._artifact || node._artifact._main) { // CQL or follow assoc
     return extra( addExplicitAs( artifactRef( node, false ), node.name ), node );
@@ -1132,12 +1387,6 @@ function addElementAsColumn( elem, cols ) {
   finally {
     gensrcFlavor = gensrcSaved;
   }
-  // FIXME: Currently toHana requires that an '_ignore' property on the elem is
-  // also visible on the column.  Don't ignore virtual columns, let the
-  // renderer decide how to render that column.
-  if (!elem.virtual && elem._ignore)
-    col._ignore = true;
-
   if (elem.value && !elem.$inferred) {
     const parens = elem.value.$parens;
     if (parens)