@sap/cds-compiler 2.11.2 → 2.11.4

package/lib/compiler/index.js

@@ -26,7 +26,6 @@ const resolve = require('./resolver');
 const propagator = require('./propagator');
 const check = require('./checks');
 
-
 const { emptyWeakLocation } = require('../base/location');
 const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
 const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
@@ -144,36 +143,25 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   });
 
   // Read file `filename` and parse its content, return messages
-  function readAndParse( filename ) {
+  async function readAndParse( filename ) {
+    const { sources } = a;
     if ( filename === false )   // module which has not been found
       return [];
-    const rel = a.sources[filename] || path.relative( dir, filename );
+    const rel = sources[filename] || path.relative( dir, filename );
     if (typeof rel === 'object') // already parsed
       return [];                 // no further dependency processing
     // no parallel readAndParse with same resolved filename should read the file,
-    // also ensure deterministic sequence in a.sources:
-    a.sources[filename] = { location: { file: rel } };
+    // also ensure deterministic sequence in sources:
+    sources[filename] = { location: { file: rel } };
 
-    return new Promise( (fulfill, reject) => {
-      cdsFs( fileCache, options.traceFs ).readFile( filename, 'utf8', (err, source) => {
-        if (err) {
-          reject(err);
-        }
-        else {
-          try {
-            const ast = parseX( source, rel, options, model.$messageFunctions );
-            a.sources[filename] = ast;
-            ast.location = { file: rel };
-            ast.dirname = path.dirname( filename );
-            assertConsistency( ast, options );
-            fulfill( ast );
-          }
-          catch (e) {
-            reject( e );
-          }
-        }
-      });
-    });
+    const source = await cdsFs( fileCache, options.traceFs ).readFileAsync( filename, 'utf8' );
+    const ast = parseX( source, rel, options, model.$messageFunctions );
+    sources[filename] = ast;
+    ast.location = { file: rel };
+    ast.dirname = path.dirname( filename );
+    assertConsistency( ast, options );
+
+    return ast;
   }
 
   // Combine the parse results (if there are not file IO errors)

package/lib/compiler/resolver.js

@@ -52,6 +52,7 @@ const { kindProperties } = require('./base');
 const {
   pushLink,
   setLink,
+  annotationVal,
   augmentPath,
   splitIntoPath,
   linkToOrigin,
@@ -359,13 +360,13 @@ function resolve( model ) {
       while (struct.kind === 'element')
         struct = struct._parent;
       if (struct.kind === 'select') {
-        message( 'ref-invalid-typeof', [ ref.location, user ],
+        message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         // we actually refer to an element in _combined; TODO: return null if
         // not configurable; would produce illegal CSN with sub queries in FROM
       }
       else if (struct !== user._main) {
-        message( 'ref-invalid-typeof', [ ref.location, user ],
+        message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         return setProp( ref, '_artifact', null );
       }
@@ -413,6 +414,7 @@ function resolve( model ) {
     for (const view of resolveChain.reverse()) {
       if (view._status !== '_query' ) { // not already resolved
         setProp( view, '_status', '_query' );
+        // must be run in order “sub query in FROM first”:
         traverseQueryPost( view.query, null, populateQuery );
         if (view.elements$)     // specified elements
           mergeSpecifiedElements( view );
@@ -719,35 +721,69 @@ function resolve( model ) {
       else if (exposed.length === 1) {
         target = exposed[0];
       }
-      else {
-        message( (elem !== assoc ? 'redirected-implicitly-ambiguous' : 'type-ambiguous-target'),
-                 [ (elem.value || elem.name).location, elem ],
+      else if (elem === assoc) {
+        // `assoc: Association to ModelEntity`: user-provided target is to be auto-redirected
+        warning( 'type-ambiguous-target',
+                 [ elem.target.location, elem ],
                  {
                    target,
-                   service,
-                   art: definitionScope( target ),
+                   // art: definitionScope( target ), - TODO extra debug info in message
                    sorted_arts: exposed,
-                   '#': ( elemScope !== true ? 'std' : 'scoped' ),
                  }, {
                    // eslint-disable-next-line max-len
-                   std: 'Target $(TARGET) is exposed in service $(SERVICE) by multiple projections $(SORTED_ARTS) - no implicit redirection',
+                   std: 'Replace target $(TARGET) by one of $(SORTED_ARTS); can\'t auto-redirect this association if multiple projections exist in this service',
                    // eslint-disable-next-line max-len
-                   scoped: 'Target $(TARGET) is defined in scope $(ART) which exposed in service $(SERVICE) by multiple projections - no implicit redirection',
+                   two: 'Replace target $(TARGET) by $(SORTED_ARTS) or $(SECOND); can\'t auto-redirect this association if multiple projections exist in this service',
                  });
+        // continuation semantics: no auto-redirection
+      }
+      else {
+        // referred (and probably inferred) assoc (without a user-provided target at that place)
+        // HINT: consider bin/cdsv2m.js when changing the following message text
+        // No grouped and sub messages yet (TODO v3): mention at all target places with all assocs
+        const withAnno = annotationVal( exposed[0]['@cds.redirection.target'] );
+        for (const proj of exposed) {
+          // TODO: def-ambiguous-target (just v3, as the current is infamous and used in options),
+          message( 'redirected-implicitly-ambiguous',
+                   [ weakLocation( proj.location ), proj ],
+                   {
+                     '#': withAnno && 'justOne',
+                     target,
+                     art: elem,
+                     // art: definitionScope( target ), - TODO extra debug info in message
+                     anno: 'cds.redirection.target',
+                     sorted_arts: exposed,
+                   }, {
+                     // eslint-disable-next-line max-len
+                     std: 'Add $(ANNO) to one of $(SORTED_ARTS) to select the entity as redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                     // eslint-disable-next-line max-len
+                     two: 'Add $(ANNO) to either $(SORTED_ARTS) or $(SECOND) to select the entity as redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                     // eslint-disable-next-line max-len
+                     justOne: 'Remove $(ANNO) from all but one of $(SORTED_ARTS) to have a unique redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                   } );
+        }
         // continuation semantics: no implicit redirections
       }
     }
     if (elem.target) {          // redirection for Association to / Composition of
       if (elem.target._artifact === target) // no change (due to no implicit redirection)
         return true;
+      const type = resolvePath( elem.type, 'type', elem ); // cds.Association or cds.Composition
       const origin = {
-        kind: elem.kind,
+        kind: elem.kind, // necessary for rewrite, '$user-provided' would be best
         name: elem.name,
+        type: {
+          path: [ { id: type.name.absolute, location: elem.type.location } ],
+          scope: 'global',
+          location: elem.type.location,
+        },
         target: elem.target,
         $inferred: 'REDIRECTED',
         location: elem.target.location,
       };
       setLink( elem, origin, '_origin' );
+      setLink( elem.type, type, '_artifact' );
+      setLink( origin, elem, '_outer' );
       setLink( origin, elem._parent, '_parent' );
       if (elem._main)           // remark: the param `elem` can also be a type
         setLink( origin, elem._main, '_main' );
@@ -755,11 +791,11 @@ function resolve( model ) {
       setLink( origin, elem._block, '_block' );
       if (elem.foreignKeys) {
         origin.foreignKeys = elem.foreignKeys;
-        delete elem.foreignKeys;
+        delete elem.foreignKeys; // will be rewritten
       }
       if (elem.on) {
         origin.on = elem.on;
-        delete elem.on;
+        delete elem.on;         // will be rewritten
       }
     }
     elem.target = {
@@ -818,10 +854,7 @@ function resolve( model ) {
                                         target._descendants[service.name.absolute] ||
                                         [],
                                         elemScope, target );
-    const preferred = descendants.filter( ( d ) => {
-      const anno = d['@cds.redirection.target'];
-      return anno && (anno.val === undefined || anno.val );
-    } );
+    const preferred = descendants.filter( d => annotationVal( d['@cds.redirection.target'] ) );
     const exposed = preferred.length ? preferred : descendants;
     if (exposed.length < 2)
       return exposed || [];
@@ -860,7 +893,7 @@ function resolve( model ) {
       // Need to filter out auto-exposed, otherwise the behavior is
       // processing-order dependent (not storing the autoexposed in
       // _descendents would only be an alternative w/o recompilation)
-      return descendants.filter( d => !d['@cds.autoexposed'] );
+      return descendants.filter( d => !annotationVal( d['@cds.autoexposed'] ) );
     }
     // try scope as target first, even if it has @cds.redirection.target: false
     if (isDirectProjection( elemScope, target ))
@@ -991,6 +1024,7 @@ function resolve( model ) {
       $inferred: 'autoexposed',
       '@cds.autoexposed': {
         name: { path: [ { id: 'cds.autoexposed', location } ], location },
+        $inferred: 'autoexposed',
       },
     };
     // TODO: do we need to tag the generated entity with elemScope = 'auto'?
@@ -2059,6 +2093,7 @@ function resolve( model ) {
         dependsOnSilent(art, key);
       }
     });
+    obj.foreignKeys[$inferred] = 'keys';
   }
 
   function addForeignKeyNavigations( art ) {
@@ -2227,8 +2262,6 @@ function resolve( model ) {
   // Only top-level queries and sub queries in FROM
 
   function rewriteSimple( art ) {
-    // If we have a proper seperation of view elements and elements of the
-    // primary query, we can delete this function.
     // return;
     if (!art.includes && !art.query) {
       // console.log(message( null, art.location, art, {target:art._target},
@@ -2241,7 +2274,7 @@ function resolve( model ) {
   }
 
   function rewriteView( view ) {
-    traverseQueryPost( view.query, false, ( query ) => {
+    traverseQueryExtra( view, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociation );
     } );
     if (view.includes)          // entities with structure includes:
@@ -2249,6 +2282,7 @@ function resolve( model ) {
   }
 
   // Check explicit ON / keys with REDIRECTED TO
+  // TODO: run on all queries, but this is potentially incompatible
   function rewriteViewCheck( view ) {
     traverseQueryPost( view.query, false, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociationCheck );
@@ -2474,7 +2508,7 @@ function resolve( model ) {
       resolveExpr( cond, rewriteExpr, elem, nav.tableAlias );
     }
     else {
-      // TODO: support that
+      // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ],
              'Selecting unmanaged associations from a sub query is not supported' );
     }
@@ -2880,8 +2914,10 @@ function navProjection( navigation, preferred ) {
     : navigation._projections[0] || null;
 }
 
-// Query tree post-order traversal - called for everything which makes a query
+// Query tree post-order traversal - called for everything which contributes to the query
+// i.e. is necessary to calculate the elements of the query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
+// NOTE: does not run on non-referred sub queries!  Consider using ‹main›.$queries instead!
 function traverseQueryPost( query, simpleOnly, callback ) {
   if (!query)                   // parser error
     return;
@@ -2919,4 +2955,34 @@ function traverseQueryPost( query, simpleOnly, callback ) {
   // else: with parse error (`select from <EOF>`, `select distinct from;`)
 }
 
+// Call callback on all queries in dependency order, i.e. starting with query Q
+// 1. sub queries in FROM sources of Q
+// 2. Q itself, except if non-referred query, but with right UNION parts
+// 3. sub queries in ON in FROM of Q
+// 4. sub queries in columns, WHERE, HAVING
+function traverseQueryExtra( main, callback ) {
+  if (!main.$queries)
+    return;
+  // with a top-level UNION, $queries[0] is just the left
+  traverseQueryPost( main.query, false, (q) => { // also with right of UNION (to be compatible)
+    setProp( q, '_status', 'extra' );
+    callback( q );
+  } );
+  for (const query of main.$queries.slice(1)) {
+    if (query._status === 'extra' || query._parent.kind === '$tableAlias')
+      continue; // if parent is alias, query is FROM source -> run by traverseQueryPost
+    // we are now in the top-level (parent is entity) or a non-referred query (parent is query)
+    setProp( query, '_status', 'extra' ); // do not call callback() in non-referred query
+    // console.log( 'A:', query.name,query._status)
+    traverseQueryPost( query, null, (q) => {
+      if (q._status !== 'extra') {
+        // console.log( 'T:', q.name)
+        setProp( q, '_status', 'extra' );
+        callback( q );
+      }
+      // else console.log( 'E:', q.name)
+    } );
+  }
+}
+
 module.exports = resolve;

package/lib/compiler/shared.js

@@ -7,7 +7,7 @@ const { searchName } = require('../base/messages');
 const { dictAddArray } = require('../base/dictionaries');
 const { setProp } = require('../base/model');
 
-const { setLink, dependsOn } = require('./utils');
+const { setLink, dependsOn, pathName } = require('./utils');
 
 function artifactsEnv( art ) {
   return art._subArtifacts || Object.create(null);
@@ -611,29 +611,24 @@ function fns( model ) {
 
       const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : VolatileFns.environment;
       const env = fn( art, item.location, user, spec.assoc );
-
-      // do not check any elements of the path, e.g. $session - but still don't return path-head
-      if (art && art.$uncheckedElements) {
-        if (env && env[item.id]) // something like $user.id/$user.locale
-          return env[item.id];
-
-        // $user.foo - build our own valid path step obj
-        // Important: Don't directly modify item!
-        const obj = {
-          location: item.location,
-          kind: 'builtin',
-          name: { id: item.id, element: path.map(p => p.id).join('.') },
-        };
-        setLink(obj, art, '_parent');
-        return obj;
-      }
-
       const sub = setLink( item, env && env[item.id] );
 
-      if (!sub)
-        return (sub === 0) ? 0 : errorNotFound( item, env );
-      else if (Array.isArray(sub)) // redefinitions
+      if (!sub) {
+        // element was not found in environment
+        if (sub === 0)
+          return 0;
+        if (art.$uncheckedElements) { // magic variable / replacement variable
+          signalNotFound( 'ref-unknown-var', [ item.location, user ], [ env ],
+                          { id: path.map(n => n.id).join('.') } );
+        }
+        else {
+          errorNotFound( item, env );
+        }
+        return null;
+      }
+      else if (Array.isArray(sub)) { // redefinitions
         return false;
+      }
 
       if (nav) {              // we have already "pseudo-followed" a managed association
         // We currently rely on the check that targetElement references do
@@ -715,7 +710,7 @@ function fns( model ) {
                         { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
       }
       else {
-        signalNotFound( 'ref-undefined-element', [ item.location, user ],
+        signalNotFound( spec.undefinedDef || 'ref-undefined-element', [ item.location, user ],
                         [ env ], { art: searchName( art, item.id, 'element' ) } );
       }
       return null;
@@ -814,7 +809,7 @@ function fns( model ) {
             setProp( a, '_block', block );
             a.$priority = priority;
             if (construct !== art)
-              dictAddArray( art, annoProp, a );
+              addAnnotation( art, annoProp, a );
           }
         }
       }
@@ -865,15 +860,17 @@ function fns( model ) {
       // TODO: _parent, _main is set later (if we have ElementRef), or do we
       // set _artifact?
       anno.$priority = priority;
-      dictAddArray( art, annoProp, anno );
+      addAnnotation( art, annoProp, anno );
     }
   }
 }
 
-// Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
-// locations):
-function pathName(path) {
-  return (path.broken) ? '' : path.map( id => id.id ).join('.');
+// Add annotation to definition - overwriting $inferred annos
+function addAnnotation( art, annoProp, anno ) {
+  const old = art[annoProp];
+  if (old && old.$inferred)
+    delete art[annoProp];
+  dictAddArray( art, annoProp, anno );
 }
 
 module.exports = {

package/lib/compiler/utils.js

@@ -181,6 +181,16 @@ function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = fa
   return false;
 }
 
+/**
+ * Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
+ * locations).
+ *
+ * @param {XSN.Path} path
+ */
+function pathName(path) {
+  return (path.broken) ? '' : path.map( id => id.id ).join('.');
+}
+
 /**
  * Generates an XSN path out of the given name. Path segments are delimited by a dot.
  * Each segment will have the given location assigned.
@@ -215,6 +225,7 @@ module.exports = {
   setMemberParent,
   storeExtension,
   withAssociation,
+  pathName,
   augmentPath,
   splitIntoPath,
 };

package/lib/gen/language.checksum

@@ -1 +1 @@
-e80280336eed20b6633835d33df8ec76
+cde5224056abde61cc2eb0b1b30bf694

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 = {
@@ -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,
@@ -609,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;
@@ -662,12 +681,7 @@ function enumDict( dict, csn, node ) {
 }
 
 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 +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 );
   }
@@ -802,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 = [];
@@ -836,8 +853,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._origin );
   return c;
 }
 
@@ -979,6 +996,8 @@ function originRef( art, user ) {
 }
 
 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 +1006,47 @@ 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 (![
     '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

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

package/lib/language/genericAntlrParser.js

@@ -320,11 +320,12 @@ function multiLineTokenLocation(token, val) {
     return undefined;
 
   // Count the number of newlines in the token.
-  // TODO: I want to avoid a substring, that's why I don't use RegEx here
   const source = token.source[1].data;
   let newLineCount = 0;
   let lastNewlineIndex = token.start;
   for (let i = token.start; i < token.stop; i++) {
+    // Note: We do NOT check for CR, LS, and PS (/[\r\u2028\u2029]/)
+    //       because ANTLR only uses LF for line break detection.
     if (source[i] === 10) { // ASCII code for '\n'
       newLineCount++;
       lastNewlineIndex = i;