@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/json/from-csn.js

@@ -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;
 }
@@ -1271,6 +1267,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 {

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 -------------------------------------
@@ -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
 };
 
@@ -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,41 @@ function elements( dict, csn, node ) {
   return insertOrderDict( dict );
 }
 
+function enumDict( dict, csn, node ) {
+  if (gensrcFlavor && dict[$inferred] ||
+      !keepElements( node ))
+    // no 'elements' with SELECT or inferred elements with gensrc;
+    // hidden or visible 'elements' will be set in query()
+    return undefined;
+  if (universalCsn && node.type && !node.type.$inferred && node.$expand === 'annotate')
+    // derived type of enum type with individual annotations: also set $origin
+    csn.$origin = originRef( node.type._artifact );
+  return insertOrderDict( dict );
+}
+
 function enumerableQueryElements( select ) {
-  if (!universalCsn || select === select._main._leadingQuery)
-    return false;
-  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 +760,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 +817,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 = [];
@@ -801,50 +853,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;
   }
-  return csn;
+  const parent = getParent( xsn );
+  const parentOrigin = getOrigin( parent );
+  if (!xsn._origin || xsn._origin.kind === 'builtin') { // or $dollarVariable
+    if (parentOrigin && (!parent.enum || parent.$origin || !parent.type))
+      csn.$origin = null;
+    return;
+  }
+  // Skip all proxies which do not make it into the CSN, as there are no
+  // individual annotations or redirection targets on it:
+  while (origin._parent && origin._parent.$expand === 'origin')
+    origin = origin._origin || origin.type._artifact;
+  // The while loop is not only for the else case below: when setting implicit
+  // prototypes, it is important that we do not have to follow the prototypes of
+  // other object; we would need to ensure a right order to avoid issues otherwise.
+  if (parentOrigin === getParent( origin )) {
+    // implicit prototype or shortened reference
+    const { id } = origin.name || {};
+    if (id && xsn.name && id !== xsn.name.id)
+      csn.$origin = id;
+    return;
+  }
+  if (origin.kind === 'mixin') {
+    // currently, target and on are always set - nothing to do here, just set type
+    csn.type = 'cds.Association';
+    return;
+  }
+  const ref = originRef( origin, xsn );
+  if (ref) {
+    csn.$origin = ref;
+    return;
+  }
+  // An element of a query with a query in FROM:
+  const anon = definition( origin );   // use $origin: {...} if necessary
+  // as there are no implicit $origin prototypes on sub query elements (yet),
+  // we do not have to care about $origin not being set
+  const { $origin } = anon;
+  if ($origin && typeof $origin === 'object' && !Array.isArray( $origin )) {
+    // repeated anon: flatten
+    csn.$origin = Object.assign( $origin, anon );
+  }
+  else if (Object.keys( anon )
+           // (we can use the properties in `csn`, because addOrigin() is called last)
+    .every( p => p in csn || p === '$origin' || p === '$location')) {
+    // nothing new in $origin: {...}
+    addOrigin( csn, xsn, origin._origin );
+  }
+  else {
+    csn.$origin = anon;
+  }
+}
+
+function getParent( art ) {
+  const parent = art._parent;
+  const main = parent._main;
+  return (main && parent === main._leadingQuery) ? main : parent;
+}
+
+function getOrigin( art ) {
+  if (art._origin)
+    return art._origin;
+  if (hasExplicitProp( art.type ))
+    return art.type._artifact;
+  if (art.includes)
+    return art.includes[0]._artifact;
+  if (art._from)
+    return art._from[0]._origin;
+  return undefined;
 }
 
 function hasExplicitProp( ref ) {
   return ref && !ref.$inferred;
 }
 
