FailedPredicateException, InputMismatchException, InterpreterRuleCont…

…ext + Lexer done

Signed-off-by: Mike Lischke <[email protected]>

src/FailedPredicateException.js → src/FailedPredicateException.ts

@@ -5,6 +5,7 @@
  */
 
 import { PredicateTransition } from "./atn/PredicateTransition.js";
+import { Parser } from "./Parser.js";
 import { RecognitionException } from "./RecognitionException.js";
 
 /**
@@ -14,14 +15,17 @@ import { RecognitionException } from "./RecognitionException.js";
  * prediction.
  */
 export class FailedPredicateException extends RecognitionException {
+    private readonly ruleIndex: number = 0;
+    private readonly predicateIndex: number = 0;
+    private readonly predicate?: string;
 
-    constructor(recognizer, predicate, message) {
+    public constructor(recognizer: Parser, predicate?: string, message: string | null = null) {
         super({
-            message: formatMessage(predicate, message || null),
-            recognizer: recognizer,
-            input: recognizer.inputStream, ctx: recognizer._ctx
+            message: formatMessage(predicate ?? "no predicate", message ?? null),
+            recognizer,
+            input: recognizer.inputStream, ctx: recognizer.context,
         });
-        const s = recognizer.interpreter.atn.states[recognizer.state];
+        const s = recognizer.interpreter.atn.states[recognizer.state]!;
         const trans = s.transitions[0];
         if (trans instanceof PredicateTransition) {
             this.ruleIndex = trans.ruleIndex;
@@ -35,11 +39,10 @@ export class FailedPredicateException extends RecognitionException {
     }
 }
 
-
-function formatMessage(predicate, message) {
+const formatMessage = (predicate: string | null, message: string | null) => {
     if (message !== null) {
         return message;
     } else {
         return "failed predicate: {" + predicate + "}?";
     }
-}
+};

src/InputMismatchException.js → src/InputMismatchException.ts

@@ -5,14 +5,15 @@
  */
 
 import { RecognitionException } from "./RecognitionException.js";
+import { Parser } from "./Parser.js";
 
 /**
  * This signifies any kind of mismatched input exceptions such as
  * when the current input does not match the expected token.
  */
 export class InputMismatchException extends RecognitionException {
-    constructor(recognizer) {
-        super({ message: "", recognizer: recognizer, input: recognizer.inputStream, ctx: recognizer._ctx });
+    public constructor(recognizer: Parser) {
+        super({ message: "", recognizer, input: recognizer.inputStream, ctx: recognizer.context });
         this.offendingToken = recognizer.getCurrentToken();
     }
 }

src/IntStream.ts

@@ -4,8 +4,6 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 
-import type { CommonTokenStream } from "./CommonTokenStream.js";
-
 /**
  * A simple stream of symbols whose values are represented as integers. This
  * interface provides <em>marked ranges</em> with support for a minimum level

src/InterpreterRuleContext.d.ts → src/InterpreterRuleContext.ts

@@ -10,24 +10,29 @@ import { ParserRuleContext } from "./ParserRuleContext.js";
  * This class extends {@link ParserRuleContext} by allowing the value of
  * {@link #getRuleIndex} to be explicitly set for the context.
  *
+ * <p>
  * {@link ParserRuleContext} does not include field storage for the rule index
  * since the context classes created by the code generator override the
  * {@link #getRuleIndex} method to return the correct value for that context.
  * Since the parser interpreter does not use the context classes generated for a
  * parser, this class (with slightly more memory overhead per node) is used to
- * provide equivalent functionality.
+ * provide equivalent functionality.</p>
  */
 export class InterpreterRuleContext extends ParserRuleContext {
-    public constructor(ruleIndex: number);
-    /**
-     * Constructs a new {@link InterpreterRuleContext} with the specified
-     * parent, invoking state, and rule index.
-     *
-     * @param ruleIndex The rule index for the current context.
-     * @param parent The parent context.
-     * @param invokingStateNumber The invoking state number.
-     */
-    public constructor(ruleIndex: number, parent: ParserRuleContext | undefined, invokingStateNumber: number);
+    /** This is the backing field for {@link #getRuleIndex}. */
+    #ruleIndex: number;
 
-    public get ruleIndex(): number;
+    public constructor(ruleIndex: number, parent: ParserRuleContext | null, invokingStateNumber?: number) {
+        if (invokingStateNumber !== undefined) {
+            super(parent, invokingStateNumber);
+        } else {
+            super(parent);
+        }
+
+        this.#ruleIndex = ruleIndex;
+    }
+
+    public override get ruleIndex(): number {
+        return this.#ruleIndex;
+    }
 }