@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/json/from-csn.js

@@ -89,6 +89,8 @@
 
 const { dictAdd } = require('../base/dictionaries');
 
+const $location = Symbol.for('cds.$location');
+
 let inExtensions = null;
 
 let vocabInDefinitions = null;  // must be reset!
@@ -661,6 +663,9 @@ const schema = compileSchema( {
     ignore: true, type: ignore,
   },
   // TODO: should we keep $parens ?
+  $generated: {
+    type: string,
+  },
   $: { type: ignore, ignore: true }, // including $origin
   _: { type: ignore, ignore: true },
 } );
@@ -705,7 +710,7 @@ let csnFilename = '';
 let virtualLine = 1;
 /** @type {CSN.Location[]} */
 let dollarLocations = [];
-let arrayLvlCnt = 0;
+let arrayLevelCount = 0;
 
 /**
  * @param {Object.<string, SchemaSpec>} specs
@@ -931,8 +936,10 @@ function definition( def, spec, xsn, csn, name ) {
   popLocation( def );
   if (kind !== 'annotation' || prop === 'vocabularies')
     return r;
-  if (!vocabInDefinitions)
+  if (!vocabInDefinitions) {
     vocabInDefinitions = Object.create(null);
+    vocabInDefinitions[$location] = location();
+  }
   vocabInDefinitions[name] = r;     // deprecated: anno def in 'definitions'
   return undefined;
 
@@ -957,6 +964,7 @@ function dictionaryOf( elementFct ) {
       return ignore( dict );
     }
     const r = Object.create(null);
+    r[$location] = location();
     const allNames = Object.keys( dict );
     if (!allNames.length)
       return r;                   // {} in one JSON line
@@ -980,6 +988,7 @@ function keys( array, spec, xsn ) {
   if (!isArray( array, spec ))
     return;
   const r = Object.create(null);
+  r[$location] = location();
   ++virtualLine;
   for (const def of array) {
     const id = def.as || implicitName( def.ref );
@@ -1164,6 +1173,12 @@ function symbol( id, spec, xsn ) { // for CSN property '#'
   xsn.sym = { id, location: location() };
 }
 
+// returns: false = no "...", true = "..." without UP TO, 'upTo' = "..." with UP TO
+function isEllipsis( val ) {
+  return val && typeof val === 'object' && '...' in val && Object.keys(val).length === 1 &&
+    (val['...'] === true || 'upTo');
+}
+
 function annoValue( val, spec ) {
   if (val == null)              // TODO: reject undefined
     return { val, literal: 'null', location: location() };
@@ -1171,22 +1186,40 @@ function annoValue( val, spec ) {
   if (lit !== 'object')
     return { val, literal: lit, location: location() };
   if (Array.isArray( val )) {
-    const ec = val.reduce((c, v) => ((v && v['...'] && Object.keys(v).length === 1) ? ++c : c), 0);
-    if (arrayLvlCnt === 0 && ec > 1) {
-      error( 'syntax-csn-duplicate-ellipsis', location(true), { code: '...' },
-             'Expected no more than one $(CODE)' );
+    /** @type {string|boolean} */
+    let seenEllipsis = false;
+    if (arrayLevelCount > 0) {  // TODO: also inside structure (possible in CSN!)
+      if (val.some( isEllipsis )) {
+        error( 'syntax-csn-unexpected-ellipsis', location(true), { code: '...' },
+               'Unexpected $(CODE) in nested array' );
+      }
     }
