Fixed a number of linter issues.

eslint.config.mjs

@@ -50,6 +50,7 @@ export default tslint.config(
                     "code": 120
                 }
             ],
+            "brace-style": ["error", "1tbs", { "allowSingleLine": false }],
             "@stylistic/padding-line-between-statements": [
                 "error",
                 {
@@ -236,6 +237,12 @@ export default tslint.config(
                 // Have to switch this off, as it is not good enough to be used.
                 "off"
             ],
+            "jsdoc/no-undefined-types": [
+                "off", // Requires a comment syntax incompatible with VS Code.
+                {
+                    "markVariablesAsUsed": false
+                }
+            ],
             "prefer-arrow/prefer-arrow-functions": [
                 "warn",
                 {

package.json

@@ -1,6 +1,6 @@
 {
     "name": "antlr-ng",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "Next generation ANTLR Tool",
     "type": "module",
     "author": "Mike Lischke",
@@ -44,7 +44,7 @@
         "typescript-eslint": "8.7.0"
     },
     "scripts": {
-        "run": "node --no-warnings --loader ts-node/esm src/runner.ts",
+        "run": "node --no-warnings --loader ts-node/esm src/runner.ts --version",
         "lint": "eslint \"./src/**/*.ts\"",
         "lint:fix": "eslint \"./src/**/*.ts\" --fix",
         "test": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --no-coverage",

src/Tool.ts

@@ -44,8 +44,6 @@ import { GrammarRootAST } from "./tool/ast/GrammarRootAST.js";
 import { RuleAST } from "./tool/ast/RuleAST.js";
 
 export class Tool {
-    public static readonly VERSION = "10.0.0";
-
     public static readonly GRAMMAR_EXTENSION = ".g4";
     public static readonly LEGACY_GRAMMAR_EXTENSION = ".g";
 
@@ -275,12 +273,12 @@ export class Tool {
         const ruleToAST = new Map<string, RuleAST>();
         for (const r of rules) {
             const ruleAST = r as RuleAST;
-            const ID = ruleAST.getChild(0) as GrammarAST;
-            const ruleName = ID.getText()!;
+            const id = ruleAST.getChild(0) as GrammarAST;
+            const ruleName = id.getText()!;
             const prev = ruleToAST.get(ruleName);
             if (prev) {
                 const prevChild = prev.getChild(0) as GrammarAST;
-                g.tool.errMgr.grammarError(ErrorType.RULE_REDEFINITION, g.fileName, ID.getToken(), ruleName,
+                g.tool.errMgr.grammarError(ErrorType.RULE_REDEFINITION, g.fileName, id.getToken(), ruleName,
                     prevChild.getToken()!.line);
                 redefinition = true;
                 continue;
@@ -624,15 +622,13 @@ export class Tool {
         }
     }
 
-    public version(): void {
-        this.info("ANTLR Parser Generator Version " + Tool.VERSION);
-    }
-
     public exit(e: number): void {
         process.exit(e);
     }
 
-    public panic(): void { throw new Error("ANTLR panic"); }
+    public panic(): void {
+        throw new Error("ANTLR panic"); 
+    }
 
     protected writeDOTFile(g: Grammar, rulOrName: Rule | string, dot: string): void {
         const name = rulOrName instanceof Rule ? rulOrName.g.name + "." + rulOrName.name : rulOrName;

src/analysis/LeftRecursiveRuleTransformer.ts

@@ -117,7 +117,7 @@ export class LeftRecursiveRuleTransformer {
         }
 
         // replace old rule's AST; first create text of altered rule
-        const RULES = ast.getFirstChildWithType(ANTLRv4Parser.RULE_REF) as GrammarAST;
+        const rules = ast.getFirstChildWithType(ANTLRv4Parser.RULE_REF) as GrammarAST;
         const newRuleText = leftRecursiveRuleWalker.getArtificialOpPrecRule();
 
         // now parse within the context of the grammar that originally created
@@ -134,7 +134,7 @@ export class LeftRecursiveRuleTransformer {
         (t.getChild(0) as GrammarAST).token = (prevRuleAST.getChild(0) as GrammarAST).getToken();
 
         // update grammar AST and set rule's AST.
-        RULES.setChild(prevRuleAST.getChildIndex(), t);
+        rules.setChild(prevRuleAST.getChildIndex(), t);
         r.ast = t;
 
         // Reduce sets in newly created rule tree
@@ -180,7 +180,7 @@ export class LeftRecursiveRuleTransformer {
         const arg = r.ast.getFirstChildWithType(ANTLRv4Parser.BEGIN_ARGUMENT) as ActionAST | null;
         if (arg !== null) {
             r.args = ScopeParser.parseTypedArgList(arg, arg.getText()!, this.g);
-            r.args.type = DictType.ARG;
+            r.args.type = DictType.Argument;
             r.args.ast = arg;
             arg.resolver = r.alt[1]; // todo: isn't this Rule or something?
         }

src/antlr3/BaseRecognizer.ts

@@ -494,9 +494,7 @@ export abstract class BaseRecognizer {
             console.log(" backtracking=" + this.state.backtracking);
             if (this.state.failed) {
                 console.log(" failed");
-            }
-
-            else {
+            } else {
                 console.log(" succeeded");
             }
 

src/antlr3/tree/CommonErrorNode.ts

@@ -17,8 +17,7 @@ export class CommonErrorNode extends CommonTree {
     public stop: Token;
     public trappedException: RecognitionException;
 
-    public constructor(input: TokenStream, start: Token, stop: Token,
-        e: RecognitionException) {
+    public constructor(input: TokenStream, start: Token, stop: Token | null, e: RecognitionException) {
         super();
 
         if (stop === null ||

src/antlr3/tree/CommonTreeNodeStream.ts

@@ -126,7 +126,7 @@ export class CommonTreeNodeStream extends LookaheadStream<Tree>
         return this.adaptor.getType(o) === Token.EOF;
     }
 
-    public setUniqueNavigationNodes(uniqueNavigationNodes: boolean): void { }
+    public setUniqueNavigationNodes(uniqueNavigationNodes: boolean): void { /**/ }
 
     public getTreeSource(): unknown {
         return this.root;
@@ -166,9 +166,6 @@ export class CommonTreeNodeStream extends LookaheadStream<Tree>
      *  Switch back with pop().
      */
     public push(index: number): void {
-        if (this.calls === null) {
-            this.calls = [];
-        }
         this.calls.push(this.p); // save current index
         this.seek(index);
     }
@@ -228,9 +225,7 @@ export class CommonTreeNodeStream extends LookaheadStream<Tree>
     // TREE REWRITE INTERFACE
 
     public replaceChildren(parent: Tree, startChildIndex: number, stopChildIndex: number, t: Tree): void {
-        if (parent !== null) {
-            this.adaptor.replaceChildren(parent, startChildIndex, stopChildIndex, t);
-        }
+        this.adaptor.replaceChildren(parent, startChildIndex, stopChildIndex, t);
     }
 
     /*public toString(start: Tree, stop: Tree): string {

src/antlr3/tree/TreeIterator.ts

@@ -27,7 +27,7 @@ export class TreeIterator {
     public down: Tree;
     public eof: Tree;
     protected adaptor: TreeAdaptor;
-    protected root: Tree;
+    protected root: Tree | null;
     protected tree: Tree | null;
     protected firstTime = true;
 
@@ -71,7 +71,7 @@ export class TreeIterator {
             return this.root !== null;
         }
 
-        if (this.nodes !== null && this.nodes.size > 0) {
+        if (this.nodes.size > 0) {
             return true;
         }
 
@@ -98,7 +98,7 @@ export class TreeIterator {
             return this.tree;
         }
         // if any queued up, use those first
-        if (this.nodes !== null && this.nodes.size > 0) {
+        if (this.nodes.size > 0) {
             return this.nodes.remove();
         }
 

src/antlr3/tree/TreeNodeStream.ts

@@ -31,6 +31,7 @@ export interface TreeNodeStream extends IntStream {
      * instead of a {@link Token}. Makes code generation identical for both
      * parser and tree grammars.</p>
      */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     LT(k: number): Tree | null;
 
     /**

src/antlr3/tree/TreePatternParser.ts

@@ -62,8 +62,7 @@ export class TreePatternParser {
                 if (subtree) {
                     this.adaptor.addChild(root, subtree);
                 }
-            }
-            else {
+            } else {
                 const child = this.parseNode();
                 if (child === null) {
                     return null;

src/antlr3/tree/TreeRewriter.ts

@@ -21,7 +21,7 @@ import type { TreeRuleReturnScope } from "./TreeRuleReturnScope.js";
 
 // cspell: disable
 
-interface fptr {
+interface Fptr {
     rule(): unknown;
 }
 
@@ -32,14 +32,18 @@ export class TreeRewriter extends TreeParser {
     protected originalTokenStream: TokenStream;
     protected originalAdaptor: TreeAdaptor;
 
-    private topdown_fptr = new class implements fptr {
+    private topdown_fptr = new class implements Fptr {
         public constructor(private $outer: TreeRewriter) { }
-        public rule(): unknown { return this.$outer.topdown(); }
+        public rule(): unknown {
+            return this.$outer.topdown(); 
+        }
     }(this);
 
-    private bottomup_ftpr = new class implements fptr {
+    private bottomup_ftpr = new class implements Fptr {
         public constructor(private $outer: TreeRewriter) { }
-        public rule(): unknown { return this.$outer.bottomup(); }
+        public rule(): unknown {
+            return this.$outer.bottomup(); 
+        }
     }(this);
 
     public constructor(input: TreeNodeStream, state?: RecognizerSharedState) {
@@ -49,7 +53,7 @@ export class TreeRewriter extends TreeParser {
         this.originalTokenStream = input.getTokenStream();
     }
 
-    public applyOnce(t: Tree | null, whichRule: fptr): Tree | null {
+    public applyOnce(t: Tree | null, whichRule: Fptr): Tree | null {
         if (t === null) {
             return null;
         }
@@ -77,15 +81,17 @@ export class TreeRewriter extends TreeParser {
                 return t;
             }
         } catch (e) {
-            if (e instanceof RecognitionException) { ; } else {
+            if (e instanceof RecognitionException) {
+                ; 
+            } else {
                 throw e;
             }
         }
 
         return t;
     }
 
-    public applyRepeatedly(t: Tree | null, whichRule: fptr): Tree | null {
+    public applyRepeatedly(t: Tree | null, whichRule: Fptr): Tree | null {
         let treeChanged = true;
         while (treeChanged) {
             const u = this.applyOnce(t, whichRule);
@@ -102,8 +108,12 @@ export class TreeRewriter extends TreeParser {
         const v = new TreeVisitor(new CommonTreeAdaptor());
         const actions = new class implements TreeVisitorAction<Tree> {
             public constructor(private $outer: TreeRewriter) { }
-            public pre(t: Tree): Tree | null { return this.$outer.applyOnce(t, this.$outer.topdown_fptr); }
-            public post(t: Tree): Tree | null { return this.$outer.applyRepeatedly(t, this.$outer.bottomup_ftpr); }
+            public pre(t: Tree): Tree | null {
+                return this.$outer.applyOnce(t, this.$outer.topdown_fptr); 
+            }
+            public post(t: Tree): Tree | null {
+                return this.$outer.applyRepeatedly(t, this.$outer.bottomup_ftpr); 
+            }
         }(this);
         t = v.visit(t, actions);
 
@@ -121,6 +131,10 @@ export class TreeRewriter extends TreeParser {
     // methods the downup strategy uses to do the up and down rules.
     // to override, just define tree grammar rule topdown and turn on
     // filter=true.
-    public topdown(): Tree | null { return null; }
-    public bottomup(): Tree | null { return null; }
+    public topdown(): Tree | null {
+        return null; 
+    }
+    public bottomup(): Tree | null {
+        return null; 
+    }
 }

src/antlr3/tree/TreeRuleReturnScope.ts

@@ -25,5 +25,7 @@ export class TreeRuleReturnScope {
      * Has a value potentially if output=template; Don't use StringTemplate
      * type as it then causes a dependency with ST lib.
      */
-    public getTemplate(): unknown { return null; }
+    public getTemplate(): unknown {
+        return null; 
+    }
 }

src/antlr3/tree/TreeVisitor.ts

@@ -34,8 +34,7 @@ export class TreeVisitor {
      *
      *  Return result of applying post action to this node.
      */
-    public visit<T extends Tree>(t: T | null, action: TreeVisitorAction<T>): T | null {
-        // System.out.println("visit "+((Tree)t).toStringTree());
+    public visit<T extends Tree>(t: T | null, action: TreeVisitorAction<T> | null): T | null {
         const isNil = this.adaptor.isNil(t);
         if (action !== null && !isNil) {
             t = action.pre(t); // if rewritten, walk children of new t

src/automata/ATNVisitor.ts

@@ -13,10 +13,14 @@ import { ATNState } from "antlr4ng";
  */
 export class ATNVisitor {
     public visit(s: ATNState): void {
-        this.visit_(s, new Set<number>());
+        this.doVisit(s, new Set<number>());
     }
 
-    public visit_(s: ATNState, visited: Set<number>): void {
+    public visitState(s: ATNState): void {
+        // intentionally empty
+    }
+
+    private doVisit(s: ATNState, visited: Set<number>): void {
         if (visited.has(s.stateNumber)) {
             return;
         }
@@ -25,11 +29,8 @@ export class ATNVisitor {
 
         this.visitState(s);
         for (const t of s.transitions) {
-            this.visit_(t.target, visited);
+            this.doVisit(t.target, visited);
         }
     }
 
-    public visitState(s: ATNState): void {
-        // intentionally empty
-    }
 }