Active parser error handling and recovery

Author: SSlinky

server/src/project/parser/vbaAntlr.ts

@@ -1,5 +1,5 @@
 // Antlr
-import { CharStream, CommonTokenStream, Token, TokenStream } from 'antlr4ng';
+import { CharStream, CommonTokenStream, InputMismatchException, IntervalSet, Token, TokenStream } from 'antlr4ng';
 import { DefaultErrorStrategy, Parser, RecognitionException } from 'antlr4ng';
 import { vbaLexer } from '../../antlr/out/vbaLexer';
 import { vbaParser } from '../../antlr/out/vbaParser';
@@ -89,12 +89,80 @@ export class VbaFmtParser extends vbafmtParser {
 
 
 export class VbaErrorHandler extends DefaultErrorStrategy {
-    recover(recognizer: Parser, e: RecognitionException): void {
+    override recover(recognizer: Parser, e: RecognitionException): void {
         // Consume the error token if look-ahead is not EOF.
         const inputStream = recognizer.inputStream;
-        if (inputStream.LA(1) === Token.EOF) {
+        if (inputStream.LA(1) !== Token.EOF) {
             inputStream.consume();
         }
         this.endErrorCondition(recognizer);
     }
+
+    override recoverInline(recognizer: Parser): Token {
+        const stream = recognizer.inputStream;
+        const thisToken = recognizer.getCurrentToken();
+
+        // Recover using deletion strategy.
+        const nextToken = stream.LT(2);
+        const expectedTokens = recognizer.getExpectedTokens();
+        if (nextToken && expectedTokens.contains(nextToken.type)) {
+            recognizer.consume();
+            this.reportMatch(recognizer);
+            return thisToken;
+        }
+
+        // Failsafe to prevent circular insertions.
+        const MAXRECURSION = -20
+        for (let i = -1; i >= MAXRECURSION; i--) {
+            if (i <= -20) {
+                throw new InputMismatchException(recognizer);
+            }
+            const wasInsertedToken = this.isTokenPositionMatch(thisToken, recognizer.inputStream.LT(i));
+            if (!wasInsertedToken) {
+                break;
+            }
+        }
+
+        // Recover using insertion strategy.
+        const missingToken = this.createErrorToken(recognizer, expectedTokens);
+        this.reportMatch(recognizer);
+        return missingToken;
+    }
+
+    private createErrorToken(recognizer: Parser, expectedTokens: IntervalSet): Token {
+        // Set up the token attributes.
+        const type = expectedTokens.length === 0
+            ? Token.INVALID_TYPE
+            : expectedTokens.minElement;
+
+        const expectedIdentifiers = expectedTokens.toArray().map(
+            t => recognizer.vocabulary.getLiteralName(t)
+                ?? recognizer.vocabulary.getDisplayName(t)
+        );
+        const plural = expectedIdentifiers.length > 1 ? 's' : '';
+        const expectedText = expectedIdentifiers.join(', ');
+        const text = `<missing token${plural} ${expectedText}>`;
+        const currentToken = recognizer.getCurrentToken();
+
+        // Create the token.
+        return recognizer.getTokenFactory().create(
+            [
+                recognizer.tokenStream.tokenSource,
+                recognizer.tokenStream.tokenSource.inputStream
+            ],
+            type,
+            text,
+            Token.DEFAULT_CHANNEL,
+            currentToken.start,
+            currentToken.stop,
+            currentToken.line,
+            currentToken.column
+        )
+    }
+
+    private isTokenPositionMatch(a: Token | null, b: Token | null): boolean {
+        return !!a && !!b
+            && a.line === b.line
+            && a.column === b.column;
+    }
 }

server/src/project/parser/vbaListener.ts

@@ -43,7 +43,6 @@ import {
     DocumentElementContext,
     IndentAfterElementContext,
     LabelStatementContext,
-    LineEndingContext,
     MethodParametersContext,
     OutdentBeforeElementContext,
     OutdentOnIndentAfterElementContext,

server/src/project/parser/vbaParser.ts

@@ -1,6 +1,6 @@
 // Antlr
 import { ParseCancellationException, ParseTreeWalker } from 'antlr4ng';
-import { VbaFmtParser, VbaParser, VbaPreParser } from './vbaAntlr';
+import { VbaErrorHandler, VbaFmtParser, VbaParser, VbaPreParser } from './vbaAntlr';
 import { VbaFmtListener, VbaListener, VbaPreListener } from './vbaListener';
 
 // Project