@sap/cds-compiler 5.3.0 → 5.4.0

package/lib/gen/BaseParser.js

@@ -1,7 +1,16 @@
-// Base class for generated parser, for redepage v0.1.12
+// Base class for generated parser, for redepage v0.1.16
 
 'use strict';
 
+// TODO: instance method
+// name → true, list of predicates which are tested for rule exit
+// const ruleExitPredicates = {};
+
+// list of predicates which are tested when continue parsing after error starts,
+// i.e. there is a predicate on the first token to match after recover example
+// `afterBrace` or just method which by default just sets this.conditionTokenIdx
+ // and this.conditionStackLength and returns true?
+
 class BaseParser {
   constructor( lexer, keywords, table ) {
     this.keywords = keywords;
@@ -10,7 +19,9 @@ class BaseParser {
     this.tokens = undefined;
     this.eofIndex = undefined;
     this.tokenIdx = 0;
-    this.conditionTokenIdx = -1;
+    this.recoverTokenIdx = -1;
+    this.conditionTokenIdx = -1; // TODO: can we use recoverTokenIdx ?
+    this.errorTokenIdx = -1;
     this.fixKeywordTokenIdx = -1;
     this.conditionStackLength = -1;
     this.nextTokenAsId = false;
@@ -22,7 +33,7 @@ class BaseParser {
     this.prec_ = null;
     this.$hasErrors = null;
     // trace:
-    this.trace = [ -1 ];
+    this.trace = [];
   }
 
   init() {
@@ -60,28 +71,23 @@ class BaseParser {
 
   e() {                         // error: report and recover
     const la = this.tokens[this.tokenIdx];
-    const expecting = this._expecting();
     if (this.trace.length > 1)
-      this._trace( 'detected parsing error,' );
+      this._trace( 'detected parsing error,', la );
     this.reportUnexpectedToken_( la );
-    la.parsedAs = 0;
-
-    if (this.conditionTokenIdx === this.tokenIdx &&
-        this.conditionStackLength === this.stack.length &&
-        (la.keyword && expecting[la.keyword] || expecting[la.type])) {
-      // called with/after gc()/gp(), and the token would actually match
-      const { tokenIdx, ruleState } = this.stack.at( -1 );
-      this.s = (this.tokenIdx > tokenIdx) ? this.errorState : ruleState;
-      return false;             // error recovery: ignore condition/precedence
+    la.parsedAs = '';           // current token is erroneous
+
+    if (this.errorTokenIdx === this.tokenIdx) {
+      // TODO: investigate why this is not handled otherwise
+      this.reportInternalError_( la );
+      this.skipToken_();
+      return false;
     }
+    this.errorTokenIdx = this.tokenIdx;
+    this.conditionStackLength = null;
 
-    if (this.tokenIdx >= this.eofIndex)
-      return this._stopParsing( this.stack.length );
-    // TODO: also sync to what comes next in current rule, at least after rule call,
-    // this way we do not have to do the check of g(0) in re() as we did before 2023-12-07
-    // (not sure yet whether to make it part of recoverInline or recoverPanicMode),
-    if (!this._recoverInline( expecting ))
-      this._recoverPanicMode();
+    const { rewindDepth, syncSet } = this._calculateSyncSet();
+    const recoverDepth = this._findSyncToken( syncSet, rewindDepth );
+    this._recoverFromError( rewindDepth, recoverDepth );
     return false;
   }
 
@@ -166,8 +172,8 @@ class BaseParser {
   }
 
   // instead of g() in a non-default case if there is a LL1 conflict
-  gP( state ) {                // goto state with standard weak-conflict prediction
-    return this.lP() && this.g( state );
+  gP( state, follow ) {                // goto state with standard weak-conflict prediction
+    return this.lP( follow ) && this.g( state );
   }
 
   // match and consume token: ---------------------------------------------------
@@ -252,73 +258,52 @@ class BaseParser {
   // “or Id” behavior other than via gpP()
 
   // “go if user condition fails”
-  gc( state, cond ) {
-    if (this.conditionTokenIdx === this.tokenIdx &&
-        this.conditionStackLength === this.stack.length) {
+  gc( state, cond, arg ) {
+    if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
+        this.conditionStackLength == null) {               // after error recovery
       this._tracePush( [ 'C' ] );
-      return true;              // error recovery: ignore condition
+      return true;
     }
-    this.conditionTokenIdx = this.tokenIdx;
-    this.conditionStackLength = this.stack.length;
     // TODO: let this[cond]( true ) return recovery badness in error case
-    const fail = !this[cond]( true );
-    if (this.constructor.tracingParser)
-      this._tracePush( [ 'C', cond, !fail ] );
-    // TODO TOOL: in this case, the default case must not have actions (tool must
-    // add state if it does)
-    if (fail) {                 // TODO: extra gcK() method instead of check below
-      // TODO: extra method necessary for academic case
-      // ( 'unreserved' 'foo' | <cond> Id 'bar' )` with input `unreserved bar`
-      const { keyword } = this.la();
-      if (keyword && this.table[keyword])
-        this.fixKeywordTokenIdx = this.tokenIdx;
+    if (this.constructor.tracingParser) {
+      const { traceName } = this[cond];
+      this._tracePush( [ 'C', traceName?.call( this, arg ) ?? cond ] );
     }
-    return !fail || this.g( state ) && false;
-  }
+    // calling the condition might have side effects (precendence conditions have)
+    // → call tracing “name” before
+    const fail = !this[cond]( true, arg );
+    if (this.constructor.tracingParser)
+      this._traceSubPush( !fail );
+    // The default case must not have actions. If written in grammar with action,
+    // the default must have <default=fallback>
 
-  ec( cond ) {
-    return this.gc( null, cond );
-  }
 
-  // “go if precedence condition fails”
-  gp( state, prec, mode ) {
-    if (this.conditionTokenIdx === this.tokenIdx &&
-        this.conditionStackLength === this.stack.length) {
-      this._tracePush( [ 'C' ] );
-      return true;              // error recovery: ignore condition
-    }
-    this.conditionTokenIdx = this.tokenIdx;
-    this.conditionStackLength = this.stack.length;
-    const parentPrec = this.stack.at( -1 ).prec ?? -Infinity;
-    const fail = prec <= parentPrec ||
-          this.prec_ != null && // previous op parsed by current rule
-          // <…,postfix> || <…,assoc=none>, <…,postfix=once>:
-          (mode === 'post' && prec > this.prec_ || mode === 'none' && prec >= this.prec_);
-    if (this.constructor.tracingParser) {
-      const pp = (parentPrec === -Infinity) ? '-∞' : parentPrec;
-      const tp = (this.prec_ == null) ? '∞' : this.prec_;
-      const suffix = mode === 'post' && `≤${ tp }` || mode === 'none' && `<${ tp }`;
-      this._tracePush( [ 'C', `${ pp }<${ prec }${ suffix || '' }`, !fail ] );
-    }
     if (fail) {                 // TODO: extra gcK() method instead of check below
+      // TODO: probably remove the following (and `conditionStackLength` tests)
+      // altogether, error with gr() should be enough
+      // if (this.conditionTokenIdx === this.tokenIdx &&
+      //     this.conditionStackLength == this.stack.length)
+      //   return this.e();        // already failed on same token in same rule
       // TODO: extra method necessary for academic case
       // ( 'unreserved' 'foo' | <cond> Id 'bar' )` with input `unreserved bar`
       const { keyword } = this.la();
       if (keyword && this.table[this.s][keyword])
         this.fixKeywordTokenIdx = this.tokenIdx;
-      return this.g( state ) && false;                // TODO: reset this.prec_ ?
+      this.conditionTokenIdx = this.tokenIdx;
+      this.conditionStackLength = this.stack.length;
     }
-    this.prec_ = (mode === 'right') ? prec - 1 : prec; // -1: <…,assoc=right>, <…,prefix>
-    return true;
+    return !fail || this.g( state ) && false;
   }
 
-  ep( prec, mode ) {
-    return this.gp( null, prec, mode );
+  ec( cond, arg ) {
+    return this.gc( null, cond, arg );
   }
 
   // rule start, end and call: --------------------------------------------------
 
   rule_( state, followState = -1 ) { // start rule
+    this.s = state;
+    this._trace( [ 'call rule', state, ' at alt start' ], this.la() );
     this.stack.push( {
       ruleState: state,
       followState,
@@ -326,26 +311,42 @@ class BaseParser {
       prec: this.prec_,
     } );
     this.dynamic_ = Object.create( this.dynamic_ );
-    this.s = state;
     this.prec_ = null;
-    this.conditionTokenIdx = -1;
     this.errorState ??= state;
-    this._trace( [ state, 'call rule', '', ' at alt start', -1 ] );
   }
 
-  exit_( rulePrecMethod ) {     // exit rule
+  exit_() {     // exit rule
     if (this.s)
       throw Error( `this.s === ${ this.s } // illegally set by action, or runtime/generator bug` );
     this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
     const caller = this.stack.pop();
+    const immediately = this.tokenIdx === caller.tokenIdx;
+    if (this.constructor.tracingParser) {
+      const post = this.s == null &&
+            (immediately
+             ? ' immediately'
+             : caller.followState == null
+             ? ' unsuccessfully'
+             : ' 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 = [ this.errorState ]; // show last good state in trace
+    }
     this.s = caller.followState;
-    this.prec_ = (rulePrecMethod) ? this[rulePrecMethod]( caller ) : caller.prec;
-    this._trace( [ caller.ruleState, 'exit rule', '', '', 1 ] );
-    //if (this.errorState == 0 || this.s != null)
+    this.prec_ = caller.prec;
+    if (this.s)
+      this._skipErrorTokens();
+    else if (this.s == null)
+      return !immediately;      // attached actions are executed even with "unsuccessful exit"
+
+    if (immediately)
+      return false;
     this.errorState = this.s;
-    // execute actions if not in error recovery (pass-through) and at least one
-    // token has been matched in rule:
-    return this.s != null && this.tokenIdx > caller.tokenIdx;
+    return true;
   }
 
   // predicate used before rule call if with LL(1) conflict, 'Id' in other case
@@ -359,10 +360,10 @@ class BaseParser {
     // Argument first2 is just a performance hint with ckP():
     if (lk2 && first2?.[0] === 'Id' && this.keywords[lk2] !== false ||
         first2?.includes( lk2 || lt2 )) {
-      this._tracePush( [ 'P', true ] );
+      this._tracePush( [ 'K', true ] );
       return true;
     }
-    this._tracePush( [ 'P' ] );
+    this._tracePush( [ 'K' ] );
     // now check it dynamically:
     let cmd = this.table[this.s][lk1];
     if (cmd[2] !== 1)
@@ -372,7 +373,7 @@ class BaseParser {
     const nextState = (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, 'P' );
+    const match = this._pred_next( nextState, lt2, lk2, 'K' );
     --this.tokenIdx;
 
     const r = match ?? true;
@@ -484,10 +485,13 @@ class BaseParser {
 
   // 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( errorState, length ) {
+  _expecting( token ) {
     // Remark: rules must not have been exited too early, see _expecting call in re()
-    const stack = this.stack.slice( 0, length || this.stack.length );
+    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) {
@@ -496,11 +500,20 @@ class BaseParser {
     }
     // Now calculate dictionary of expected tokens:
     const expecting = Object.create(null);
-    let state = errorState ?? this.errorState;
+    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];
+    }
     return expecting;
   }
 
@@ -509,31 +522,41 @@ class BaseParser {
   // 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.
-  _exp_collect( expecting, cmd, prop ) {
+
+  // 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 ))
+            this._exp_collect( expecting, cmd, tok, val ))
           reachedRuleEnd = true;
       }
       return reachedRuleEnd;
     }
     switch (cmd[0]) {
       case 'c': case 'ck':
-        expecting[prop] = true;
+        expecting[prop] ??= val;
         return false;
       case 'ckA':
         for (const tok of this.translateParserToken_( prop ))
-          expecting[tok] = true;
+          expecting[tok] ??= val;
         return false;
       case 'm': case 'mk':
-        expecting[cmd[2]] = true;
+        expecting[cmd[2]] ??= val;
         return false;
       case 'ci': case 'ciA': case 'mi': case 'miA':
-        expecting['Id'] = true;
+        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])
@@ -544,12 +567,12 @@ class BaseParser {
         // 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]] );
+        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]] );
+          this._exp_collect( expecting, this.table[cmd[1]], undefined, val );
         return false;
     }
   }
@@ -560,72 +583,72 @@ class BaseParser {
 
   // Error recovery -------------------------------------------------------------
 
-  _recoverInline( expecting ) {
-    const { type: lt2, keyword: lk2 } = this.tokens[this.tokenIdx + 1];
-    if (!(lk2 && expecting[lk2] || expecting[lt2]))
-      return false;
-
-    // Immediately exit rules (except start) when no tokens have yet been consumed:
-    let { length } = this.stack;
-    while (--length > 0) {
-      const caller = this.stack[length];
-      // matched tokens in rule: found rule
-      if (this.tokenIdx > caller.tokenIdx)
-        break;
-      caller.followState = null;
-    }
-
-    if (++length < this.stack.length) {
-      this.s = null;
-      this.stack[length].followState = this.errorState;
-      // assume the erroneous token to be skipped before having called the rule:
-      ++this.stack[length].tokenIdx
-      this.errorState = null;
+  _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;
     }
-    else {                      // no rule to leave immediately
-      this.s = this.errorState;
+    syncSet.EOF ??= 0;
+    this.stack = stack;
+    this.dynamic_ = dynamic_;
+    return { rewindDepth: length, syncSet };
+  }
+
+  _findSyncToken( syncSet, rewindDepth ) {
+    this.recoverTokenIdx = this.tokenIdx;
+    while (this.recoverTokenIdx <= this.eofIndex) {
+      const { keyword, type } = this.tokens[this.recoverTokenIdx];
+      const tryKeyw = keyword ? syncSet[keyword] : null;
+      if (tryKeyw != null)
+        return tryKeyw;
+      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()
+           (tryType > rewindDepth || this.tokens[this.recoverTokenIdx - 1].type === ';')))
+        return tryType;
+      ++this.recoverTokenIdx;
     }
+    throw Error( 'EOF must be last in `tokens`' );
+  }
 
-    this.skipToken_();
-    if (this.constructor.tracingParser)
-      this._trace( [ this.stack[length - 1].ruleState, 'recover inside rule' ] );
-    return true;              // to be re-checked with actions
-  }
-
-  _recoverPanicMode() {
-    const { length } = this.stack;
-    // Panic mode: resume at token in then-expecting set:
-    const followSets = { EOF: 0 };
-    for (let idx = 0; idx < length; ++idx) {
-      const caller = this.stack[idx];
-      const exp = this._expecting( caller.followState, length );
-      for (const t of Object.keys( exp )) {
-        // no sync to 'Id' - TODO: provide grammar and rule options
-        if (t !== 'Id')         // TODO: see below
-          followSets[t] = idx;
-      }
+  _recoverFromError( rewindDepth, recoverDepth ) {
+    this.s = null;
+    let depth = this.stack.length;
+    if (recoverDepth > depth) { // no rewind, no rule exit
+      this.trace = [ this.errorState ]; // show last good state in trace
+      this.s = this.errorState;
+      if (this.s)
+        this._skipErrorTokens();
     }
-    const tokenIdx = this.tokenIdx;
-    // console.log( this.la().location.toString(), followSets )
-    while (this.tokenIdx <= this.eofIndex) {
-      // TODO: exclude reserved words for test with this.l()
-      const depth = followSets[this.lk()] || followSets[this.l()];
-      // TODO: handle Id here
-      if (depth != null)
-        return this._error_panic( depth, length, tokenIdx );
-      this.skipToken_();
+    else if (recoverDepth > rewindDepth) { // rewind, no rule exit
+      this.stack[rewindDepth].followState = this.errorState;
     }
-    throw Error( 'EOF was added...' );
-  }
+    while (depth > recoverDepth)
+      this.stack[--depth].followState = null;
+    // TODO: when the error is due to failed rule exit prediction, try to keep
+    // existing followState (if that reaches RuleEnd_)
+    // Continue parsing: ignore next predicate (TODO: except some specified ones?)
+    this.conditionTokenIdx = this.tokenIdx;
+    this.conditionStackLength = null;
 
-  _error_panic( low, high, tokenIdx ) {
-    this.s = null;              // mark current rule for exit
-    if (this.constructor.tracingParser) {
-      this._trace( this.stack.length - 1 > low
-                   ? `recover by exiting ${ this.stack.length - low} rules prematurely,`
-                   : 'recover by exiting current rule prematurely,' );
-    }
-    // eventually mark outer rules for exit:
     // TODO: re-check for rule calls which are at the optional rule end:
     //   x: 'x not'; b: 'b'? x {console.log('x→b')} 'b'?; a: b {console.log('b→a')} 'a'
     // with start rule `a` and input `x a`: output should be x→b + b→a
@@ -633,27 +656,15 @@ class BaseParser {
     //
     // → the rule is: if a rule can continue at the specified state and has
     // matched at least one token, then its action is executed, otherwise not
-    for (let idx = low + 1; idx < high; ++idx) {
-      this.stack[idx].followState = null;
-    }
-    const resume = this.stack[low];
-    if (tokenIdx === resume.tokenIdx) // no tokens matched other than those by skipping
-      resume.tokenIdx = this.tokenIdx; // make exit_() return false
-    this.errorState = null;
   }
 
-  _stopParsing( idx ) {
-    if (this.constructor.tracingParser) {
-      this.log( this.la().location.toString() + ':', 'Info:',
-                `leave all active ${ idx } rules prematurely, stop parsing` );
-    }
-    // TODO: run this.skipToken_() on all remaining tokens?  Does ANTLR consumes
-    // those in error recovery mode?  Probably not.
-    for (const c of this.stack)
-      c.followState = null;
-    this.errorState = null;
-    this.s = null;
-    return false;
+  _skipErrorTokens() {
+    if (this.constructor.tracingParser && this.tokenIdx <= this.recoverTokenIdx) {
+      this._trace( `skipped ${ this.recoverTokenIdx - this.tokenIdx } tokens to recover from error,`,
+                   this.tokens[this.recoverTokenIdx] );
+      }
+    while (this.tokenIdx < this.recoverTokenIdx)
+      this.skipToken_();
   }
 
   // small methods --------------------------------------------------------------
@@ -662,31 +673,39 @@ class BaseParser {
     console.log( ...args );
   }
 
-  expectingForMessage_( sep = ',' ) {
-    return Object.keys( this._expecting() ).map( tokenName ).sort().join( sep );
+  expectingForMessage_( token ) {
+    return Object.keys( this._expecting( token ) ).map( tokenName ).sort().join( ',' );
   }
 
   reportError_( location, text ) {
     this.$hasErrors = true;
-    this.log( `${ location }: Error:`, text );
+    this.log( `${ location }:`, text );
   }
 
   reportUnexpectedToken_( token ) {
     this.reportError_( token.location,
-                       `unexpected token ${ tokenFullName( token, ': ' ) } - expecting: ` +
-                       this.expectingForMessage_() );
+                       `Unexpected token ${ tokenFullName( token, ': ' ) } - expecting: ` +
+                       this.expectingForMessage_( token ) );
+  }
+
+  reportInternalError_( token ) {
+    this.reportError_( token.location,
+                       `Unexpected token at ${ tokenFullName( token, ': ' ) } - skipped one token` );
   }
 
   reportReservedWord_( token ) {
     this.reportError_( token.location,
-                       `unexpected reserved word ‘${ token.text }’ - expecting: ` +
+                       `Unexpected reserved word ‘${ token.text }’ - expecting: ` +
                        this.expectingForMessage_() );
   }
 
   errorAndRecoverOutside( token, text ) { // TODO: re-check
+    // TODO: TMP
     this.reportError_( token.location, text );
-    ++this.tokenIdx;
-    return this._recoverPanicMode( this.stack.length );
+    while (this.l() !== ';')
+      this.skipToken_();
+    this.s = null;
+    return false;
   }
 
   _tracePush( state ) {
@@ -697,31 +716,55 @@ class BaseParser {
     if (this.constructor.tracingParser)
       this.trace.at(-1).push( state );
   }
-  traceAction( location ) {     // will be put into tracing parser
-    this._trace( 'execute action,', { location } );
+  traceAction( location ) {     // TODO: remove
+    this._trace( location );
   }
 
   _trace( msg, la ) {
     if (!this.constructor.tracingParser)
       return;
-    if (Array.isArray( msg ))
-      msg = this._rule( ...msg );
+    // indentation according to rule call depth is nice, but only if without
+    // excessive spaces → truncate:
+    const indent = '  '.repeat( this.stack.length % 32 );
+    if (!la) {
+      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 })` );
+      return;
+    }
+    const { location } = la;
+    if (!this.trace.length) {
+      this.log( `In ${ location.file }:` );
+      this.trace = [ -1 ];
+    }
     this.trace.push( this.s ?? '⚠' );
-    this.log( (la || this.la()).location.toString() + ':',
-              'Info:', msg, 'states:', this.trace.map( traceStep ).join( ' → ' ) );
+    if (Array.isArray( msg )) {
+      const [ intro, state, finale, exitLength ] = msg;
+      let depth = (exitLength) ? exitLength - 1 : this.stack.length + 1;
+      let length = this.trace.length - 1;
+      this.trace[length] = `${ this.trace[length] }(${ depth })`;
+      depth = exitLength || this.stack.length;
+      while (length && typeof this.trace[--length] !== 'number')
+        ;
+      this.trace[length] = `${ this.trace[length] }(${ depth })`;
+
+      let start = state;
+      while (typeof this.table[--start] !== 'string')
+        ;
+      const post = (exitLength || start + 1 < state) && finale;
+      msg = `${ intro } “${ this.table[start] }”${ post || '' },`;
+    }
+    // Yes, I know util.format, but do not want to have a `require` in this file
+    const line = location.line < 1e5 ? `    ${ location.line }`.slice(-5) : `${ location.line }`;
+    const col = location.col < 1e4 ? `:${ location.col }   `.slice(0,5) : `:${location.col }`;
+    this.log( line + col + indent + msg,
+              'states:', this.trace.map( traceStep ).join( ' → ' ) );
     this.trace = [ this.s ?? '⚠' ];
   }
 
-  // TODO: rename to ruleName_, leaving out the msg stuff
-  _rule( state, msg, post = '', postOther = post, depthDiff ) {
-    const start = --state;
-    while (typeof this.table[state] !== 'string')
-      --state;
-    const { length } = this.stack;
-    const depth = depthDiff ? `, depth ${ length + depthDiff } → ${ length }` : '';
-    return `${ msg } “${ this.table[state] }”${ state < start ? postOther : post }${ depth },`;
-  }
-
   inSameRule_( lowState, highState ) {
     if (lowState > highState)
       [ lowState, highState ] = [ highState, lowState ];
@@ -732,6 +775,57 @@ class BaseParser {
     return true;
   }
 
+  // Predefined conditions with extra option names:
+
+  precLeft_( _test, prec ) {    // <prec=…>, <…,assoc=left>, <…,prefix=once>
+    const parentPrec = this.stack.at( -1 ).prec;
+    if (parentPrec != null && parentPrec >= prec)
+      return false;
+    this.prec_ = prec;
+    return true;
+  }
+  precRight_( _test, prec ) {   // <…,assoc=right>, <…,prefix>
+    const parentPrec = this.stack.at( -1 ).prec;
+    if (parentPrec != null && parentPrec >= prec)
+      return false;
+    this.prec_ = prec - 1;
+    return true;
+  }
+  precNone_( _test, prec ) {    // <…,assoc=none>, <…,postfix=once>
+    const parentPrec = this.stack.at( -1 ).prec;
+    if (parentPrec != null && parentPrec >= prec ||
+        this.prec_ != null && this.prec_ <= prec)
+      return false;
+    this.prec_ = prec;
+    return true;
+  }
+  precPost_( _test, prec ) {    // <…,postfix>
+    const parentPrec = this.stack.at( -1 ).prec;
+    if (parentPrec != null && parentPrec >= prec ||
+        this.prec_ != null && this.prec_ < prec)
+      return false;
+    this.prec_ = prec;
+    return true;
+  }
+}
+const members = BaseParser.prototype;
+// functions below are to be called with `call` to set `this`
+
+members.precLeft_.traceName = function( prec ) {
+  const parentPrec = this.stack.at( -1 ).prec;
+  return `${ parentPrec ?? '-∞' }<${ prec }`;
+}
+members.precRight_.traceName = function( prec ) {
+  const left = this.precLeft_.traceName.call( this, prec );
+  return `${ left },↓`;
+}
+members.precNone_.traceName = function( prec ) {
+  const left = this.precLeft_.traceName.call( this, prec );
+  return `${ left }<${ this.prec_ == null ? '∞' : this.prec_ }`;
+}
+members.precPost_.traceName = function( prec ) {
+  const left = this.precLeft_.traceName.call( this, prec );
+  return `${ left }≤${ this.prec_ == null ? '∞' : this.prec_ }`;
 }
 
 function traceStep( step ) {