@sap/cds-compiler 5.5.2 → 5.7.0

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.1.18
+// Base class for generated parser, for redepage v0.2.1
 
 'use strict';
 
@@ -32,6 +32,7 @@ class BaseParser {
   dynamic_ = {};                // TODO: extra class
   prec_ = null;
   $hasErrors = null;
+  leanConditions = {};
   // trace:
   trace = [];
 
@@ -163,6 +164,7 @@ class BaseParser {
       this._tracePush( [ 'E', true ] );
       return true;
     }
+    this._tracePush( [ 'E', 0 ] );
     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
@@ -203,8 +205,10 @@ class BaseParser {
   // cases
   giR( state, follow ) { // go to state (after trying to test again as identifier)
     const { keyword } = this.tokens[this.tokenIdx];
-    if (!keyword || this.keywords[keyword] ||
-        this._matchesInFollow( 'Id', keyword, 'R' ))
+    if (!keyword || this.keywords[keyword])
+      return this.g( state, follow );
+    this._tracePush( [ 'R', 0 ] );
+    if (this._matchesInFollow( 'Id', keyword, 'R' ))
       return this.g( state, follow );
     this.nextTokenAsId = true;
     return false;               // do not execute action after it
@@ -256,7 +260,11 @@ class BaseParser {
 
   // instead of c() for identifiers, used both with l() and lk()
   ci( state, ident = 'ident' ) {   // consume identifier token
+    if (this.tokenIdx === this.fixKeywordTokenIdx)
+      return this.e();
     const la = this.tokens[this.tokenIdx];
+    // TODO: consider this like a failed condition? Will be relevant if we try
+    // different error recovery possibilities.
     if (this.keywords[la.keyword])
       this.reportReservedWord_();
     // with error recovery: use that (consider this having a good score)
@@ -308,7 +316,7 @@ class BaseParser {
     }
     // calling the condition might have side effects (precendence conditions have)
     // → call tracing “name” before
-    const fail = !this[cond]( true, arg );
+    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,
@@ -328,6 +336,10 @@ class BaseParser {
         this.fixKeywordTokenIdx = this.tokenIdx;
       this.conditionTokenIdx = this.tokenIdx;
       this.conditionStackLength = this.stack.length;
+      this.conditionName = cond;
+      // we also set the failure here, because the reporting might have a
+      // different context (consider immediate exit)
+      this.conditionFailure = fail;
     }
     return !fail || this.g( state ) && false;
   }
@@ -385,95 +397,104 @@ class BaseParser {
     return true;
   }
 
-  // predicate used before rule call if with LL(1) conflict, 'Id' in other case
-  lP( first2 ) {             // only start rule if this predicate returns true
+  // predicate used before rule call (and called by `ckP` and `gP`) on keyword
+  // branch if with weak LL(1) conflict, i.e. there is an 'Id' branch or the
+  // default branch has `Id` in its first-set (TODO: or rule end, and `Id` is in
+  // follow-union)
+  lP( first2 ) {
     // nothing to check if not a non-reserved keyword:
     const { keyword: lk1 } = this.tokens[this.tokenIdx];
-    if (!lk1 || this.keywords[lk1] !== 0)
+    if (!lk1 || this.keywords[lk1] !== 0 || this.fixKeywordTokenIdx === this.tokenIdx)
       return true;
 
+    this._tracePush( [ 'K' ] );
     const { type: lt2, keyword: lk2 } = this.tokens[this.tokenIdx + 1];
-    // Argument first2 is just a performance hint with ckP():
+    if (lt2 === 'IllegalToken')
+      return true
+    // Argument first2 is just a performance hint:
     if (lk2 && first2?.[0] === 'Id' && !this.keywords[lk2] ||
         first2?.includes( lk2 || lt2 )) {
-      this._tracePush( [ 'K', true ] );
+      this._traceSubPush( true );
       return true;
     }
-    this._tracePush( [ 'K' ] );
     // now check it dynamically:
-    let cmd = this.table[this.s][lk1];
-    if (cmd[2] !== 1)
-      throw Error( `Unexpected command '${ cmd?.[0] }' without prediction at state ${ this.s } for ‘${ lk1 }’` );
+    if (this._walkPred( this.table[this.s][lk1], lk1, lt2, lk2 ))
+      return true;
+    this._tracePush( [ 'I' ] );
+    const choice = this.table[this.s];
+    if (!this._walkPred( choice.Id || choice[''], null, lt2, lk2 ))
+      return true;
+    this.nextTokenAsId = true;
+    return false;
+  }
 
-    // if not the keyword match, the command is “goto” or “rule call”
-    const savedState = this.s;
-    this.s = (cmd[0] === 'ck') ? cmd[1] : this._pred_keyword( cmd[1], lk1 );
+  _walkPred( cmd, lk1, lt2, lk2 ) {
+    const saved = this._saveForWalk();
+    const { length } = this.stack;
+    if (typeof cmd[0] !== 'number') // don't skip push to state with rule call
+      this.s = cmd[1];
+    if (cmd[0] !== (lk1 ? 'ck' : 'ci')) { // make the std case fast
+      let match1 = this._pred_next( 'Id', lk1, 'P' ); // TODO: really P for I?
+      if (!match1) {
+        if (lk1 || match1 === false) // assert for correct code generation
+          throw Error( `Cannot match first prediction token in rule at state ${ saved.s }` );
+        if (match1 == null) {
+          this._traceSubPush( 0 );  // TODO: make _pred_next push this
+          match1 = this._matchesInFollow( 'Id', lk1, 'I' );
+        }
+        else {
+          this._traceSubPush( false );
+        }
+        Object.assign( this, saved );
+        this.stack.length = length;
+        return !!match1;
+      }
+    }
 
+    this._traceSubPush( '' );   // between the two tokens
     ++this.tokenIdx;            // for user lookahead fns and conditions
-    const match = this._pred_next( lt2, lk2, 'K' );
+    let match2 = this._pred_next( lt2, lk2, (lk1 ? 'K' : 'I') );
+    if (match2 == null) {
+      this._traceSubPush( 0 );  // TODO: make _pred_next push this
+      match2 = !!this._matchesInFollow( lt2, lk2, (lk1 ? 'K' : 'I') );
+    }
+    else {
+      this._traceSubPush( match2 );
+    }
+    Object.assign( this, saved );
+    this.stack.length = length;
     --this.tokenIdx;
-    this.s = savedState;
-
-    const r = match ?? true;
-    if (match == null)
-      this._traceSubPush( 0 );
-    if (lt2 === 'IllegalToken')
-      return true
-    // TODO: instead of this IllegalToken test, implement a “confirm unreserved
-    // keyword as Id” prediction which tests whether the token after the then-Id
-    // matches.
-    this._traceSubPush( r );
-    if (!r)
-      this.nextTokenAsId = true;
-    return r;
+    return match2;
   }
 
   // Now the helper methods =====================================================
 
   // Standard weak-conflict predicate -------------------------------------------
 
-  _pred_keyword( state, keyword ) {
-    // returns state after matching the first token as keyword, for lP()
-    while (state) {
-      this._traceSubPush( state );
-      let cmd = this.table[state];
-      if (!Array.isArray( cmd ))
-        cmd = cmd[keyword] || cmd.Id || cmd[''];
-      switch (cmd[0]) {
-        case 'ck': case 'mk':
-          return cmd[1];        // state after token consumption
-        case 'g':               // TODO: another rule call?
-          break;
-        default:
-          if (typeof cmd[0] !== 'number')
-            throw Error( `Unexpected command ${ cmd[0] } at state ${ this.s }` );
-      }
-      state = cmd[1];
-    }
-    // reached end of rule without having consumed a token
-    throw Error( 'Not supported: option for unreserved keywords in follow set' );
-  }
-
-  _pred_next( type, keyword, mode ) { // mode = K | E | R | M
-    const useConditions = (mode === 'M'); // TODO: extra method with conditions ?
-    let hasEnteredRule = false;
+  _pred_next( type, keyword, mode ) { // mode = P | K | I | E | R | M
+    const properCall = (mode === 'P');
+    const lean = (mode !== 'M'); // TODO: extra method with conditions ?
+    // TODO: if false, use condition in this.leanConditions
+    let hasMatchedToken = null; // undecided yet → calculate on demand
     while (this.s) {
-      if (useConditions)
-        this._tracePush( this.s );
-      else
+      if (lean)
         this._traceSubPush( this.s );
+      else
+        this._tracePush( this.s ); // TODO: push new state instead
       let cmd = this.table[this.s];
       if (!Array.isArray( cmd )) {
         const lookahead = cmd[' lookahead'];
         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[''];
+        cmd = !(c && this._rejectCondition( c, mode, lean )) && c || cmd[''];
       }
+      const state = this.s;
+      this.s = cmd[1];
       switch (cmd[0]) {
         case 'c': case 'ck': case 'ckA': // TODO: re-check ckA
           return true;
-        case 'ciA':
+        case 'ciA':             // TODO: fixKeywordTokenIdx ?
           return mode !== 'R';
           // in the R prediction for optional `Id<reserved>` at rule end, only
           // alternative keyword matches are preferred, not identifier matches
@@ -481,7 +502,8 @@ class BaseParser {
           if (!keyword ||
               !this.keywords[keyword] && this.fixKeywordTokenIdx !== this.tokenIdx)
             return mode !== 'R';
-          cmd = this.table[this.s]['']; // is currently always 'g' or 'e'
+          cmd = this.table[state]['']; // is currently always 'g' or 'e'
+          this.s = cmd[1];
           break;
         case 'm':
           return type === cmd[2];
@@ -497,17 +519,27 @@ class BaseParser {
           break;
         default:
           if (typeof cmd[0] !== 'number')
-            throw Error( `Unexpected command ${ cmd[0] } at state ${ this.s }` );
+            throw Error( `Unexpected command ${ cmd[0] } at state ${ state }` );
           // If the parser enters a rule, reaching the rule end (can happen with
           // option `minTokensMatched`) means "no match".
-          hasEnteredRule = true;
+          hasMatchedToken = false;
           // If we want to support conditions before matching the first token in a
           // rule, we would have to handle `this.stack` and `this.dynamically_`.
+          if (properCall) {
+            // rule_() - TODO: also w/ conditions before matching first token
+            this.stack.push( {
+              ruleState: cmd[1],
+              followState: cmd[0],
+              tokenIdx: this.tokenIdx,
+              prec: this.prec_,
+            } );
+            this.dynamic_ = Object.create( this.dynamic_ );
+            this.prec_ = null;
+          }
       }
       // We could optimize with rule call - only 'Id' must be further investigated
       // 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 );
@@ -522,28 +554,31 @@ class BaseParser {
     // prediction, the tool can normally omit the prediction (and output a
     // message), no so with `ruleStartingWithUnreserved`.  We will rather look
     // behind the current rule _after_ having decided that the token is to be
-    // matched as identifier.
-    return !hasEnteredRule && null; // let caller decide how to interpret this
+      // matched as identifier.
+    return (hasMatchedToken ?? this.tokenIdx > this.stack.at( -1 ).tokenIdx)
+      && null; // let caller decide how to interpret this
   }
 
-  _rejectCondition( cmd, mode ) {
+  _rejectCondition( cmd, mode, lean ) {
     const cond = cmd[3];
-    if (!cond)
+    if (!cond || lean && !this.leanConditions[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;
+      return !!this[cond]( mode, cmd[4] );
+    // TODO: let this[cond]( true ) return recovery badness in error case
+    if (!lean) {
+      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 succeed = !this[cond]( mode, cmd[4] );
+    this._traceSubPush( lean ? { true: 'C✔', false: 'C✖' }[succeed] : succeed );
+    return !succeed;
   }
 
   _matchesInFollow( type, keyword, mode ) { // mode = E | R
-    this._tracePush( [ mode, 0 ] );
+    // TODO: now also set stack!
     const savedState = this.s;
     // TODO: caching
     const { dynamic_ } = this;
@@ -564,9 +599,11 @@ class BaseParser {
   }
 
   _confirmExpected( token, saved ) { // mode = M
-    const [ type, keyword ] = (/^[_a-z]/.test( token )) ? [ 'Id', token ] : [ token ];
+    const fix = /^[_a-z]/.test( token );
+    const [ type, keyword ] = (fix) ? [ 'Id', token ] : [ token ];
     Object.assign( this.la(), { type, keyword } );
     this._cloneFromSaved( saved );
+    this.fixKeywordTokenIdx = fix && this.tokenIdx;
     this.trace = [];
     let match;
     while (this.stack.length) {
@@ -627,7 +664,7 @@ class BaseParser {
   //   ( <prefer, guard=fail> 'foo' | rule ) with
   //   rule : 'foo' | Id ;
   // doing it already here would list `foo` as expected token
-  _tokenSetInRule( expecting, val, cmd ) {
+  _tokenSetInRule( expecting, val, cmd, collectKeywordsAndIdOnly = false ) {
     const savedDynamic = this.dynamic_;
     const savedState = this.s;
     let enteredRules = 0;
@@ -638,25 +675,19 @@ class BaseParser {
         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;
-            }
-          }
+              !Object.hasOwn( expecting, prop ) && prop.charAt(0) !== ' ')
+            this.addTokenToSet_( expecting, prop, val, collectKeywordsAndIdOnly, lookahead );
         }
         cmd = dict[''];
         if (dict.Id) {
           // recursive call only if Id branch with non-error default branch
           if (cmd[0] === 'e') {
+            collectKeywordsAndIdOnly = true;
             cmd = dict.Id;
           }
           else {                // Id branch never leads to rule exit:
             this._tracePush( [ '[' ] );
-            this._tokenSetInRule( expecting, val, dict.Id );
+            this._tokenSetInRule( expecting, val, dict.Id, true );
             this._tracePush( [ ']' ] );
           }
         }
@@ -664,10 +695,10 @@ class BaseParser {
       this._traceSubPush( this.s );
       switch (cmd[0]) {
         case 'm': case 'mk':
-          expecting[cmd[2]] ??= val;
+          this.addTokenToSet_( expecting, cmd[2], val, collectKeywordsAndIdOnly );
           break loop;
         case 'ci': case 'ciA': case 'mi': case 'miA':
-          expecting['Id'] ??= val;
+          this.addTokenToSet_( expecting, 'Id', val, false );
           // 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()
@@ -698,8 +729,10 @@ class BaseParser {
     return inspectOuterRules;
   }
 
-  translateParserToken_( token ) {
-    return [ token ];
+  // Remark: when called for `Id` token, `collectKeywordsOnly` is `false`
+  addTokenToSet_( set, token, val, collectKeywordsOnly, _lookahead ) {
+    if (!collectKeywordsOnly || /^[_a-z]/.test( token ))
+      set[token] ??= val;
   }
 
   // Error reporting and recovery -----------------------------------------------
@@ -715,12 +748,14 @@ class BaseParser {
       delete set[type];         // delete Id if Id token or non-reserved keyword
 
     this._trace( 'collect tokens for message,' );
+    const { trace } = this;
     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 );
+    this.trace = trace;
     // TODO: also trace M(…) collection, extra line for each token, with condition
     return expecting;
   }
@@ -761,6 +796,7 @@ class BaseParser {
     // Continue parsing: ignore next predicate (TODO: except some specified ones?)
     this.conditionTokenIdx = this.tokenIdx;
     this.conditionStackLength = null;
+    this.fixKeywordTokenIdx = -1; // was set when collecting expecting-set
 
     // 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'
@@ -887,35 +923,38 @@ class BaseParser {
 
   // Predefined conditions with extra option names:
 
+  hide_( mode ) {
+    return mode === 'M';
+  }
   precLeft_( _test, prec ) {    // <prec=…>, <…,assoc=left>, <…,prefix=once>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec)
-      return false;
+      return true;
     this.prec_ = prec;
-    return true;
+    return false;
   }
   precRight_( _test, prec ) {   // <…,assoc=right>, <…,prefix>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec)
-      return false;
+      return true;
     this.prec_ = prec - 1;
-    return true;
+    return false;
   }
   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;
+      return true;
     this.prec_ = prec;
-    return true;
+    return false;
   }
   precPost_( _test, prec ) {    // <…,postfix>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec ||
         this.prec_ != null && this.prec_ < prec)
-      return false;
+      return true;
     this.prec_ = prec;
-    return true;
+    return false;
   }
 }
 const members = BaseParser.prototype;