@sap/cds-compiler 2.7.0 → 2.10.2

package/lib/json/from-csn.js

@@ -145,7 +145,7 @@ const schemaClasses = {
     type: natnumOrStar,
     msgId: 'syntax-csn-expected-cardinality',
   },
-  column: {
+  columns: {
     arrayOf: selectItem,
     msgId: 'syntax-csn-expected-column',
     defaultKind: '$column',
@@ -238,15 +238,15 @@ const schema = compileSchema( {
     validKinds: [],
   },
   columns: {
-    class: 'column',
+    class: 'columns',
     inKind: [ 'extend' ], // only valid in extend and SELECT/projection
   },
   expand: {
-    class: 'column',
+    class: 'columns',
     inKind: [ '$column' ], // only valid in $column
   },
   inline: {
-    class: 'column',
+    class: 'columns',
     inKind: [ '$column' ], // only valid in $column
   },
   keys: {
@@ -272,7 +272,7 @@ const schema = compileSchema( {
   },
   annotate: {
     type: kindAndName,
-    inKind: (kind => kind === 'annotate'), // using array would test 'entity' for extensions[]
+    inKind: [ 'annotate' ],
   },
   extend: {
     type: kindAndName,
@@ -326,7 +326,7 @@ const schema = compileSchema( {
     inKind: [ 'element', 'type', 'param', 'annotation' ],
   },
   scale: {
-    type: natnum,
+    type: scalenum,
     inKind: [ 'element', 'type', 'param', 'annotation' ],
   },
   srid: {
@@ -609,10 +609,10 @@ const schema = compileSchema( {
     inKind: [ 'entity', 'type', 'aspect', 'event', 'extend' ],
   },
   returns: {
-    type: definition,
+    type: returnsDefinition,
     defaultKind: 'param',
     validKinds: [ 'param' ],
-    inKind: [ 'action', 'function' ],
+    inKind: [ 'action', 'function', 'annotate' ],
   },
   technicalConfig: {            // treat it like external_property
     type: extra,
@@ -739,14 +739,15 @@ function compileSchema( specs, proto = null) {
         throw new Error( `Missing type specification for property "${ p }"` );
     }
   }
-  if (proto)
-    return r;
+  // Set property 'xorGroup' in main and sub schema:
   for (const group in xorGroups) {
     for (const prop of xorGroups[group]) {
       if (r[prop].xorGroup === undefined)
         r[prop].xorGroup = group;
     }
   }
+  if (proto)
+    return r;
   for (const prop of exprProperties) {
     if (r[prop].inValue === undefined)
       r[prop].inValue = true;
@@ -944,7 +945,10 @@ function definition( def, spec, xsn, csn, name ) {
       return s.inKind && s.inKind( kind, spec );
     return s.inKind.includes( kind ) &&
       // for an 'annotate', both 'annotate' and the "host" kind must be expected
-      (!inExtensions || s.inKind.includes( inExtensions ));
+      (!inExtensions || s.inKind.includes( inExtensions ) ||
+       // extending elements in returns can be without 'returns' in CSN
+       // TODO: with warning/info?
+       inExtensions === 'action' && p === 'elements');
   }
 }
 
@@ -992,12 +996,23 @@ function keys( array, spec, xsn ) {
 }
 
 function selectItem( def, spec, xsn, csn ) {
-  if (def === '*')
+  if (def === '*')              // compile() will complain about repeated '*'s
     return { val: '*', location: location() };
 
   return definition( def, spec, xsn, csn, null ); // definer sets name
 }
 
+function returnsDefinition( def, spec, xsn, csn, name ) {
+  // TODO: be stricter in what is allowed inside returns
+  if (!inExtensions)
+    return definition( def, spec, xsn, csn, name );
+  // for the moment, flatten elements in returns in an annotate
+  // TODO: bigger Core Compiler changes would have to be done otherwise
+  xsn.elements = definition( def, spec, xsn, csn, name ).elements;
+  xsn.$syntax = 'returns';
+  return undefined;
+}
+
 // For v1 CSNs with annotation definitions
 function attachVocabInDefinitions( csn ) {
   if (!csn.vocabularies) {
@@ -1124,6 +1139,12 @@ function stringValOrNull( val, spec ) {
   return stringVal(val, spec);
 }
 
+function scalenum( val, spec ) {
+  if ([ 'floating', 'variable' ].includes(val))
+    return { val, literal: 'string', location: location() };
+  return natnum(val, spec );
+}
+
 function natnum( val, spec ) {
   if (typeof val === 'number' && val >= 0)
     //  XSN TODO: do not require literal
@@ -1248,9 +1269,14 @@ function func( val, spec, xsn ) {
   return { path: [ { id: val, location: location() } ], location: location() };
 }
 
-function xpr( exprs, spec, xsn ) {
-  xsn.op = { val: 'xpr', location: location() };
-  xsn.args = exists( exprs, spec, xsn );
+function xpr( exprs, spec, xsn, csn ) {
+  if (csn.func) {
+    xsn.suffix = exprArgs( exprs, spec );
+  }
+  else {
+    xsn.op = { val: 'xpr', location: location() };
+    xsn.args = exprArgs( exprs, spec, xsn );
+  }
 }
 
 function list( exprs, spec, xsn ) {
@@ -1258,15 +1284,15 @@ function list( exprs, spec, xsn ) {
   xsn.args = arrayOf( exprOrString )( exprs, spec, xsn );
 }
 
-function xprInValue( exprs, spec, xsn ) {
+function xprInValue( exprs, spec, xsn, csn ) {
   // if the top-level xpr is just for a cast:
   if (exprs.length === 1 && exprs[0].cast) {
     const x = {};
-    xpr( exprs, spec, x );
+    xpr( exprs, spec, x, csn );
     Object.assign( xsn, x.args[0] );
   }
   else {
-    xpr( exprs, spec, xsn );
+    xpr( exprs, spec, xsn, csn );
   }
 }
 
@@ -1315,9 +1341,9 @@ function exprOrString( e, spec ) {
 }
 
 // mark path argument of 'exits' predicate with $expected:'exists'
-function exists( cond, spec, xsn, csn ) {
-  const rxsn = arrayOf( exprOrString )(cond, spec, xsn, csn);
-  if (Array.isArray(rxsn) && rxsn.some(x => x === 'exists')) {
+function exprArgs( cond, spec, xsn, csn ) {
+  const rxsn = arrayOf( exprOrString )( cond, spec, xsn, csn );
+  if (Array.isArray( rxsn ) && rxsn.some( x => x === 'exists' )) {
     for (let i = 0; i < rxsn.length - 1; i++) {
       if (rxsn[i] === 'exists' && rxsn[i + 1].path)
         rxsn[++i].$expected = 'exists';
@@ -1330,7 +1356,7 @@ function condition( cond, spec ) {
   const loc = location();
   const x = {
     op: { val: 'xpr', location: loc },
-    args: exists( cond, spec ),
+    args: exprArgs( cond, spec ),
     location: loc,
   };
   return x;
@@ -1500,7 +1526,7 @@ function calculateKind( def, spec ) {
     return 'annotate';
   }
   if (spec.prop === 'extensions') {
-    inExtensions = (def.extend) ? '' : 'entity';
+    inExtensions = (def.extend) ? '' : 'annotate';
     return (def.extend) ? 'extend' : 'annotate';
   }
   const kind = (def.kind === 'view') ? 'entity' : def.kind; // 'view' is CSN v0.1.0
@@ -1556,6 +1582,9 @@ function checkAndSetXorGroup( group, prop, xor ) {
     xor[group] = prop;
     return true;
   }
+  if (prop === 'func' && xor[group] === 'xpr' ||
+      prop === 'xpr' && xor[group] === 'func')
+    return true;                // hack for window function: both func and xpr is allowed
   error( 'syntax-csn-excluded-property', location(true),
          { prop, otherprop: xor[group] },
          'CSN property $(PROP) can only be used alternatively to $(OTHERPROP)');

package/lib/json/to-csn.js

@@ -80,6 +80,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 +96,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 +192,13 @@ 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 ] ) ),
+  ],
   // xpr: (exprs) => [].concat( ...exprs ), see below - handled extra
 };
 
@@ -232,22 +240,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 +381,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 +401,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 +423,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 +536,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 +597,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;
 }
 
@@ -528,10 +623,8 @@ 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()
     return undefined;
-  return standard( obj );
+  return standard( obj );   // no 'elements' with inferred elements with gensrc
 }
 
 function elements( dict, csn, node ) {
@@ -553,21 +646,24 @@ 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
+// Should we render the elements?  (and items?)
 function keepElements( node ) {
   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;
+  // 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 +749,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 +782,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,7 +794,14 @@ 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 };
+  }
+  return c;
 }
 
 function addOrigin( csn, xsn ) {
@@ -865,10 +968,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) {
@@ -911,7 +1016,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 +1056,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 +1071,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 +1081,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 +1091,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 +1135,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) {
@@ -1087,7 +1207,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 +1252,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)

package/lib/language/errorStrategy.js

@@ -245,6 +245,7 @@ function reportIgnoredWith( recognizer, t ) {
 }
 
 function consumeUntil( recognizer, set ) {
+  // TODO: add trace
   if (SEMI == null)
     SEMI = recognizer.literalNames.indexOf( "';'" );
   if (RBRACE == null)

package/lib/language/genericAntlrParser.js

@@ -77,6 +77,7 @@ GenericAntlrParser.prototype = Object.assign(
     noAssignmentInSameLine,
     noSemicolonHere,
     setLocalToken,
+    setLocalTokenIfBefore,
     excludeExpected,
     isStraightBefore,
     meltKeywordToIdentifier,
@@ -183,6 +184,14 @@ function setLocalToken( string, tokenName, notBefore, inSameLine ) {
     ll1.type = this.constructor[tokenName];
 }
 
+function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
+  const ll1 = this.getCurrentToken();
+  if (ll1.text.toUpperCase() === string &&
+      (!inSameLine || this._input.LT(-1).line === ll1.line) &&
+      (!before || before && before.test( this._input.LT(2).text )))
+    ll1.type = this.constructor[tokenName];
+}
+
 // // Special function for rule `requiredSemi` before return $ctx
 // function braceForSemi() {
 //   if (RBRACE == null)