@sap/cds-compiler 2.15.4 → 3.0.0

package/lib/language/errorStrategy.js

@@ -29,12 +29,12 @@
 'use strict';
 
 const antlr4 = require('antlr4');
-const IntervalSet = require('antlr4/IntervalSet');
-const antlr4_error = require('antlr4/error/ErrorStrategy');
-const antlr4_LL1Analyzer = require('antlr4/LL1Analyzer.js').LL1Analyzer;
-const predictionContext = require('antlr4/PredictionContext').predictionContextFromRuleContext;
-const { ATNState } = require('antlr4/atn/ATNState');
-const { InputMismatchException } = antlr4.error;
+const antlr4_LL1Analyzer = require('antlr4/src/antlr4/LL1Analyzer');
+const { DefaultErrorStrategy } = require('antlr4/src/antlr4/error/ErrorStrategy');
+const { InputMismatchException } = require('antlr4/src/antlr4/error/Errors');
+const { predictionContextFromRuleContext: predictionContext } = require('antlr4/src/antlr4/PredictionContext');
+const { ATNState } = require('antlr4/src/antlr4/atn/ATNState');
+const { IntervalSet, Interval } = require('antlr4/src/antlr4/IntervalSet');
 
 const keywordRegexp = /^[a-zA-Z]+$/; // we don't have keywords with underscore
 
