@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/json/from-csn.js

@@ -705,7 +705,7 @@ let csnFilename = '';
 let virtualLine = 1;
 /** @type {CSN.Location[]} */
 let dollarLocations = [];
-let arrayLvlCnt = 0;
+let arrayLevelCount = 0;
 
 /**
  * @param {Object.<string, SchemaSpec>} specs
@@ -773,12 +773,8 @@ function arrayOf( fn, filter = undefined ) {
     } );
     const minLength = spec.minLength || 0;
     if (minLength > val.length) {
-      error( 'syntax-csn-expected-length', location(true),
-             { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' },
-             {
-               std: 'Expected array in $(PROP) to have at least $(N) items',
-               one: 'Expected array in $(PROP) to have at least one item',
-             } );
+      message( 'syntax-csn-expected-length', location(true),
+               { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' });
     }
     if (val.length)
       ++virtualLine;          // [] in one JSON line
@@ -913,7 +909,7 @@ function definition( def, spec, xsn, csn, name ) {
       ++virtualLine;
     }
   }
-  if (!r.name && name) {
+  if (!r.name && name != null) {
     r.name = { id: name, location: r.location };
     if (prop === 'columns' || prop === 'keys' || prop === 'foreignKeys')
       r.name.$inferred = 'as';
@@ -1002,13 +998,13 @@ function selectItem( def, spec, xsn, csn ) {
   return definition( def, spec, xsn, csn, null ); // definer sets name
 }
 
-function returnsDefinition( def, spec, xsn, csn, name ) {
+function returnsDefinition( def, spec, xsn, csn ) {
   // TODO: be stricter in what is allowed inside returns
   if (!inExtensions)
-    return definition( def, spec, xsn, csn, name );
+    return definition( def, spec, xsn, csn, '' );
   // 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.elements = definition( def, spec, xsn, csn, '' ).elements;
   xsn.$syntax = 'returns';
   return undefined;
 }
@@ -1168,6 +1164,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() };
@@ -1175,22 +1177,39 @@ 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)' );
+    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') {
@@ -1209,12 +1228,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;
@@ -1271,6 +1297,10 @@ function func( val, spec, xsn ) {
 
 function xpr( exprs, spec, xsn, csn ) {
   if (csn.func) {
+    if (!exprs.length) {
+      message( 'syntax-csn-expected-length', location(true),
+               { prop: 'xpr', otherprop: 'func', '#': 'suffix' });
+    }
     xsn.suffix = exprArgs( exprs, spec );
   }
   else {
@@ -1354,12 +1384,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 ) {
@@ -1666,8 +1695,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 +1739,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

@@ -33,12 +33,23 @@ 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');
+
+// XSN $inferred values mapped to Universal CSN $generated values:
+const inferredAsGenerated = {
+  autoexposed: 'exposed',
+  'localized-entity': 'localized',
+  localized: 'localized',       // on elements (texts, localized)
+  'composition-entity': 'composed', // ('aspect-composition' on element not in CSN)
+};
+
 // 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,
@@ -63,11 +74,11 @@ const transformers = {
   precision: value,
   scale: value,
   srid: value,
-  cardinality: standard,            // also for pathItem: after 'id', before 'where'
+  cardinality,                 // also in pathItem: after 'id', before 'where'
   targetAspect,
   target,
   foreignKeys,
-  enum: insertOrderDict,
+  enum: enumDict,
   items,
   includes: arrayOf( artifactRef ), // also entities
   // late expressions / query properties -------------------------------------
@@ -89,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
@@ -199,6 +210,15 @@ const operators = {
   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
 };
 
@@ -536,7 +556,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];
@@ -554,7 +574,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;
@@ -597,10 +617,21 @@ function set( prop, csn, node ) {
 }
 
 function targetAspect( val, csn, node ) {
+  if (universalCsn) {
+    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 );
+      return undefined;
+    }
+  }
   const ta = (val.elements)
     ? addLocation( val.location, standard( val ) )
     : artifactRef( val, true );
-  if (!gensrcFlavor || node.target && !node.target.$inferred)
+  if (!gensrcFlavor && !universalCsn || node.target && !node.target.$inferred)
     return ta;
   // For compatibility, put aspect in 'target' with parse.cdl and csn flavor 'gensrc'
   csn.target = ta;
@@ -622,7 +653,7 @@ function target( val, _csn, node ) {
 }
 
 function items( obj, csn, node ) {
-  if (!keepElements( node ))
+  if (!keepElements( node, obj ))
     return undefined;
   return standard( obj );   // no 'elements' with inferred elements with gensrc
 }
@@ -637,23 +668,42 @@ 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' &&
+      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 );
+}
+
 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;
+  return (universalCsn && select !== select._main._leadingQuery);
 }
 
 // Should we render the elements?  (and items?)
-function keepElements( node ) {
+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
@@ -711,7 +761,8 @@ function ignore() { /* no-op: ignore property */ }
 
 function location( loc, csn, xsn ) {
   if (xsn.kind && xsn.kind.charAt(0) !== '$' && xsn.kind !== 'select' &&
-      (!xsn.$inferred || !xsn._main)) { // TODO: also for 'select'
+      (!xsn.$inferred || !xsn._main) &&
+      xsn.$inferred !== 'REDIRECTED') { // TODO: also for 'select'
     // Also include $location for elements in queries (if not via '*')
     addLocation( xsn.name && xsn.name.location || loc, csn );
   }
@@ -767,8 +818,10 @@ function dictionary( dict, keys, prop ) {
 }
 
 function foreignKeys( dict, csn, node ) {
-  if (universalCsn && !target( node.target, csn, node ))
-    return;
+  if (universalCsn) {
+    if (!target( node.target, csn, node ) || dict[$inferred] === 'keys')
+      return;
+  }
   if (gensrcFlavor && node._origin && node._origin.$inferred === 'REDIRECTED')
     dict = node._origin.foreignKeys;
   const keys = [];
@@ -782,6 +835,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
@@ -801,50 +862,151 @@ function definition( art, _csn, _node, prop ) {
     delete c.elements;
     c.returns = { elements: elems };
   }
+  // precondition already fulfilled: art.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;
+  }
+  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;
   }
