refactor(JS: explicitly using TerminalNode): move the implementation to TerminalNode/ErrorNode and actually use them.

runtime/JavaScript/src/antlr4/Parser.js

@@ -355,7 +355,7 @@ export default class Parser extends Recognizer {
             node.invokingState = this.state;
             if (hasListener) {
                 this._parseListeners.forEach(function (listener) {
-                    if (node instanceof ErrorNode || (node.isErrorNode !== undefined && node.isErrorNode())) {
+                    if (node instanceof ErrorNode) {
                         listener.visitErrorNode(node);
                     } else if (node instanceof TerminalNode) {
                         listener.visitTerminal(node);

runtime/JavaScript/src/antlr4/context/ParserRuleContext.js

@@ -5,8 +5,7 @@
 
 import RuleContext from './RuleContext.js';
 import TerminalNode from '../tree/TerminalNode.js';
-import TerminalNodeImpl from '../tree/TerminalNodeImpl.js';
-import ErrorNodeImpl from '../tree/ErrorNodeImpl.js';
+import ErrorNode from '../tree/ErrorNode.js';
 import Interval from "../misc/Interval.js";
 
 /**
@@ -67,7 +66,7 @@ export default class ParserRuleContext extends RuleContext {
 			this.children = [];
 			// reset parent pointer for any error nodes
 			ctx.children.map(function(child) {
-				if (child instanceof ErrorNodeImpl) {
+				if (child instanceof ErrorNode) {
 					this.children.push(child);
 					child.parentCtx = this;
 				}
@@ -102,14 +101,14 @@ export default class ParserRuleContext extends RuleContext {
 	}
 
 	addTokenNode(token) {
-		const node = new TerminalNodeImpl(token);
+		const node = new TerminalNode(token);
 		this.addChild(node);
 		node.parentCtx = this;
 		return node;
 	}
 
 	addErrorNode(badToken) {
-		const node = new ErrorNodeImpl(badToken);
+		const node = new ErrorNode(badToken);
 		this.addChild(node);
 		node.parentCtx = this;
 		return node;

runtime/JavaScript/src/antlr4/context/RuleContext.d.ts

@@ -1,10 +1,11 @@
-import {RuleNode} from "../tree/index.js";
-import {Parser} from "../Parser.js";
+import {ParseTreeVisitor, RuleNode} from "../tree/index.js";
+import { Parser } from "../Parser.js";
 
 export declare class RuleContext extends RuleNode {
     parentCtx: RuleContext | undefined;
     invokingState: number;
 
+    accept<T>(visitor: ParseTreeVisitor<T>): T;
     get ruleContext() : RuleContext;
     toStringTree(ruleNames: string[] | null, recog: Parser) : string;
 }

runtime/JavaScript/src/antlr4/tree/ErrorNode.d.ts

@@ -1,5 +1,6 @@
-import {TerminalNode} from "./TerminalNode.js";
+import { ParseTreeVisitor } from "./ParseTreeVisitor.js";
+import { TerminalNode } from "./TerminalNode.js";
 
 export declare class ErrorNode extends TerminalNode {
-
+    accept<T>(visitor: ParseTreeVisitor<T>): T;
 }

runtime/JavaScript/src/antlr4/tree/ErrorNode.js

@@ -4,5 +4,23 @@
  */
 import TerminalNode from "./TerminalNode.js";
 
+/**
+ * Represents a token that was consumed during resynchronization
+ * rather than during a valid match operation. For example,
+ * we will create this kind of a node during single token insertion
+ * and deletion as well as during "consume until error recovery set"
+ * upon no viable alternative exceptions.
+ */
 export default class ErrorNode extends TerminalNode {
+    constructor(token) {
+        super(token);
+    }
+
+    isErrorNode() {
+        return true;
+    }
+
+    accept(visitor) {
+        return visitor.visitErrorNode(this);
+    }
 }

runtime/JavaScript/src/antlr4/tree/ParseTree.d.ts

@@ -1,5 +1,7 @@
 import {SyntaxTree} from "./SyntaxTree.js";
+import {ParseTreeVisitor} from "./ParseTreeVisitor";
 
-export declare class ParseTree extends SyntaxTree {
+export declare abstract class ParseTree extends SyntaxTree {
     getText(): string;
+    abstract accept<T>(visitor: ParseTreeVisitor<T>): T;
 }

runtime/JavaScript/src/antlr4/tree/ParseTree.js

@@ -5,4 +5,8 @@
 import SyntaxTree from "./SyntaxTree.js";
 
 export default class ParseTree extends SyntaxTree {
+
+    accept(visitor) {
+        throw new Error("missing interface implementation")
+    }
 }

runtime/JavaScript/src/antlr4/tree/ParseTreeWalker.js

@@ -16,9 +16,7 @@ export default class ParseTreeWalker {
      * @param t The parse tree to be walked on
      */
     walk(listener, t) {
-        const errorNode = t instanceof ErrorNode ||
-            (t.isErrorNode !== undefined && t.isErrorNode());
-        if (errorNode) {
+        if (t instanceof ErrorNode) {
             listener.visitErrorNode(t);
         } else if (t instanceof TerminalNode) {
             listener.visitTerminal(t);

runtime/JavaScript/src/antlr4/tree/TerminalNode.d.ts

@@ -1,8 +1,10 @@
 import {ParserRuleContext} from "../context/index.js";
 import {ParseTree} from "./ParseTree.js";
 import {Token} from "../Token.js";
+import { ParseTreeVisitor } from "./ParseTreeVisitor.js";
 
 export declare class TerminalNode extends ParseTree {
     symbol: Token;
     parentCtx: ParserRuleContext;
+    accept<T>(visitor: ParseTreeVisitor<T>): T;
 }

runtime/JavaScript/src/antlr4/tree/TerminalNode.js

@@ -3,6 +3,57 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 import ParseTree from "./ParseTree.js";
+import Interval from "../misc/Interval.js";
+import Token from "../Token.js";
 
 export default class TerminalNode extends ParseTree {
+    constructor(symbol) {
+        super();
+        this.parentCtx = null;
+        this.symbol = symbol;
+    }
+
+    getChild(i) {
+        return null;
+    }
+
+    getSymbol() {
+        return this.symbol;
+    }
+
+    getParent() {
+        return this.parentCtx;
+    }
+
+    getPayload() {
+        return this.symbol;
+    }
+
+    getSourceInterval() {
+        if (this.symbol === null) {
+            return Interval.INVALID_INTERVAL;
+        }
+        const tokenIndex = this.symbol.tokenIndex;
+        return new Interval(tokenIndex, tokenIndex);
+    }
+
+    getChildCount() {
+        return 0;
+    }
+
+    accept(visitor) {
+        return visitor.visitTerminal(this);
+    }
+
+    getText() {
+        return this.symbol.text;
+    }
+
+    toString() {
+        if (this.symbol.type === Token.EOF) {
+            return "<EOF>";
+        } else {
+            return this.symbol.text;
+        }
+    }
 }