@@ -65,30 +65,35 @@ function match( ttype ) {
 //
 // An instance of this class should be set as property `_errHandler` to the
 // parser (prototype).
-function KeywordErrorStrategy( ...args ) {
-  antlr4_error.DefaultErrorStrategy.call( this, ...args );
-}
-const super1 = antlr4_error.DefaultErrorStrategy.prototype;
-
-KeywordErrorStrategy.prototype = Object.assign(
-  Object.create( super1 ), {
-    sync,
-    reportNoViableAlternative,
-    reportInputMismatch,
-    reportUnwantedToken,
-    reportMissingToken,
-    reportIgnoredWith,
-    // getErrorRecoverySet,
-    consumeUntil,
-    recoverInline,
-    getMissingSymbol,
-    getExpectedTokensForMessage,
-    getTokenDisplay,
-    constructor: KeywordErrorStrategy,
+class KeywordErrorStrategy extends DefaultErrorStrategy {
+  constructor( ...args ) {
+    super( ...args );
+
+    this._super = {
+      consumeUntil: super.consumeUntil,
+      recoverInline: super.recoverInline,
+      getExpectedTokens: super.getExpectedTokens,
+    };
   }
-);
+}
 
-// Attemp to recover from problems in subrules, except if rule has defined a
+// TODO: Use actual methods
+Object.assign( KeywordErrorStrategy.prototype, {
+  sync,
+  reportNoViableAlternative,
+  reportInputMismatch,
+  reportUnwantedToken,
+  reportMissingToken,
+  reportIgnoredWith,
+  // getErrorRecoverySet,
+  consumeUntil,
+  recoverInline,
+  getMissingSymbol,
+  getExpectedTokensForMessage,
+  getTokenDisplay,
+});
+
+// Attempt to recover from problems in subrules, except if rule has defined a
 // local variable `_sync` with value 'nop'
 function sync( recognizer ) {
   // If already recovering, don't try to sync
@@ -166,7 +171,7 @@ function sync( recognizer ) {
     case ATNState.STAR_LOOP_BACK: { // 9
       // TODO: do not delete a '}'
       this.reportUnwantedToken(recognizer);
-      const expecting = new IntervalSet.IntervalSet();
+      const expecting = new IntervalSet();
       expecting.addSet(recognizer.getExpectedTokens());
       const whatFollowsLoopIterationOrRule = expecting.addSet(this.getErrorRecoverySet(recognizer));
       this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);
@@ -270,21 +275,21 @@ function consumeUntil( recognizer, set ) {
 
   // let s=this.getTokenDisplay( recognizer.getCurrentToken(), recognizer );
   if (SEMI < 1 || RBRACE < 1) {
-    super1.consumeUntil.call( this, recognizer, set );
+    this._super.consumeUntil.call( this, recognizer, set );
   }
   else if (set.contains(SEMI)) { // do not check for RBRACE here!
-    super1.consumeUntil.call( this, recognizer, set );
+    this._super.consumeUntil.call( this, recognizer, set );
     // console.log('CONSUMED-ORIG:',s,this.getTokenDisplay( recognizer.getCurrentToken(), recognizer ),recognizer.getCurrentToken().line,intervalSetToArray( recognizer, set ));
   }
   else {
     // DO NOT modify input param `set`, as the set might be cached in the ATN
-    const stop = new IntervalSet.IntervalSet();
+    const stop = new IntervalSet();
     stop.addSet( set );
     stop.removeOne( recognizer.constructor.Identifier );
     stop.addOne( SEMI );
     // I am not that sure whether to add RBRACE...
     stop.addOne( RBRACE );
-    super1.consumeUntil.call( this, recognizer, stop );
+    this._super.consumeUntil.call( this, recognizer, stop );
     if (recognizer.getTokenStream().LA(1) === SEMI ||
         recognizer.getTokenStream().LA(1) === RBRACE && !set.contains(RBRACE)) {
       recognizer.consume();
@@ -310,11 +315,11 @@ function consumeUntil( recognizer, set ) {
 function recoverInline( recognizer ) {
   const identType = recognizer.constructor.Identifier;
   if (!identType || !recognizer.isExpectedToken( identType ))
-    return super1.recoverInline.call( this, recognizer );
+    return this._super.recoverInline.call( this, recognizer );
 
   const token = recognizer.getCurrentToken();
   if (!keywordRegexp.test( token.text ))
-    return super1.recoverInline.call( this, recognizer );
+    return this._super.recoverInline.call( this, recognizer );
 
   recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text },
                       '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it' );
@@ -344,8 +349,12 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
     for (let j = v.start; j < v.stop; j++) {
       // a generic keyword as such does not appear in messages, only its replacements,
       // which are function name and argument position dependent:
-      if (j === pc.GenericArgFull)
-        names.push( ...recognizer.$genericKeywords.argFull );
+      if (j === pc.GenericExpr)
+        names.push( ...recognizer.$genericKeywords.expr );
+      else if (j === pc.GenericSeparator)
+        names.push( ...recognizer.$genericKeywords.separator );
+      else if (j === pc.GenericIntro)
+        names.push( ...recognizer.$genericKeywords.introMsg );
       // other expected tokens usually appear in messages, except the helper tokens
       // which are used to solve ambiguities via the parser method setLocalToken():
       else if (j !== pc.HelperToken1 && j !== pc.HelperToken2)
@@ -362,6 +371,9 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
   else if (names.includes("';'")) {
     names = names.filter( n => n !== "'}'" );
   }
+  else if (names.includes("'?'")) {
+    names = names.filter( n => n !== "'?'" );
+  }
   names.sort( (a, b) => (tokenPrecedence(a) < tokenPrecedence(b) ? -1 : 1) );
   return names;
 }
@@ -421,10 +433,10 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   const hideAltsType = recognizer.constructor.HideAlternatives;
   const beforeUnreserved = recognizer.constructor.Number;
   if (!identType || !beforeUnreserved || beforeUnreserved + 2 > identType)
-    return intervalSetToArray( recognizer, super1.getExpectedTokens.call( this, recognizer ) );
+    return intervalSetToArray( recognizer, this._super.getExpectedTokens.call( this, recognizer ) );
 
   const ll1 = new antlr4_LL1Analyzer(atn);
-  const expected = new IntervalSet.IntervalSet();
+  const expected = new IntervalSet();
   const orig_addInterval = expected.addInterval;
   const orig_addSet = expected.addSet;
   expected.addInterval = addInterval;
@@ -485,7 +497,7 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   }
 
   function addRange( interval, start, stop ) {
-    orig_addInterval.call( interval, new IntervalSet.Interval( start, stop || start + 1 ) );
+    orig_addInterval.call( interval, new Interval( start, stop || start + 1 ) );
   }
 }