@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/json/to-csn.js

@@ -37,6 +37,14 @@ let dictionaryPrototype = null;
 // 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 = {
@@ -49,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!
@@ -66,7 +74,7 @@ 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,
@@ -92,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
@@ -177,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
 ];
@@ -196,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 => [
@@ -269,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.
  *
@@ -548,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];
@@ -566,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;
@@ -609,10 +620,18 @@ function set( prop, csn, node ) {
 }
 
 function targetAspect( val, csn, node ) {
+  if (universalCsn) {
+    if (val.$inferred)
+      return undefined;
+    if (node.target) {
+      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;
@@ -624,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;
@@ -655,19 +674,15 @@ 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 );
 }
 
 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?)
@@ -746,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 );
   }
@@ -763,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,
@@ -791,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) {
@@ -802,8 +825,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 = [];
@@ -817,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
@@ -836,8 +869,8 @@ function definition( art, _csn, _node, prop ) {
     delete c.elements;
     c.returns = { elements: elems };
   }
-  if (kind && kind !== 'key')
-    addOrigin( c, art, art._origin );
+  // precondition already fulfilled: art.kind !== 'key'
+  addOrigin( c, art, art );
   return c;
 }
 
@@ -850,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)
@@ -861,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 );
@@ -877,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 || {};
@@ -902,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
@@ -919,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 );
   }
 }
 
@@ -937,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;
@@ -949,36 +1029,38 @@ 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;
 }
 
 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.
@@ -987,20 +1069,44 @@ function kind( k, csn, node ) {
     else if (k === 'extend')
       csn.kind = k;
   }
+  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',
   ].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 && node.$inferred !== 'cast')
     return undefined;
+  if (xsn._origin) {
+    if (xsn._origin.$inferred === 'REDIRECTED') { // auto-redirected user-provided target
+      csn.$origin = definition( xsn._origin );
+    }
+  }
   return artifactRef( node, !node.$extra );
 }
 
+function cardinality( node ) {
+  if (!universalCsn)
+    return standard( node );
+  if (node.$inferred)
+    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
@@ -1104,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) {
@@ -1117,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;
@@ -1274,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 ) };
@@ -1296,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 = {};
@@ -1344,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 );
@@ -1397,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)
@@ -1470,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;

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 );