-    if (arrayLvlCnt > 0 && ec > 0) {
-      error( 'syntax-csn-unexpected-ellipsis', location(true), { code: '...' },
-             'Unexpected $(CODE) in nested array' );
+    else {
+      for (const item of val) {
+        if (seenEllipsis !== true) {
+          seenEllipsis = isEllipsis( item ) || seenEllipsis;
+        }
+        else if (isEllipsis( item )) { // with or without UP TO
+          // error position at the beginning of the array, but that is fine
+          error( 'syntax-csn-duplicate-ellipsis', location(true), { code: '...' },
+                 'Expected no more than one $(CODE)' );
+          break;
+        }
+      }
     }
-    arrayLvlCnt++;
+    arrayLevelCount++;
     const retval = {
       location: location(),
       val: arrayOf( annoValue )( val, spec ),
       literal: 'array',
     };
-    arrayLvlCnt--;
+    arrayLevelCount--;
+    if (seenEllipsis === 'upTo') {
+      error( 'syntax-csn-expecting-ellipsis', location(true), // at closing bracket
+             { code: '... up to', newcode: '...' },
+             // TODO: should we be more CSN specific in the message?
+             'Expecting an array item $(NEWCODE) after an item with $(CODE)' );
+    }
     return retval;
   }
   if (typeof val['#'] === 'string') {
@@ -1205,12 +1238,19 @@ function annoValue( val, spec ) {
       return refSplit( val['='], '=' );
     }
   }
