@sap/cds-compiler 5.9.4 → 6.0.12

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.2.1
+// Base class for generated parser, for redepage v0.2.4
 
 'use strict';
 
@@ -9,7 +9,7 @@
 // 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?
+// and this.conditionStackLength and returns true?
 
 class BaseParser {
   keywords;
@@ -110,7 +110,7 @@ class BaseParser {
 
   e() {                         // error: report and recover
     const la = this.tokens[this.tokenIdx];
-    this._trace( 'detect parsing error,' );
+    this._trace( 'detect parsing error' );
     if (this.errorTokenIdx === this.tokenIdx)
       throw Error( `Already reported error for ${ tokenFullName( la ) } at ${ la.location }`);
 
@@ -134,7 +134,7 @@ class BaseParser {
     this.reportUnexpectedToken_();
     const syncSet = this._calculateTokenSet( 'Y' );
     const recoverDepth = this._findSyncToken( syncSet );
-    this._trace( 'recover from error,' );
+    this._trace( 'recover from error' );
     this._recoverFromError( recoverDepth );
     return false;
   }
@@ -181,7 +181,7 @@ class BaseParser {
     return true;
   }
 
-  // instead of gi() for `Id_all`
+  // instead of gi() for `Id<greedy>`
   giA( state, follow ) { // go to state (after trying to test again as identifier)
     if (!this.tokens[this.tokenIdx].keyword) // lk() had directly returned the type
       return this.g( state, follow );
@@ -200,9 +200,7 @@ class BaseParser {
     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
+  // instead of gi() at rule end (RuleEnd_ in follow-set) for `Id<weak>`, TODO: delete
   giR( state, follow ) { // go to state (after trying to test again as identifier)
     const { keyword } = this.tokens[this.tokenIdx];
     if (!keyword || this.keywords[keyword])
@@ -227,14 +225,14 @@ class BaseParser {
       : this.e();
   }
 
-  // instead of m() for identifiers via `Id` or `Id_restricted`
+  // instead of m() for identifiers via `Id` or `Id<weak>`
   mi( state, ident = true ) {   // match identifier token
     return (this.tokens[this.tokenIdx].type === 'Id')
       ? this.ci( state, ident )
       : this.e();
   }
 
-  // instead of mi() for `Id_all`
+  // instead of mi() for `Id<greedy>`
   miA( state, ident = true ) {  // match identifier token
     return (this.tokens[this.tokenIdx].type === 'Id')
       ? this.ciA( state, ident )
@@ -254,7 +252,7 @@ class BaseParser {
     this.s = state;
     this.errorState = state;
     if (this.constructor.tracingParser)
-      this._trace( `consume ${ tokenFullName( la, ' as ' ) },`, la );
+      this._trace( `consume ${ tokenFullName( la, ' as ' ) }`, la );
     return true;
   }
 
@@ -271,7 +269,7 @@ class BaseParser {
     return this.c( state, ident )
   }
 
-  // instead of ci() for `Id_all`, used both with l() and lk()
+  // instead of ci() for `Id<greedy>`, used both with l() and lk()
   ciA( state, ident = 'ident' ) {  // consume identifier token, the "All" variant
     return this.c( state, ident )
   }
@@ -286,7 +284,7 @@ class BaseParser {
     return this.lP( first2 ) && this.ck( state );
   }
 
-  // for parser token or token set via `/`
+  // for parser token or token set via `/` -> cx() ?
   ckA( state ) {
     // if it really should be considered an Id, `set this.la().parsedAs` yourself
     return this.c( state, (this.l() === 'Id' ? 'keyword' : 'token') );
@@ -316,7 +314,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]( arg, true ); // TODO: use single-letter for run?
     if (this.constructor.tracingParser)
       this._traceSubPush( !fail );
     // The default case must not have actions. If written in grammar with action,
@@ -379,7 +377,7 @@ 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._trace( [ text, caller.ruleState, post, 'back to' ] )
       if (immediately && this.stack.at(-1)?.followState != null)
         this.trace = [ this.errorState ]; // show last good state in trace
     }
@@ -434,13 +432,14 @@ class BaseParser {
     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
+      // TODO: also not with lean condition
       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' );
+          match1 = this._matchesInFollow( 'Id', lk1, 'I' ); // TODO: 'I'?
         }
         else {
           this._traceSubPush( false );
@@ -471,7 +470,23 @@ class BaseParser {
 
   // Standard weak-conflict predicate -------------------------------------------
 
+  /**
+   * Return whether current token (its type and keyword are args - TODO delete?)
+   * would be matched when starting at the current state:
+   *  - true/false are definite answers,
+   *  - null: reached end-of-rule (let caller decide what to do).
+   *
+   * Changes by side-effect:
+   *  - this.s
+   *  - with mode='P' (first step in keyword prediction) if a rule is called:
+   *    this.stack, this.dynamic_, this.prec_
+   *
+   * Conditions are only evaluated with mode='M' (expected set in msgs) or if
+   * condition is listed in `this.leanConditions`.
+   */
   _pred_next( type, keyword, mode ) { // mode = P | K | I | E | R | M
+    // TODO mode: really distinguish between K | I | E | R ?
+    // Probably not: would not work with caching?  → P, P -> F
     const properCall = (mode === 'P');
     const lean = (mode !== 'M'); // TODO: extra method with conditions ?
     // TODO: if false, use condition in this.leanConditions
@@ -496,8 +511,9 @@ class BaseParser {
           return true;
         case 'ciA':             // TODO: fixKeywordTokenIdx ?
           return mode !== 'R';
-          // in the R prediction for optional `Id<reserved>` at rule end, only
+          // in the R prediction for optional `Id<weak>` at rule end, only
           // alternative keyword matches are preferred, not identifier matches
+          // TODO: delete this prediction
         case 'ci':
           if (!keyword ||
               !this.keywords[keyword] && this.fixKeywordTokenIdx !== this.tokenIdx)
@@ -564,7 +580,7 @@ class BaseParser {
     if (!cond || lean && !this.leanConditions[cond])
       return false;
     if (!this.constructor.tracingParser)
-      return !!this[cond]( mode, cmd[4] );
+      return !!this[cond]( cmd[4], mode );
     // TODO: let this[cond]( true ) return recovery badness in error case
     if (!lean) {
       const { traceName } = this[cond];
@@ -572,12 +588,12 @@ class BaseParser {
       // calling the condition might have side effects (precendence conditions have)
       // → call tracing “name” before
     }
-    const succeed = !this[cond]( mode, cmd[4] );
+    const succeed = !this[cond]( cmd[4], mode );
     this._traceSubPush( lean ? { true: 'C✔', false: 'C✖' }[succeed] : succeed );
     return !succeed;
   }
 
-  _matchesInFollow( type, keyword, mode ) { // mode = E | R
+  _matchesInFollow( type, keyword, mode ) { // mode = E | R and K | I
     // TODO: now also set stack!
     const savedState = this.s;
     // TODO: caching
@@ -588,6 +604,7 @@ class BaseParser {
     while (match == null && --depth) {
       this.dynamic_ = Object.getPrototypeOf( this.dynamic_ );
       this.s = this.stack[depth].followState;
+      // TODO: this.prec_ ?
       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
@@ -700,7 +717,7 @@ class BaseParser {
         case 'ci': case 'ciA': case 'mi': case 'miA':
           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
+          // token for Id<greedy>?  Probably not, see also comment in
            // _findSyncToken()
           break loop;
         case 'g': case 'gi': case 'e':
@@ -747,7 +764,7 @@ class BaseParser {
     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,' );
+    this._trace( 'collect tokens for message' );
     const { trace } = this;
     const saved = this._saveForWalk();
     const expecting = Object.keys( set )
@@ -765,16 +782,18 @@ class BaseParser {
     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];
+      let recoverDepth = keyword ? syncSet[keyword] : null;
+      if (recoverDepth != null)
+        return recoverDepth;
+      recoverDepth = syncSet[type];
       // sync to Id only if in expected set of last good state or if after ';'
-      if (tryType != null &&
+      if (recoverDepth != null &&
           (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;
+           (recoverDepth > rewindDepth || this.tokens[this.recoverTokenIdx - 1].type === ';')))
+        // if (recoverDepth != null &&
+        //     (this.recoverTokenIdx > this.tokenIdx || 
+        return recoverDepth;
       ++this.recoverTokenIdx;
     }
     throw Error( 'EOF must be last in `tokens`' );
@@ -809,7 +828,7 @@ class BaseParser {
 
   _skipErrorTokens() {
     if (this.constructor.tracingParser && this.tokenIdx <= this.recoverTokenIdx) {
-      this._trace( `skipped ${ this.recoverTokenIdx - this.tokenIdx } tokens to recover from error,`,
+      this._trace( `skip ${ this.recoverTokenIdx - this.tokenIdx } tokens to recover from error`,
                    this.tokens[this.recoverTokenIdx] );
       }
     while (this.tokenIdx < this.recoverTokenIdx)
@@ -832,7 +851,7 @@ class BaseParser {
     msg ??= `Unexpected token ${ tokenFullName( token, ': ' ) }`;
     this.reportError_(
       token.location, msg + ' - expecting: ' +
-        this.expectingArray_().map( tokenName ).sort().join( ',' ) );
+        this.expectingArray_().map( tokenName ).sort().join( ', ' ) );
   }
 
   reportReservedWord_() {
@@ -875,7 +894,7 @@ class BaseParser {
       this.log( indent, line, `(${ la })` );
       return;
     }
-    else if (la === 2) {
+    else if (la === 2) {        // confirming tokens in expected set
       this.log( indent, '          ', msg + ':',
                 this.trace.map( traceStep ).join( ' → ' ) );
       this.trace = [ this.s ?? '⚠' ];
@@ -887,31 +906,23 @@ class BaseParser {
       this.trace = [ -1 ];
     }
     this.trace.push( this.s ?? '⚠' );
-    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 })`;
-
+    if (Array.isArray( msg )) { // rule call and exit
+      const [ intro, state, finale, exit ] = msg;
       let start = state;
       while (typeof this.table[--start] !== 'string')
         ;
-      const post = (exitLength || start + 1 < state) && finale;
-      msg = `${ intro } “${ this.table[start] }”${ post || '' },`;
+      const post = (exit || start + 1 < state) && finale;
+      msg = `${ intro } “${ this.table[start] }”${ post || '' } ${ exit || 'from' } stack level ${ this.stack.length }`;
     }
     // 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.log( line + col + indent + msg + ', states:',
+              this.trace.map( traceStep ).join( ' → ' ) );
     this.trace = [ this.s ?? '⚠' ];
   }
 
-  inSameRule_( lowState, highState ) {
+  inSameRule_( lowState = this.s, highState = this.stack.at(-1).followState ) {
     if (lowState > highState)
       [ lowState, highState ] = [ highState, lowState ];
     while (lowState < highState) {
@@ -923,24 +934,24 @@ class BaseParser {
 
   // Predefined conditions with extra option names:
 
-  hide_( mode ) {
+  hide_( _arg, mode ) {
     return mode === 'M';
   }
-  precLeft_( _test, prec ) {    // <prec=…>, <…,assoc=left>, <…,prefix=once>
+  precLeft_( prec ) {           // <prec=…>, <…,assoc=left>, <…,prefix=once>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec)
       return true;
     this.prec_ = prec;
     return false;
   }
-  precRight_( _test, prec ) {   // <…,assoc=right>, <…,prefix>
+  precRight_( prec ) {          // <…,assoc=right>, <…,prefix>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec)
       return true;
     this.prec_ = prec - 1;
     return false;
   }
-  precNone_( _test, prec ) {    // <…,assoc=none>, <…,postfix=once>
+  precNone_( prec ) {           // <…,assoc=none>, <…,postfix=once>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec ||
         this.prec_ != null && this.prec_ <= prec)
@@ -948,7 +959,7 @@ class BaseParser {
     this.prec_ = prec;
     return false;
   }
-  precPost_( _test, prec ) {    // <…,postfix>
+  precPost_( prec ) {           // <…,postfix>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec ||
         this.prec_ != null && this.prec_ < prec)

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-226c8854e08665b3eaae3ae1a1276db7
+eb778bab22f4006cfcf64e418dcae71c