@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/json/to-csn.js

@@ -12,20 +12,31 @@
 'use strict';
 
 const { locationString } = require('../base/messages');
-const { isDeprecatedEnabled } = require('../base/model');
+const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 
 const compilerVersion = require('../../package.json').version;
 const creator = `CDS Compiler v${ compilerVersion }`;
 const csnVersion = '2.0';
 
+const normalizedKind = {
+  param: 'param',
+  action: 'action',
+  function: 'action',
+};
+
 /** @type {boolean|string} */
 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 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 = {
@@ -50,7 +61,7 @@ const transformers = {
   all: ignore,                  // XSN TODO use quantifier
   // type properties (without 'elements') ------------------------------------
   localized: value,
-  type: t => artifactRef( t, !t.$extra ),
+  type,
   length: value,
   precision: value,
   scale: value,
@@ -59,7 +70,7 @@ const transformers = {
   targetAspect,
   target,
   foreignKeys,
-  enum: insertOrderDict,
+  enum: enumDict,
   items,
   includes: arrayOf( artifactRef ), // also entities
   // late expressions / query properties -------------------------------------
@@ -72,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,
@@ -80,14 +92,14 @@ const transformers = {
   offset: expression,
   on: onCondition,
   // definitions, extensions, members ----------------------------------------
-  returns: standard,            // storing the return type of actions
+  returns: definition,          // storing the return type of actions
   notNull: value,
   default: expression,
   // targetElement: ignore,     // special display of foreign key, renameTo: select
   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,
@@ -128,7 +140,7 @@ const transformers = {
 // which should appear at that place in order.
 const csnPropertyNames = {
   virtual: [ 'abstract' ],      // abstract is compiler v1 CSN property
-  kind: [ 'annotate', 'extend' ],
+  kind: [ 'annotate', 'extend', '$origin' ],
   op: [ 'join', 'func', 'xpr' ],    // TODO: 'func','xpr' into 'quantifier'?  TODO: 'global'(scope)?
   quantifier: [
     'some', 'any', 'distinct',  // 'all' explicitly listed
@@ -148,7 +160,7 @@ const csnPropertyNames = {
   name: [ 'as', 'cast' ],
   location: [ '$env', '$location' ], // --enrich-csn
   expectedKind: [
-    '_type', '_targetAspect', '_target', '_includes', '_links', '_art', '_scope',
+    '_origin', '_type', '_targetAspect', '_target', '_includes', '_links', '_art', '_scope',
   ],                            // --enrich-csn
 };
 
@@ -183,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
 };
 
@@ -194,7 +222,7 @@ const csnDirectValues = [ 'val' ]; // + all starting with '@' - TODO: still rele
 /**
  * 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, $env, elements.
+ * if requested (cloneOptions != false): $location, elements.
  *
  * If cloneOptions is false or if either cloneOptions.testMode or cloneOptions.testSortCsn
  * are set, definitions are also sorted.
@@ -224,24 +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.$env)
-      setHidden(r, '$env', csn.$env);
-    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
@@ -353,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()) {
@@ -371,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 );
     }
   }
 
@@ -389,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;
@@ -450,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 ) {
@@ -499,48 +609,96 @@ 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;
 }
 
 function target( val, _csn, node ) {
   if (gensrcFlavor && node._origin && node._origin.$inferred === 'REDIRECTED')
     val = node._origin.target;
-  if (!val.elements)
+  if (val.elements)
+    return standard( val );       // elements in target (parse-cdl)
+  if (!universalCsn || node.on)
     return artifactRef( val, true );
-  return standard( val );       // elements in target (parse-cdl)
+  const tref = artifactRef( val, true );
+  const proto = node.type && !node.type.$inferred ? node.type._artifact : node._origin;
+  return (proto && proto.target && artifactRef( proto.target, true ) === tref)
+    ? undefined
+    : tref;
 }
 
 function items( obj, csn, node ) {
-  if (!keepElements( node ) && node.type && node.kind !== 'type')
-    // 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 ) {
-  if (csn.from ||
+  if (node.from ||              // do not directly show query elements here
       gensrcFlavor && (node.query || node.type) ||
-      node.type && node.kind !== 'type' && !keepElements( node ))
+      !keepElements( node ))
+    // no 'elements' with SELECT or inferred elements with gensrc;
+    // hidden or visible 'elements' will be set in query()
+    return undefined;
+  return insertOrderDict( dict );
+}
+
+function enumDict( dict, csn, node ) {
+  if (gensrcFlavor && dict[$inferred] ||
+      !keepElements( node ))
     // no 'elements' with SELECT or inferred elements with gensrc;
-    // hidden 'elements' will be set in query()
+    // 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 );
 }
 
-// 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 ) {
+function enumerableQueryElements( select ) {
+  if (!universalCsn || select === select._main._leadingQuery)
+    return false;
+  if (select.orderBy || select.$orderBy)
+    return true;
+  const alias = select._parent;
+  return alias.query && (alias.query._leadingQuery || alias.query) === select;
+}
+
+// Should we render the elements?  (and items?)
+function keepElements( node, line ) {
+  if (universalCsn)
+    // $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:
@@ -626,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;
   }
@@ -644,6 +802,8 @@ function dictionary( dict, keys ) {
 }
 
 function foreignKeys( dict, csn, node ) {
+  if (universalCsn && !target( node.target, csn, node ))
+    return;
   if (gensrcFlavor && node._origin && node._origin.$inferred === 'REDIRECTED')
     dict = node._origin.foreignKeys;
   const keys = [];
@@ -657,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):
@@ -669,22 +829,176 @@ 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;
+}
+
+// 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) {
+    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) {
+    csn.$origin = includesOrigin( xsn.includes, xsn );
+    return;
+  }
+  else if (!xsn._main || xsn.kind === 'select') {
+    return;
+  }
+  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, user ) {
+  const r = [];
+  // do not use name.element, as we allow `.`s in name
+  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 (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;
 }
 
 function kind( k, csn, node ) {
-  if (!node._main && [ 'annotate', 'extend' ].includes( k )) {
+  if (k === 'annotate' || k === 'extend') {
     // We just use `name.absolute` because it is very likely a "constructed"
     // extensions.  The CSN parser must produce name.path like for other refs.
-    csn[k] = node.name.absolute || artifactRef( node.name, true );
-    return undefined;
+    if (!node._main)
+      csn[k] = node.name.absolute || artifactRef( node.name, true );
+    else if (k === 'extend')
+      csn.kind = k;
   }
-  if ([
-    'element', 'key', 'param', 'enum', 'annotate', 'select', '$join',
+  else if (![
+    'element', 'key', 'param', 'enum', 'select', '$join',
     '$tableAlias', 'annotation', 'mixin',
-  ].includes(k))
+  ].includes(k)) {
+    csn.kind = k;
+  }
+}
+
+function type( node, csn, xsn ) {
+  if (universalCsn && node.$inferred && xsn._origin)
     return undefined;
-  return k;
+  return artifactRef( node, !node.$extra );
 }
 
 function artifactRef( node, terse ) {
@@ -786,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) {
@@ -813,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 ) );
 }
@@ -832,23 +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 ];
-}
-
-// TODO: quoted magic names like $now should be complained about in the compiler
-
-function pathRef( path ) {
-  const ref = { ref: path.map( pathItem ) };
-  const nav = path[0]._navigation;
-  if (nav && nav.kind !== '$self' && nav.kind !== 'element' && nav.name.select != null) {
-    setHidden( ref, '$env', (nav.kind === '$navElement')
-      ? nav.name.alias
-      : nav.name.select );
-  }
-  else if ( path[0]._artifact && path[0]._artifact.query ) {
-    setHidden( ref, '$env', true );
-  }
-  return ref;
+  return !expr.cast && !expr.func && expr.xpr || [ expr ];
 }
 
 function expression( node, dollarExtra ) {
@@ -863,8 +1166,8 @@ function expression( node, dollarExtra ) {
     return { ref: [ node.param.val ], param: true }; // CDL rule for runtimes
   }
   if (node.path) {
-    // TODO: global
-    return extra( pathRef( node.path ), dollarExtraNode );
+    // we would need to consider node.global here if we introduce that
+    return extra( { ref: node.path.map( pathItem ) }, dollarExtraNode );
   }
   if (node.literal) {
     if (typeof node.val === node.literal || node.val === null)
@@ -888,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')
@@ -901,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
@@ -911,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)
@@ -929,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])
@@ -952,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) {
@@ -969,7 +1287,10 @@ function query( node, csn, xsn, expectedParens = 0 ) {
       const gensrcSaved = gensrcFlavor;
       try {
         gensrcFlavor = false;
-        setHidden( select.SELECT, 'elements', insertOrderDict( elems ) );
+        if (enumerableQueryElements( node ))
+          select.SELECT.elements = insertOrderDict( elems );
+        else
+          setHidden( select.SELECT, 'elements', insertOrderDict( elems ) );
       }
       finally {
         gensrcFlavor = gensrcSaved;
@@ -999,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 );
   }
@@ -1021,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 );
@@ -1057,25 +1378,15 @@ function addElementAsColumn( elem, cols ) {
       col.excluding = Object.keys( elem.excludingDict );
     // yes, the AS comes after the EXPAND
     addExplicitAs( col, elem.name, neqPath( elem.value ) );
-    // $env and elements (sub queries) in expr are hidden (not set via Object.assign):
-    if (!expr.cast) {
-      if (expr.$env)
-        setHidden( col, '$env', expr.$env );
-      if (expr.elements)
-        setHidden( col, 'elements', expr.elements );
-    }
+    // elements of sub queries (in expr) are hidden (not set via Object.assign):
+    if (!expr.cast && expr.elements)
+      setHidden( col, 'elements', expr.elements );
     if (elem.type && !elem.type.$inferred || elem.target && !elem.target.$inferred)
       cast( col, elem );
   }
   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)
@@ -1162,6 +1473,9 @@ function compactExpr( e ) {     // TODO: 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;
   strictMode = options.testMode;
   const proto = options.dictionaryPrototype;
   // eslint-disable-next-line no-nested-ternary