-  else if (val['...'] && Object.keys(val).length === 1) {
-    return {
+  else if (val['...'] && Object.keys( val ).length === 1) {
+    // TODO: only if not nested - see error above
+    ++virtualLine;
+    const ell = val['...'];
+    const r = {
       val: '...',
       literal: 'token',
       location: location(),
     };
+    if (ell !== true)
+      r.upTo = annoValue( ell, schema['@'] );
+    ++virtualLine;
+    return r;
   }
   const struct = Object.create(null);
   ++virtualLine;
@@ -1354,12 +1394,11 @@ function exprArgs( cond, spec, xsn, csn ) {
 
 function condition( cond, spec ) {
   const loc = location();
-  const x = {
+  return {
     op: { val: 'xpr', location: loc },
     args: exprArgs( cond, spec ),
     location: loc,
   };
-  return x;
 }
 
 function vZeroValue( obj, spec, xsn ) {
@@ -1406,6 +1445,7 @@ function excluding( array, spec, xsn ) {
   if (!isArray( array, spec ))
     return;
   const r = Object.create(null);
+  r[$location] = location();
   ++virtualLine;
   for (const ex of array) {
     const id = string( ex, spec ) || '';
@@ -1666,8 +1706,8 @@ function pushLocation( obj ) {
     error( 'syntax-csn-expected-object', location(true), { prop: '$location' } );
   }
   // hidden feature: string $location
-  const m = /:(\d+)(?::(\d+)(?:-[0-9-]+)?)?$/.exec( loc ); // extra - at end for .refloc
-  if (!m) {
+  const m = /:(\d+)(?::(\d+))?$/.exec( loc ); // extra '^'s at end deliberately left out
+  if (!m) {                     // without location or with '^'s: do not use
     dollarLocations.push( null );
   }
   else {
@@ -1710,8 +1750,10 @@ function toXsn( csn, filename, options, messageFunctions ) {
   csnFilename = filename;
   virtualLine = 1;
   dollarLocations = [];
+  arrayLevelCount = 0;
   inExtensions = null;
   vocabInDefinitions = null;
+
   const xsn = { $frontend: 'json' };
 
   // eslint-disable-next-line object-curly-newline

package/lib/json/to-csn.js

@@ -57,7 +57,7 @@ const transformers = {
   key: value,
   unique: value,
   masked: value,
-  params: insertOrderDict,
+  params,
   // early expression / query properties -------------------------------------
   op: o => ((o.val !== 'SELECT' && o.val !== '$query') ? o.val : undefined),
   from,                         // before elements!
@@ -100,7 +100,7 @@ const transformers = {
   offset: expression,
   on: onCondition,
   // definitions, extensions, members ----------------------------------------
-  returns: definition,          // storing the return type of actions
+  returns,                      // storing the return type of actions
   notNull: value,
   default: expression,
   // targetElement: ignore,     // special display of foreign key, renameTo: select
@@ -185,7 +185,7 @@ const propertyOrder = (function orderPositions() {
 
 // sync with definition in from-csn.js:
 const typeProperties = [
-  'target', 'elements', 'enum', 'items',
+  'target', 'elements', 'enum', 'items', // TODO: notNull?
   'type', 'length', 'precision', 'scale', 'srid', 'localized',
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
 ];
@@ -204,7 +204,10 @@ const operators = {
   when: exprs => [ 'when', ...exprs[0], 'then', ...exprs[1] ],
   case: exprs => [ 'case' ].concat( ...exprs, [ 'end' ] ),
   over: exprs => [ 'over', { xpr: [].concat( ...exprs ) } ],
-  orderBy: exprs => [
+  orderBy: exprs => [ // ORDER BY in generic functions
+    ...exprs[0], ...operators.overOrderBy(exprs.slice(1)),
+  ],
+  overOrderBy: exprs => [ // ORDER BY in OVER() clause
     'order', 'by', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
   ],
   partitionBy: exprs => [
@@ -277,7 +280,7 @@ function sortCsn( csn, cloneOptions = false ) {
 }
 
 /**
- * Check wether the given object has non enumerable property.
+ * 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.
  *
@@ -556,7 +559,7 @@ function sources( srcDict, csn ) {
   }
 }
 
-function attachAnnotations( annotate, prop, dict, inferred, returns = false ) {
+function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
   const annoDict = Object.create( dictionaryPrototype );
   for (const name in dict) {
     const elem = dict[name];
@@ -574,7 +577,7 @@ function attachAnnotations( annotate, prop, dict, inferred, returns = false ) {
       annoDict[name] = sub;
   }
   if (Object.keys( annoDict ).length) {
-    if (returns)
+    if (insideReturns)
       annotate.returns = { elements: annoDict };
     else
       annotate[prop] = annoDict;
@@ -621,10 +624,7 @@ function targetAspect( val, csn, node ) {
     if (val.$inferred)
       return undefined;
     if (node.target) {
-      csn.$origin = { type: 'cds.Composition' };
-      if (node.cardinality)
-        csn.$origin.cardinality = standard( node.cardinality );
-      csn.$origin.target = (val.elements) ? standard( val ) : artifactRef( val, true );
+      csn.$origin = { target: (val.elements) ? standard( val ) : artifactRef( val, true ) };
       return undefined;
     }
   }
@@ -643,7 +643,7 @@ function target( val, _csn, node ) {
     val = node._origin.target;
   if (val.elements)
     return standard( val );       // elements in target (parse-cdl)
-  if (!universalCsn || node.on)
+  if (!universalCsn || gensrcFlavor || node.on)
     return artifactRef( val, true );
   const tref = artifactRef( val, true );
   const proto = node.type && !node.type.$inferred ? node.type._artifact : node._origin;
@@ -674,7 +674,8 @@ function enumDict( dict, csn, 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')
+  if (universalCsn && node.type && !node.type.$inferred && node.$expand === 'annotate' &&
+      node.type._artifact && !node.type._artifact.builtin)
     // derived type of enum type with individual annotations: also set $origin
     csn.$origin = originRef( node.type._artifact );
   return insertOrderDict( dict );
@@ -778,7 +779,7 @@ function addLocation( loc, csn ) {
     // Remove endLine/endCol:
     // Reasoning: $location is mostly attached to definitions/members but the name
     // is often not the reason for an error or warning.  So we gain little benefit for
-    // two more properties.
+    // two more properties. It is also an indication that the location is not exact.
     const val = { file: loc.file, line: loc.line, col: loc.col };
     Object.defineProperty( csn, '$location', {
       value: val, configurable: true, writable: true, enumerable: withLocations,
@@ -806,6 +807,13 @@ function actions( dict ) {
     : undefined;
 }
 
+function params( dict ) {
+  const keys = Object.keys( dict );
+  return (keys.length)
+    ? insertOrderDict( dict )
+    : undefined;
+}
+
 function dictionary( dict, keys, prop ) {
   const csn = Object.create( dictionaryPrototype );
   for (const name of keys) {
@@ -834,6 +842,14 @@ function foreignKeys( dict, csn, node ) {
   csn.keys = keys;
 }
 
+function returns( art, csn, _node, prop ) {
+  // TODO: currently, the `returns` structure might just have been created by the propagator
+  // if that is the case, there should be no reason to store it in universal CSN
+  if (universalCsn && art.$inferred === 'proxy')
+    return undefined;
+  return definition( art, csn, _node, prop );
+}
+
 function definition( art, _csn, _node, prop ) {
   if (!art || typeof art !== 'object')
     return undefined;           // TODO: complain with strict
@@ -854,7 +870,7 @@ function definition( art, _csn, _node, prop ) {
     c.returns = { elements: elems };
   }
   // precondition already fulfilled: art.kind !== 'key'
-  addOrigin( c, art, art._origin );
+  addOrigin( c, art, art );
   return c;
 }
 
@@ -867,7 +883,8 @@ function includesOrigin( includes, art ) {
   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)) {
+      if ((prop.charAt(0) === '@' || prop === 'doc') &&
+          (!art[prop] || art[prop].$inferred)) {
         const anno = aspect[prop];
         if (anno.val !== null)
           // matererialize non-null annos (whether direct or inherited)
@@ -878,9 +895,23 @@ function includesOrigin( includes, art ) {
   return (Object.keys( result ).length === 1) ? $origin : result;
 }
 
-function addOrigin( csn, xsn, origin ) {
-  if (!universalCsn || hasExplicitProp( xsn.type ))
+function addOrigin( csn, xsn, node ) {
+  if (!universalCsn)
+    return;
+  if (hasExplicitProp( xsn.type, 'cast' )) {
+    const main = xsn._main || xsn;
+    let count = 0;
+    let source = xsn;
+    while (source && source._main === main) {
+      source = source.value && source.value._artifact;
+      ++count;
+    }
+    if (count > 0 && source && source.kind !== 'builtin')
+      csn.$source = originRef( source, xsn );
+    else if (count > 1)
+      csn.$source = null;
     return;
+  }
   if (xsn._from) {
     const source = xsn._from[0]._origin;
     csn.$origin = originRef( source );
@@ -894,23 +925,22 @@ function addOrigin( csn, xsn, origin ) {
     csn.$origin = includesOrigin( xsn.includes, xsn );
     return;
   }
-  else if (!xsn._main || xsn.kind === 'select') {
+  let origin = getOrigin( node );
+  if (xsn.$inferred === 'composition-entity') {
+    csn.$origin = originRef( origin, xsn );
+    return;
+  }
+  else if (!isMember( xsn ) || xsn.kind === 'select') {
     return;
   }
+  // from here on: member:
   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))
+  if (!origin) {
+    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 || {};
@@ -919,16 +949,21 @@ function addOrigin( csn, xsn, origin ) {
     return;
   }
   if (origin.kind === 'mixin') {
-    // currently, target and on are always set - nothing to do here, just set type
-    csn.type = 'cds.Association';
+    set( 'type', csn, origin );
+    set( 'cardinality', csn, origin );
+    // currently, target and on are always set - nothing to do here
     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;
   const ref = originRef( origin, xsn );
   if (ref) {
     csn.$origin = ref;
     return;
   }
-  // An element of a query with a query in FROM:
+  // 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
@@ -936,15 +971,26 @@ function addOrigin( csn, xsn, origin ) {
   if ($origin && typeof $origin === 'object' && !Array.isArray( $origin )) {
     // repeated anon: flatten
     csn.$origin = Object.assign( $origin, anon );
+    return;
+  }
+  // Annotations and 'doc' must keep the distinction between direct or inherited,
+  // other properties can as well be set as direct element properties
+  const annos = {};
+  for (const prop of Object.keys( anon )) {
+    if (prop.charAt(0) === '@' || prop === 'doc')
+      annos[prop] = anon[prop];
+    else if (prop === '$source')
+      csn[prop] = anon[prop];   // overwrite from inner
+    else if (prop !== '$location' && prop !== '$origin' && !(prop in csn))
+      csn[prop] = anon[prop];
   }
-  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 );
+  if (Object.keys( annos ).length) {
+    if (!csn.type && $origin)
+      annos.$origin = $origin;
+    csn.$origin = annos;
   }
-  else {
-    csn.$origin = anon;
+  else if (!csn.type) {
+    addOrigin( csn, xsn, origin );
   }
 }
 
@@ -954,10 +1000,27 @@ function getParent( art ) {
   return (main && parent === main._leadingQuery) ? main : parent;
 }
 
+function isMember( art ) {
+  // TODO: introduce art.kind = '$aspect' for anonymous aspect (is a member) ?
+  return !!(art._main || art._outer);
+}
+
+// function getDefinition( art ) {
+//   let main = art._main || art;
+//   while (main._outer)           // anonymous aspect
+//     main = main._outer._main;
+//   return main;
+// }
+
+// XSN `_origin` is (currently?) not the same as _origin in Universal CSN...
+// TODO: at least with expand, set it correctly (alias: keep, assoc: to entity, $builtin: no)
 function getOrigin( art ) {
-  if (art._origin)
-    return art._origin;
-  if (hasExplicitProp( art.type ))
+  if (art.$noOrigin)
+    return undefined;
+  const { _origin } = art;
+  if (_origin)
+    return (_origin.kind === 'builtin') ? undefined : _origin; // not $dollarVariable
+  if (hasExplicitProp( art.type, 'cast' ))
     return art.type._artifact;
   if (art.includes)
     return art.includes[0]._artifact;
@@ -966,31 +1029,31 @@ function getOrigin( art ) {
   return undefined;
 }
 
-function hasExplicitProp( ref ) {
-  return ref && !ref.$inferred;
+function hasExplicitProp( ref, alsoLikeExplicit ) {
+  return ref && (!ref.$inferred || ref.$inferred === alsoLikeExplicit );
 }
 
 function originRef( art, user ) {
   const r = [];
-  // do not use name.element, as we allow `.`s in name
+  // do not use name.element, as we might allow `.`s in name
   let parent = art;
-  while (parent._main && parent.kind !== 'select') {
+  if (parent._outer && parent.kind === 'aspect')
+    r.push( { target: true } );
+  while (isMember( parent ) && parent.kind !== 'select') {
     const nkind = normalizedKind[parent.kind];
-    if (parent.name.id || !r.length)
+    const name = parent.name || parent._outer.name;
+    if (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 } );
+      r.push( !nkind ? name.id : name.id ? { [nkind]: name.id } : { returns: 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: {...}
+    return false;               // do not write, 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.push( parent.name.absolute );
   r.reverse();
   return r;
 }
@@ -1009,6 +1072,9 @@ function kind( k, csn, node ) {
   else if (k === 'action' && node._main && universalCsn && node.$inferred) {
     // Universal CSN:  do not mention kind: 'action' on expanded action
   }
+  else if (k === 'aspect' && (node._outer || node.$inferred)) {
+    return;                     // do not show kind for anonymous aspect
+  }
   else if (![
     'element', 'key', 'param', 'enum', 'select', '$join',
     '$tableAlias', 'annotation', 'mixin',
@@ -1023,26 +1089,20 @@ function kind( k, csn, node ) {
 function type( node, csn, xsn ) {
   if (!universalCsn)
     return artifactRef( node, !node.$extra );
-  if (node.$inferred)
+  if (node.$inferred && node.$inferred !== 'cast')
     return undefined;
   if (xsn._origin) {
     if (xsn._origin.$inferred === 'REDIRECTED') { // auto-redirected user-provided target
       csn.$origin = definition( xsn._origin );
-      return undefined;
     }
   }
-  else if ( xsn.targetAspect && xsn.target ) {
-    // type moved to $origin: { type: … }
-    return undefined;
-  }
   return artifactRef( node, !node.$extra );
 }
 
-function cardinality( node, csn, xsn ) {
+function cardinality( node ) {
   if (!universalCsn)
     return standard( node );
-  // cardinality might be moved to $origin: { cardinality: … }
-  if (node.$inferred || xsn.targetAspect && !xsn.targetAspect.$inferred && xsn.target)
+  if (node.$inferred)
     return undefined;
   return standard( node );
 }
@@ -1150,8 +1210,12 @@ 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 (universalCsn && node.$inferred) {
+    if (node.$inferred === 'prop' || node.$inferred === '$generated') // via propagator.js
+      return undefined;
+    else if (node.$inferred === 'NULL')
+      return null;
+  }
   if (node.$inferred && gensrcFlavor)
     return undefined;
   if (node.path) {
@@ -1163,7 +1227,7 @@ function value( node ) {
   if (node.literal === 'array')
     return node.val.map( value );
   if (node.literal === 'token' && node.val === '...')
-    return extra( { '...': true } );
+    return extra( { '...': !node.upTo || value( node.upTo ) } );
   if (node.literal !== 'struct')
     // no val (undefined) as true only for annotation values (and struct elem values)
     return node.name && !('val' in node) || node.val;
@@ -1320,7 +1384,7 @@ 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) {
-      csn.projection = standard( node );
+      csn.projection = addLocation( node.location, standard( node ) );
       return undefined;
     }
     const select = { SELECT: extra( standard( node ), node, expectedParens ) };
@@ -1342,6 +1406,9 @@ function query( node, csn, xsn, _prop, expectedParens = 0 ) {
         gensrcFlavor = gensrcSaved;
       }
     }
+    // the $location is better put inside the SELECT value, not as sibling (but
+    // we keep it as sibling also for compatibility):
+    addLocation( node.location, select.SELECT );
     return addLocation( node.location, select );
   }
   const union = {};
@@ -1390,11 +1457,13 @@ function from( node ) {
   else if (node.query) {
     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 );
-  }
-  return extra( addExplicitAs( artifactRef( node, false ), node.name, (id) => {
-    const name = node._artifact.name.absolute;
+
+  const ref = artifactRef( node, false );
+  return extra( addExplicitAs( ref, node.name, (id) => {
+    let name = ref.ref ? ref.ref[ref.ref.length - 1] : ref;
+    name = name && name.id || name;
+    if (!name)
+      return false;
     const dot = name.lastIndexOf('.');
     return name.substring( dot + 1 ) !== id;
   }), node );
@@ -1443,7 +1512,7 @@ function addElementAsColumn( elem, cols ) {
 }
 
 function orderBy( node ) {
-  const expr = expression( node, 'ignoreExtra' );
+  const expr = expression( node );
   if (node.sort)
     expr.sort = node.sort.val;
   if (node.nulls)
@@ -1516,6 +1585,9 @@ function compactExpr( e ) {     // TODO: options
   return e && expression( e, true );
 }
 
+/**
+ * @param {CSN.Options} options
+ */
 function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
   gensrcFlavor = options.parseCdl || options.csnFlavor === 'gensrc' ||
                  options.toCsn && options.toCsn.flavor === 'gensrc';

package/lib/language/antlrParser.js

@@ -112,7 +112,7 @@ const rules = {
   expr: { func: 'conditionEOF', returns: 'cond' }, // yes, condition
 };
 
-function parse( source, filename = '<undefined>.cds', options = {}, messageFunctions, rule = 'cdl' ) {
+function parse( source, filename = '<undefined>.cds', options = {}, messageFunctions = null, rule = 'cdl' ) {
   const lexer = new Lexer( new antlr4.InputStream(source) );
   const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
@@ -166,8 +166,8 @@ function parse( source, filename = '<undefined>.cds', options = {}, messageFunct
   // Do not warn if docComments are explicitly disabled.
   if (options.docComment !== false) {
     for (const token of tokenStream.tokens) {
-      if (token.channel === antlr4.Token.HIDDEN_CHANNEL && token.type === parser.constructor.DocComment && !token.isUsed) {
-        messageFunctions.info('syntax-ignoring-doc-comment', parser.multiLineTokenLocation(token), {},
+      if (token.type === parser.constructor.DocComment && !token.isUsed) {
+        messageFunctions.info('syntax-ignoring-doc-comment', parser.tokenLocation(token), {},
           "Ignoring doc-comment as it does not belong to any artifact");
       }
     }

package/lib/language/docCommentParser.js

@@ -69,7 +69,7 @@ function parseDocComment(comment) {
  * @param {string} content
  */
 function isWhiteSpaceOnly(content) {
-  return content.trim().length === 0;
+  return /^\s*$/.test(content);
 }
 
 /**
@@ -127,8 +127,8 @@ function removeFooterFence(line) {
  * @param {string[]} lines
  */
 function isFencedComment(lines) {
-  const index = lines.findIndex((line, index) => {
-    const exclude = (index === 0 || index === lines.length - 1);
+  const index = lines.findIndex((line, i) => {
+    const exclude = (i === 0 || i === lines.length - 1);
     return !exclude && !(/^\s*[*]/.test(line));
   });
   return index === -1 && lines.length > 2;