-  return csn;
+}
+
+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;
-  }
-  if (main._main)    // well, an element of an query in FROM
-    return definition( art );   // use $origin: {}
+  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.$inferred === 'REDIRECTED')
+    return;
   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.
@@ -853,22 +1015,47 @@ 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 (k === 'action' && node._main && universalCsn && node.$inferred) {
+    // Universal CSN:  do not mention kind: 'action' on expanded action
   }
+  else if (![
+    'element', 'key', 'param', 'enum', 'select', '$join',
+    '$tableAlias', 'annotation', 'mixin',
+  ].includes(k)) {
+    csn.kind = k;
+  }
+  const generated = universalCsn && inferredAsGenerated[node.$inferred];
+  if (typeof generated === 'string')
+    csn.$generated = generated;
 }
 
 function type( node, csn, xsn ) {
-  if (universalCsn && node.$inferred && xsn._origin)
+  if (!universalCsn)
+    return artifactRef( node, !node.$extra );
+  if (node.$inferred)
+    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 ) {
+  if (!universalCsn)
+    return standard( node );
+  // cardinality might be moved to $origin: { cardinality: … }
+  if (node.$inferred || xsn.targetAspect && !xsn.targetAspect.$inferred && xsn.target)
+    return undefined;
+  return standard( node );
+}
+
 function artifactRef( node, terse ) {
   // When called as transformer function, a CSN node is provided as argument
   // for `terse`, i.e. it is usually truthy, except for FROM
@@ -985,7 +1172,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;
@@ -997,7 +1184,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 ) );
 }
@@ -1185,7 +1375,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 );
   }
@@ -1335,6 +1525,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} */
@@ -162,6 +162,17 @@ function parse( source, filename = '<undefined>.cds', options = {}, messageFunct
   if (rulespec.$frontend)
     ast.$frontend = rulespec.$frontend;
 
+  // Warn about unused doc-comments.
+  // Do not warn if docComments are explicitly disabled.
+  if (options.docComment !== false) {
+    for (const token of tokenStream.tokens) {
+      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");
+      }
+    }
+  }
+
   // TODO: clarify with LSP colleagues: still necessary?
   if (parser.messages) {
     Object.defineProperty( ast, 'messages',

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);
 }
 
 /**