-function originRef( art ) {
+function originRef( art, user ) {
   const r = [];
   // do not use name.element, as we allow `.`s in name
-  let main = art;
-  while (main._main && main.kind !== 'select') {
-    const nkind = normalizedKind[main.kind];
-    if (main.name.id || !r.length) // { param: "" } only for return, not elements inside
-      r.push( nkind ? { [nkind]: main.name.id } : main.name.id );
-    main = main._parent;
-  }
-  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 +1006,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
@@ -997,7 +1175,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 +1366,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 );
   }

package/lib/language/antlrParser.js

@@ -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.channel === antlr4.Token.HIDDEN_CHANNEL && token.type === parser.constructor.DocComment && !token.isUsed) {
+        messageFunctions.info('syntax-ignoring-doc-comment', parser.multiLineTokenLocation(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/errorStrategy.js

@@ -114,9 +114,10 @@ function sync( recognizer ) {
     }
     return;
   }
-  // TODO: expected token is identifier, current is KEYWORD
 
   if (nextTokens.contains(antlr4.Token.EPSILON)) {
+    // when exiting a (innermost) rule, remember the state to make
+    // getExpectedTokensForMessage() calculate the full "expected set"
     if (recognizer.$nextTokensToken !== token) {
       // console.log('SET:',token.type,recognizer.state,recognizer.$nextTokensToken && recognizer.$nextTokensToken.type)
       recognizer.$nextTokensToken = token;
@@ -126,13 +127,29 @@ function sync( recognizer ) {
     return;
   }
 
+  // Expected token is identifier, current is (reserved) KEYWORD:
+  // TODO: do not use this if "close enough" (1 char diff) to a keyword in nextTokens
+  //
+  // NOTE: it is important to do this only if EPSILON is not in `nextTokens`,
+  // which means that we cannot bring the better special syntax-fragile-ident
+  // in all cases.  Reason: high performance impact of the alternative,
+  // i.e. calling method Parser#isExpectedToken() = invoking the ATN
+  // interpreter to see behind EPSILON.
+  const identType = recognizer.constructor.Identifier;
+  if (keywordRegexp.test( token.text ) && nextTokens.contains( identType )) {
+    recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text },
+                        '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it' );
+    token.type = identType;     // make next ANTLR decision assume identifier
+    return;
+  }
+
   if (recognizer._ctx._sync === 'nop')
     return;
   switch (s.stateType) {
-    case ATNState.BLOCK_START:
-    case ATNState.STAR_BLOCK_START:
-    case ATNState.PLUS_BLOCK_START:
-    case ATNState.STAR_LOOP_ENTRY:
+    case ATNState.BLOCK_START:  // 3
+    case ATNState.STAR_BLOCK_START: // 5
+    case ATNState.PLUS_BLOCK_START: // 4
+    case ATNState.STAR_LOOP_ENTRY:  // 10
       // report error and recover if possible
       if ( token.text !== '}' &&                          // do not just delete a '}'
           this.singleTokenDeletion(recognizer) !== null) { // also calls reportUnwantedToken
@@ -145,8 +162,8 @@ function sync( recognizer ) {
       }
       throw new InputMismatchException(recognizer);
 
-    case ATNState.PLUS_LOOP_BACK:
-    case ATNState.STAR_LOOP_BACK: {
+    case ATNState.PLUS_LOOP_BACK: // 11
+    case ATNState.STAR_LOOP_BACK: { // 9
       // TODO: do not delete a '}'
       this.reportUnwantedToken(recognizer);
       const expecting = new IntervalSet.IntervalSet();
@@ -425,7 +442,8 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   }
   else if (offendingToken && recognizer.$nextTokensContext &&
            offendingToken === recognizer.$nextTokensToken) {
-    // We have a state (via sync())  with more "expecting" for the same token
+    // Before exiting a rule, we had a state (via sync()) with a bigger
+    // "expecting set" for the same token
     ll1._LOOK( atn.states[recognizer.$nextTokensState], null,
                predictionContext( atn, recognizer.$nextTokensContext ),
                expected, lookBusy, calledRules, true, true );