@sap/cds-compiler 5.4.2 → 5.5.0

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.1.16
+// Base class for generated parser, for redepage v0.1.18
 
 'use strict';
 
@@ -12,28 +12,33 @@
  // and this.conditionStackLength and returns true?
 
 class BaseParser {
+  keywords;
+  table;
+  lexer;
+
+  tokens = undefined;
+  eofIndex = undefined;
+  tokenIdx = 0;
+  recoverTokenIdx = -1;
+  conditionTokenIdx = -1; // TODO: can we use recoverTokenIdx ?
+  errorTokenIdx = -1;
+  fixKeywordTokenIdx = -1;
+  conditionStackLength = -1;
+  nextTokenAsId = false;
+
+  s = null;
+  errorState = null;
+  stack = [];
+  dynamic_ = {};                // TODO: extra class
+  prec_ = null;
+  $hasErrors = null;
+  // trace:
+  trace = [];
+
   constructor( lexer, keywords, table ) {
-    this.keywords = keywords;
+    this.keywords = { __proto__: null, ...keywords };
     this.table = compileTable( table );
     this.lexer = lexer;
-    this.tokens = undefined;
-    this.eofIndex = undefined;
-    this.tokenIdx = 0;
-    this.recoverTokenIdx = -1;
-    this.conditionTokenIdx = -1; // TODO: can we use recoverTokenIdx ?
-    this.errorTokenIdx = -1;
-    this.fixKeywordTokenIdx = -1;
-    this.conditionStackLength = -1;
-    this.nextTokenAsId = false;
-
-    this.s = null;
-    this.errorState = null;
-    this.stack = [];            // [{ ruleState, followState, tokenIdx }]
-    this.dynamic_ = {};
-    this.prec_ = null;
-    this.$hasErrors = null;
-    // trace:
-    this.trace = [];
   }
 
   init() {
@@ -42,6 +47,38 @@ class BaseParser {
     return this;
   }
 
+  _saveForWalk() {
+    return {
+      s: this.s,
+      stack: this.stack,
+      dynamic_: this.dynamic_,
+      prec_: this.prec_
+    };
+  }
+
+  _cloneFromSaved( saved ) {    // non-deep: Object.assign
+    this.s = saved.s;
+    this.stack = saved.stack.map( obj => ({ ...obj }) );
+    this.dynamic_ = this._cloneDynamic( saved.dynamic_ );
+    this.prec_ = saved.prec_;
+  }
+
+  _cloneDynamic( dynamic_ ) {
+    let chain = [];
+    while (dynamic_ !== Object.prototype) {
+      const obj = {};
+      for (const [ prop, val ] of Object.entries( dynamic_ ))
+        obj[prop] = Array.isArray( val ) ? [ ...val ] : val;
+      chain.push( obj );
+      dynamic_ = Object.getPrototypeOf( dynamic_ );
+    }
+    let copy = Object.prototype;
+    let { length } = chain;
+    while (--length >= 0)
+      copy = { __proto__: copy, ...chain[length] };
+    return copy;
+  }
+
   // methods for actions --------------------------------------------------------
 
   la() {                        // lookahead: complete token
@@ -65,29 +102,39 @@ class BaseParser {
     const la = this.tokens[this.tokenIdx];
     if (!this.nextTokenAsId)
       return la.keyword || la.type;
+    // return la.keyword && this.table[this.s][la.keyword] && la.keyword || la.type;
     this.nextTokenAsId = false;
     return la.type;
   }
 
   e() {                         // error: report and recover
     const la = this.tokens[this.tokenIdx];
-    if (this.trace.length > 1)
-      this._trace( 'detected parsing error,', la );
-    this.reportUnexpectedToken_( la );
-    la.parsedAs = '';           // current token is erroneous
+    this._trace( 'detect parsing error,' );
+    if (this.errorTokenIdx === this.tokenIdx)
+      throw Error( `Already reported error for ${ tokenFullName( la ) } at ${ la.location }`);
 
-    if (this.errorTokenIdx === this.tokenIdx) {
-      // TODO: investigate why this is not handled otherwise
-      this.reportInternalError_( la );
-      this.skipToken_();
-      return false;
-    }
+    la.parsedAs = '';           // current token is erroneous
     this.errorTokenIdx = this.tokenIdx;
     this.conditionStackLength = null;
 
-    const { rewindDepth, syncSet } = this._calculateSyncSet();
-    const recoverDepth = this._findSyncToken( syncSet, rewindDepth );
-    this._recoverFromError( rewindDepth, recoverDepth );
+    let { length } = this.stack;
+    while (--length && this.tokenIdx === this.stack[length].tokenIdx)
+      this.stack[length].followState = null;
+    if (++length === this.stack.length) // last good state in current rule
+      return this._reportAndRecover();
+
+    this.stack[length].followState = this.errorState;
+    this.s = null;
+    return false;
+  }
+
+  _reportAndRecover() {
+    this.s = this.errorState;
+    this.reportUnexpectedToken_();
+    const syncSet = this._calculateTokenSet( 'Y' );
+    const recoverDepth = this._findSyncToken( syncSet );
+    this._trace( 'recover from error,' );
+    this._recoverFromError( recoverDepth );
     return false;
   }
 
@@ -108,26 +155,15 @@ class BaseParser {
     this.s = 0;
     // TODO: also have recursive flag in stack: was rule was called recursively?
     // extra val 'gr' when rule was called when it could reach the rule end
-    const { type: lt, keyword: lk } = this.tokens[this.tokenIdx];
-    if (lk &&            // Id also for unreserved, except after condition failure
-        follow?.[0] === 'Id' && this.keywords[lk] !== false &&
+    const { type, keyword } = this.tokens[this.tokenIdx];
+    if (keyword &&            // Id also for unreserved, except after condition failure
+        follow?.[0] === 'Id' && !this.keywords[keyword] &&
         this.fixKeywordTokenIdx !== this.tokenIdx ||
-        follow?.includes( lk || lt )) {
+        follow?.includes( keyword || type )) {
       this._tracePush( [ 'E', true ] );
       return true;
     }
-    this._tracePush( [ 'E', 0 ] );
-    // TODO: caching
-    const { dynamic_ } = this;
-    let match;
-    let depth = this.stack.length;
-    while (match == null && --depth) {
-      this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
-      const { followState } = this.stack[depth];
-      match = this._pred_next( followState, lt, lk, 'E' );
-      this._traceSubPush( match ?? 0 );
-    }
-    this.dynamic_ = dynamic_;
+    const match = this._matchesInFollow( type, keyword, 'E' );
     // If the parser reaches this point with match = null, even the top-level rule
     // does not have a required token (typically `EOF`) at the end → the parser
     // must accept any token → rule exit possible (but no output '✔' in trace).
@@ -156,16 +192,19 @@ class BaseParser {
     const lk = this.tokens[this.tokenIdx].keyword;
     // As opposed to ei(), we also check for reserved keywords here; this way, we
     // do not have to add reserved keywords from the follow-set to the `switch`.
-    if (!lk || this.keywords[lk] === false) // TODO: consider fixKeywordTokenIdx ?
+    if (!lk || this.keywords[lk]) // TODO: consider fixKeywordTokenIdx ?
       return this.g( state, follow );
     this.nextTokenAsId = true;
     return false;               // do not execute action after it
   }
 
   // instead of gi() at rule end (RuleEnd_ in follow-set) for `Id_restricted`
+  // TODO: investigate why this is just used once - should be for all no-`as`
+  // cases
   giR( state, follow ) { // go to state (after trying to test again as identifier)
-    const lk = this.tokens[this.tokenIdx].keyword;
-    if (!lk || this.keywords[lk] === false || this._keyword_after_rule( lk ))
+    const { keyword } = this.tokens[this.tokenIdx];
+    if (!keyword || this.keywords[keyword] ||
+        this._matchesInFollow( 'Id', keyword, 'R' ))
       return this.g( state, follow );
     this.nextTokenAsId = true;
     return false;               // do not execute action after it
@@ -206,10 +245,8 @@ class BaseParser {
   }
 
   c( state, parsedAs = 'token' ) { // consume token
-    const la = this.tokens[this.tokenIdx];
+    const la = this.tokens[this.tokenIdx++]; // ++ now also for EOF
     la.parsedAs = parsedAs;
-    if (this.tokenIdx < this.eofIndex) ++this.tokenIdx;
-    // TODO: handle identifier-including-reserved-words later (e.g. for id after a `.`)
     this.s = state;
     this.errorState = state;
     if (this.constructor.tracingParser)
@@ -220,8 +257,8 @@ class BaseParser {
   // instead of c() for identifiers, used both with l() and lk()
   ci( state, ident = 'ident' ) {   // consume identifier token
     const la = this.tokens[this.tokenIdx];
-    if (this.keywords[la.keyword] === false)
-      this.reportReservedWord_( la );
+    if (this.keywords[la.keyword])
+      this.reportReservedWord_();
     // with error recovery: use that (consider this having a good score)
     return this.c( state, ident )
   }
@@ -303,7 +340,7 @@ class BaseParser {
 
   rule_( state, followState = -1 ) { // start rule
     this.s = state;
-    this._trace( [ 'call rule', state, ' at alt start' ], this.la() );
+    this._trace( [ 'call rule', state, ' at alt start' ] );
     this.stack.push( {
       ruleState: state,
       followState,
@@ -330,21 +367,20 @@ class BaseParser {
              : ' prematurely');
       const text = immediately ? '⚠ exit rule' : '⏎ exit rule';
       this.s = caller.followState; // for trace
-      this._trace( [ text, caller.ruleState, post, this.stack.length + 1 ],
-                   this.la() );
-      if (this.tokenIdx === caller.tokenIdx &&
-          this.stack.at(-1)?.followState != null)
+      this._trace( [ text, caller.ruleState, post, this.stack.length + 1 ] )
+      if (immediately && this.stack.at(-1)?.followState != null)
         this.trace = [ this.errorState ]; // show last good state in trace
     }
     this.s = caller.followState;
+    if (immediately)
+      return this.s != null && this._reportAndRecover();
+
     this.prec_ = caller.prec;
     if (this.s)
-      this._skipErrorTokens();
+      this._skipErrorTokens();  // TODO: re-think - directly with _reportAndRecover() ?
     else if (this.s == null)
-      return !immediately;      // attached actions are executed even with "unsuccessful exit"
+      return true;  // attached actions are executed even with "unsuccessful exit"
 
-    if (immediately)
-      return false;
     this.errorState = this.s;
     return true;
   }
@@ -353,12 +389,12 @@ class BaseParser {
   lP( first2 ) {             // only start rule if this predicate returns true
     // nothing to check if not a non-reserved keyword:
     const { keyword: lk1 } = this.tokens[this.tokenIdx];
-    if (!lk1 || !this.keywords[lk1])
+    if (!lk1 || this.keywords[lk1] !== 0)
       return true;
 
     const { type: lt2, keyword: lk2 } = this.tokens[this.tokenIdx + 1];
     // Argument first2 is just a performance hint with ckP():
-    if (lk2 && first2?.[0] === 'Id' && this.keywords[lk2] !== false ||
+    if (lk2 && first2?.[0] === 'Id' && !this.keywords[lk2] ||
         first2?.includes( lk2 || lt2 )) {
       this._tracePush( [ 'K', true ] );
       return true;
@@ -370,11 +406,13 @@ class BaseParser {
       throw Error( `Unexpected command '${ cmd?.[0] }' without prediction at state ${ this.s } for ‘${ lk1 }’` );
 
     // if not the keyword match, the command is “goto” or “rule call”
-    const nextState = (cmd[0] === 'ck') ? cmd[1] : this._pred_keyword( cmd[1], lk1 );
+    const savedState = this.s;
+    this.s = (cmd[0] === 'ck') ? cmd[1] : this._pred_keyword( cmd[1], lk1 );
 
     ++this.tokenIdx;            // for user lookahead fns and conditions
-    const match = this._pred_next( nextState, lt2, lk2, 'K' );
+    const match = this._pred_next( lt2, lk2, 'K' );
     --this.tokenIdx;
+    this.s = savedState;
 
     const r = match ?? true;
     if (match == null)
@@ -416,34 +454,43 @@ class BaseParser {
     throw Error( 'Not supported: option for unreserved keywords in follow set' );
   }
 
-  _pred_next( state, type, keyword, mode ) {
+  _pred_next( type, keyword, mode ) { // mode = K | E | R | M
+    const useConditions = (mode === 'M'); // TODO: extra method with conditions ?
     let hasEnteredRule = false;
-    while (state) {
-      this._traceSubPush( state );
-      let cmd = this.table[state];
+    while (this.s) {
+      if (useConditions)
+        this._tracePush( this.s );
+      else
+        this._traceSubPush( this.s );
+      let cmd = this.table[this.s];
       if (!Array.isArray( cmd )) {
         const lookahead = cmd[' lookahead'];
-        cmd = lookahead
-          ? cmd[this[lookahead]( mode )] || cmd['']
-          : keyword && cmd[keyword] || cmd[type] || cmd[''];
+        const c = lookahead         // TODO: call with { keyword, type } ?
+          ? cmd[this[lookahead]( mode )]
+          : keyword && cmd[keyword] || cmd[type];
+        cmd = !(c && useConditions && this._rejectCondition( c, mode )) && c || cmd[''];
       }
       switch (cmd[0]) {
-        case 'c': case 'ck': case 'ciA': case 'ckA': // TODO: re-check ckA
+        case 'c': case 'ck': case 'ckA': // TODO: re-check ckA
           return true;
+        case 'ciA':
+          return mode !== 'R';
+          // in the R prediction for optional `Id<reserved>` at rule end, only
+          // alternative keyword matches are preferred, not identifier matches
         case 'ci':
           if (!keyword ||
-              this.keywords[keyword] !== false && this.fixKeywordTokenIdx !== this.tokenIdx)
-            return true;
-          cmd = this.table[state]['']; // is currently always 'g' or 'e'
+              !this.keywords[keyword] && this.fixKeywordTokenIdx !== this.tokenIdx)
+            return mode !== 'R';
+          cmd = this.table[this.s]['']; // is currently always 'g' or 'e'
           break;
         case 'm':
           return type === cmd[2];
         case 'mi':
-          return type === 'Id' &&
+          return type === 'Id' && mode !== 'R' &&
             (!keyword ||
-             this.keywords[keyword] !== false && this.fixKeywordTokenIdx !== this.tokenIdx);
+             !this.keywords[keyword] && this.fixKeywordTokenIdx !== this.tokenIdx);
         case 'miA':
-          return type === 'Id';
+          return type === 'Id' && mode !== 'R';
         case 'mk':
           return keyword === cmd[2];
         case 'g': case 'e':
@@ -458,11 +505,16 @@ class BaseParser {
           // rule, we would have to handle `this.stack` and `this.dynamically_`.
       }
       // We could optimize with rule call - only 'Id' must be further investigated
-      state = cmd[1];
+      // TODO: actually also with `g`
+      // in both cases if no condition is evaluated
+      this.s = cmd[1];
+      // TODO <prepare=…, arg=…> for real trial run also before all returns
+      // if (cmd[5])
+      //   this.cmd[5]( cmd[4], mode );
     }
     // If invalid state, the second token does not match, e.g. for `VIRTUAL +`
-    // or `VIRTUAL §` (with IllegalToken):
-    if (state == null)
+    // or `VIRTUAL ⎀` (with IllegalToken):
+    if (this.s == null)
       return false;
 
     // Otherwise, the parser could end the rule after having matched the keyword
@@ -474,143 +526,207 @@ class BaseParser {
     return !hasEnteredRule && null; // let caller decide how to interpret this
   }
 
-  _keyword_after_rule( keyword ) {
-    // TODO: this is a slow implementation - do dedicated traversal later
-    // It is used in giR() only and this is currently used just once.
-    // TODO: using mode = 'R' and tracing R(…)
-    // TODO: investigate why this was not written before adding
-    // `<default=fallback>` in rule `fromRefWithOptAlias`.
-    return this._expecting()[keyword];
+  _rejectCondition( cmd, mode ) {
+    const cond = cmd[3];
+    if (!cond)
+      return false;
+    if (!this.constructor.tracingParser)
+      return !this[cond]( mode, cmd[4] );
+      // TODO: let this[cond]( true ) return recovery badness in error case
+    const { traceName } = this[cond];
+    this._tracePush( [ 'C', traceName?.call( this, cmd[4] ) ?? cond ] );
+    // calling the condition might have side effects (precendence conditions have)
+    // → call tracing “name” before
+    const fail = !this[cond]( mode, cmd[4] );
+    this._traceSubPush( !fail );
+    return fail;
   }
 
-  // Set of expected tokens: for error reporting and recovery -------------------
-
-  // method like _exp_collect - conditions in called rules are evaluated with
-  // unchanged stack and dynamic & no site-effects (are run with extra mode)
-
-  // Calculate array of expected tokens
-  _expecting( token ) {
-    // Remark: rules must not have been exited too early, see _expecting call in re()
-    const stack = this.stack.slice( 0, this.stack.length );
-      // Immediately exit rules when no tokens have yet been consumed:
-    let caller = stack.at( -1 );
-    while (stack.length && this.tokenIdx === caller.tokenIdx) {
-      --stack.length;
-      caller = stack.at( -1 );
-    }
-    // Now calculate dictionary of expected tokens:
-    const expecting = Object.create(null);
-    let state = this.errorState;
-    // At potential rule end, we must add follow sets of outer rules
-    // TODO: we also need to unravel this.dynamic_ for translateParserToken_()
-    while ((!state || this._exp_collect( expecting, this.table[state] )) && stack.length)
-      state = stack.pop().followState;
-
-    // Remove token (TODO later: instead, use conditions when collecting tokens):
-    if (token) {
-      const { keyword, type } = token;
-      if (keyword && expecting[keyword] === true)
-        delete expecting[keyword];
-      else if (expecting[type] === true)
-        delete expecting[type];
+  _matchesInFollow( type, keyword, mode ) { // mode = E | R
+    this._tracePush( [ mode, 0 ] );
+    const savedState = this.s;
+    // TODO: caching
+    const { dynamic_ } = this;
+    let match;
+    let depth = this.stack.length;
+    // TODO: currently assumes that lookahead does not use stack.at()
+    while (match == null && --depth) {
+      this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
+      this.s = this.stack[depth].followState;
+      match = this._pred_next( type, keyword, mode );
+      this._traceSubPush( match == null ? 0 : match === (mode !== 'R') );
+      // successfully matching a keyword in giR() means unsuccessful match as
+      // reserved identifer
     }
-    return expecting;
+    this.dynamic_ = dynamic_;
+    this.s = savedState;
+    return match;
   }
 
-  // TODO: use iterative alg, no recursive call, return state instead -----------
-  // Add expected tokens to dictionary `expecting` starting at command `cmd`.
-  // Return true if the rule end is reached, i.e. we also need to add the expected
-  // tokens at the follow state of the current rule.  Argument `prop` is the token
-  // name for `cmd` in a decision.
-
-  // translateParserToken must work, i.e. this.stack and this.dynamic_ must be
-  // according to stack level
-  _exp_collect( expecting, cmd, prop, val = true ) {
-    if (prop != null)
-      cmd = cmd[prop];
-    else if (!cmd)              // called on follow state of start rule
-      return false;
-
-    if (!Array.isArray( cmd )) {
-      let reachedRuleEnd = false;
-      for (const tok in cmd) {
-        // TODO: except for `Id`, we can directly continue if `tok` is already in
-        // `expecting`
-        if (Object.hasOwn( cmd, tok ) && tok.charAt(0) !== ' ' &&
-            this._exp_collect( expecting, cmd, tok, val ))
-          reachedRuleEnd = true;
+  _confirmExpected( token, saved ) { // mode = M
+    const [ type, keyword ] = (/^[_a-z]/.test( token )) ? [ 'Id', token ] : [ token ];
+    Object.assign( this.la(), { type, keyword } );
+    this._cloneFromSaved( saved );
+    this.trace = [];
+    let match;
+    while (this.stack.length) {
+      match = this._pred_next( type, keyword, 'M' );
+      if (match != null) {
+        this._tracePush( { true: '✔', false: '✖' }[match] );
+        break;
       }
-      return reachedRuleEnd;
+      this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
+      this.s = this.stack.pop().followState;
     }
-    switch (cmd[0]) {
-      case 'c': case 'ck':
-        expecting[prop] ??= val;
-        return false;
-      case 'ckA':
-        for (const tok of this.translateParserToken_( prop ))
-          expecting[tok] ??= val;
-        return false;
-      case 'm': case 'mk':
-        expecting[cmd[2]] ??= val;
-        return false;
-      case 'ci': case 'ciA': case 'mi': case 'miA':
-        expecting['Id'] ??= val;
-        // TODO: should we do s/th special, such that a reserved word is a sync
-        // token for Id<all>?  Probably not, see also comment in _findSyncToken()
-        return false;
-      case 'g': case 'gi':
-        if (!cmd[1])
-          return cmd[1] === 0;
-        //(this.stack[this.stack.length - 1].tokenIdx === this.tokenIdx);
-        // TODO: add some assertion in generation that a decision has no two `g`s
-        // to the same state (both in cases and default)
-        // UPDATE: no, there will be at least gP()s
-        // TOOD: do properly for (...)+ - currently, the token for directly
-        // exiting the rule is also collected
-        return this._exp_collect( expecting, this.table[cmd[1]], undefined, val );
-      default:
-        // a called rule must match at least one token → after having called a
-        // rule, do not collect expecting tokens after exiting the rule
-        if (typeof cmd[0] === 'number')
-          this._exp_collect( expecting, this.table[cmd[1]], undefined, val );
-        return false;
+    if (this.constructor.tracingParser) {
+      this.stack = saved.stack; // influences indentation
+      this._trace( tokenName( token ), 2 );
+    }
+    return match ?? true;
+  }
+
+  // Set of expected and sync tokens: for error reporting and recovery ----------
+
+  // Calculate array of expected tokens / error sync set
+  _calculateTokenSet( mode ) {  // mode = M | Y
+    this._tracePush( [ mode ] );
+    // TODO later (after trying different synchronization tokens), we could use
+    // one set for both M and Y, the latter just adds more tokens to it
+    const savedState = this.s;
+    const savedDynamic = this.dynamic_;
+    const savedStack = this.stack;
+    this.stack = [ ...savedStack ];
+    this.s = this.errorState;
+
+    const set = Object.create(null);
+    // Add follow sets of outer rules if at potential rule end
+    if (mode === 'M') {         // for messages
+      while (this.stack.length && this._tokenSetInRule( set, true )) {
+        this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
+        this.s = this.stack.pop().followState;
+      }
     }
+    else {                      // or always when calculating the sync-set
+      let val = this.stack.length + 1;
+      while (this.stack.length) {
+        if (!this._tokenSetInRule( set, val ))
+          val = this.stack.length;
+        // TODO: use new _tracePush if `val` changes, probably also use Y‹val›(…)
+        this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
+        this.s = this.stack.pop().followState;
+      }
+      set.EOF ??= 0;
+    }
+    this.stack = savedStack;
+    this.s = savedState;        // should be the errorState anyway - TODO: confirm
+    this.dynamic_ = savedDynamic;
+    return set;
+  }
+
+  // Filter after this fn for conditions via interpreter call after: consider
+  //   ( <prefer, guard=fail> 'foo' | rule ) with
+  //   rule : 'foo' | Id ;
+  // doing it already here would list `foo` as expected token
+  _tokenSetInRule( expecting, val, cmd ) {
+    const savedDynamic = this.dynamic_;
+    const savedState = this.s;
+    let enteredRules = 0;
+    loop: while (this.s) {
+      cmd ??= this.table[this.s];
+      if (!Array.isArray( cmd )) {
+        const lookahead = cmd[' lookahead'];
+        const dict = cmd;
+        for (const prop in dict) {
+          if (prop && Object.hasOwn( dict, prop ) && prop !== 'Id' &&
+              !Object.hasOwn( expecting, prop ) && prop.charAt(0) !== ' ') {
+            if (lookahead) {    // yes, independently from ckA()
+              for (const p of this.translateParserToken_( prop, lookahead ))
+                expecting[p] = val;
+            }
+            else {
+              expecting[prop] = val;
+            }
+          }
+        }
+        cmd = dict[''];
+        if (dict.Id) {
+          // recursive call only if Id branch with non-error default branch
+          if (cmd[0] === 'e') {
+            cmd = dict.Id;
+          }
+          else {                // Id branch never leads to rule exit:
+            this._tracePush( [ '[' ] );
+            this._tokenSetInRule( expecting, val, dict.Id );
+            this._tracePush( [ ']' ] );
+          }
+        }
+      }
+      this._traceSubPush( this.s );
+      switch (cmd[0]) {
+        case 'm': case 'mk':
+          expecting[cmd[2]] ??= val;
+          break loop;
+        case 'ci': case 'ciA': case 'mi': case 'miA':
+          expecting['Id'] ??= val;
+          // TODO: should we do s/th special, such that a reserved word is a sync
+          // token for Id<all>?  Probably not, see also comment in
+           // _findSyncToken()
+          break loop;
+        case 'g': case 'gi': case 'e':
+          break;
+        default:
+          if (typeof cmd[0] !== 'number')
+            throw Error( `Unexpected command ${ cmd[0] } at state ${ this.s }` );
+          ++enteredRules;       // conditions might use stack/dynamic_
+          // core rule_():
+          this.stack.push( {
+            ruleState: cmd[1],
+            followState: cmd[0],
+            tokenIdx: this.tokenIdx,
+            prec: this.prec_,
+          } );
+          this.dynamic_ = Object.create( this.dynamic_ );
+          this.prec_ = null;
+      }
+      this.s = cmd[1];
+      cmd = null;
+    }
+    const inspectOuterRules = (this.s === 0 && !enteredRules);
+    this.s = savedState;
+    this.dynamic_ = savedDynamic;
+    this.stack.length -= enteredRules;
+    return inspectOuterRules;
   }
 
   translateParserToken_( token ) {
     return [ token ];
   }
 
-  // Error recovery -------------------------------------------------------------
-
-  _calculateSyncSet() {
-    const { stack, dynamic_ } = this;
-    let { length } = stack;
-    while (stack[--length].tokenIdx === this.tokenIdx && length)
-      this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
-    this.stack = stack.slice( 0, ++length );
-
-    // needs (copy of) "real stack"
-    const syncSet = {};
-    let depth = length + 1;
-    if (!this._exp_collect( syncSet, this.table[this.errorState], undefined, depth ))
-      --depth;
-    while (this.stack.length) {
-      this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
-      const caller = this.stack.pop();
-      // this.stack and this.dynamic_ must be changed for parser token
-      // translation:
-      if (caller.followState > 0 &&
-          !this._exp_collect( syncSet, this.table[caller.followState], undefined, depth ))
-        depth = this.stack.length;
-    }
-    syncSet.EOF ??= 0;
-    this.stack = stack;
-    this.dynamic_ = dynamic_;
-    return { rewindDepth: length, syncSet };
+  // Error reporting and recovery -----------------------------------------------
+
+  expectingArray_() {
+    const token = this.la();
+    const set = this._calculateTokenSet( 'M' );
+    // Speed-up: delete current token
+    const { keyword, type } = token;
+    if (keyword && set[keyword] === true)
+      delete set[keyword];
+    else if (set[type] === true && !(keyword && this.keywords[keyword]))
+      delete set[type];         // delete Id if Id token or non-reserved keyword
+
+    this._trace( 'collect tokens for message,' );
+    const saved = this._saveForWalk();
+    const expecting = Object.keys( set )
+      .filter( tok => this._confirmExpected( tok, saved ) );
+    token.type = type;          // overwritten by _confirmExpected
+    token.keyword = keyword;
+    Object.assign( this, saved );
+    // TODO: also trace M(…) collection, extra line for each token, with condition
+    return expecting;
   }
 
-  _findSyncToken( syncSet, rewindDepth ) {
+  _findSyncToken( syncSet ) {
+    const rewindDepth = this.stack.length
     this.recoverTokenIdx = this.tokenIdx;
     while (this.recoverTokenIdx <= this.eofIndex) {
       const { keyword, type } = this.tokens[this.recoverTokenIdx];
@@ -620,8 +736,8 @@ class BaseParser {
       const tryType = syncSet[type];
       // sync to Id only if in expected set of last good state or if after ';'
       if (tryType != null &&
-          (type !== 'Id' || (!keyword || this.keywords[keyword] !== false) &&
-           // reserved words do not match Id in expected-set, see _exp_collect()
+          (type !== 'Id' || (!keyword || !this.keywords[keyword]) &&
+           // reserved words do not match Id in expected-set
            (tryType > rewindDepth || this.tokens[this.recoverTokenIdx - 1].type === ';')))
         return tryType;
       ++this.recoverTokenIdx;
@@ -629,7 +745,7 @@ class BaseParser {
     throw Error( 'EOF must be last in `tokens`' );
   }
 
-  _recoverFromError( rewindDepth, recoverDepth ) {
+  _recoverFromError( recoverDepth ) {
     this.s = null;
     let depth = this.stack.length;
     if (recoverDepth > depth) { // no rewind, no rule exit
@@ -638,9 +754,6 @@ class BaseParser {
       if (this.s)
         this._skipErrorTokens();
     }
-    else if (recoverDepth > rewindDepth) { // rewind, no rule exit
-      this.stack[rewindDepth].followState = this.errorState;
-    }
     while (depth > recoverDepth)
       this.stack[--depth].followState = null;
     // TODO: when the error is due to failed rule exit prediction, try to keep
@@ -673,30 +786,21 @@ class BaseParser {
     console.log( ...args );
   }
 
-  expectingForMessage_( token ) {
-    return Object.keys( this._expecting( token ) ).map( tokenName ).sort().join( ',' );
-  }
-
   reportError_( location, text ) {
     this.$hasErrors = true;
     this.log( `${ location }:`, text );
   }
 
-  reportUnexpectedToken_( token ) {
-    this.reportError_( token.location,
-                       `Unexpected token ${ tokenFullName( token, ': ' ) } - expecting: ` +
-                       this.expectingForMessage_( token ) );
-  }
-
-  reportInternalError_( token ) {
-    this.reportError_( token.location,
-                       `Unexpected token at ${ tokenFullName( token, ': ' ) } - skipped one token` );
+  reportUnexpectedToken_( msg ) {
+    const token = this.la();
+    msg ??= `Unexpected token ${ tokenFullName( token, ': ' ) }`;
+    this.reportError_(
+      token.location, msg + ' - expecting: ' +
+        this.expectingArray_().map( tokenName ).sort().join( ',' ) );
   }
 
-  reportReservedWord_( token ) {
-    this.reportError_( token.location,
-                       `Unexpected reserved word ‘${ token.text }’ - expecting: ` +
-                       this.expectingForMessage_() );
+  reportReservedWord_() {
+    this.reportUnexpectedToken_( `Unexpected reserved word ‘${ this.la().text }’` );
   }
 
   errorAndRecoverOutside( token, text ) { // TODO: re-check
@@ -717,22 +821,28 @@ class BaseParser {
       this.trace.at(-1).push( state );
   }
   traceAction( location ) {     // TODO: remove
-    this._trace( location );
+    this._trace( 1, location );
   }
 
-  _trace( msg, la ) {
+  _trace( msg, la = this.la() ?? this.lb() ) {
     if (!this.constructor.tracingParser)
       return;
     // indentation according to rule call depth is nice, but only if without
     // excessive spaces → truncate:
     const indent = '  '.repeat( this.stack.length % 32 );
-    if (!la) {
+    if (msg === 1) {
       let line = '         execute action'; // align with non-action messages
       if (this.trace.length > 1) { // i.e. with some 'g' command
         line += ', states: ' + this.trace.map( traceStep ).join( ' → ' );
         this.trace = [ this.s ?? '⚠' ];
       }
-      this.log( indent, line, `(${ msg })` );
+      this.log( indent, line, `(${ la })` );
+      return;
+    }
+    else if (la === 2) {
+      this.log( indent, '          ', msg + ':',
+                this.trace.map( traceStep ).join( ' → ' ) );
+      this.trace = [ this.s ?? '⚠' ];
       return;
     }
     const { location } = la;