github.com/antlr4-go/antlr/v4 v4.13.0: antlr.NewParseTreeWalker

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify antlr.NewParseTreeWalker in pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0
Demonstrate these symbols/APIs:
  - antlr.NewParseTreeWalker
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:d81bba558663f4d85d54c9f4a7f0e9392cf87248174277676910edcf12ace4d1","constraints":{"executionContext":"go"},"contract":["antlr.NewParseTreeWalker traverses parse trees in depth-first order triggering EnterEveryRule, VisitTerminal, and ExitEveryRule events on custom listeners embedding antlr.BaseParseTreeListener."],"goal":"verify antlr.NewParseTreeWalker in pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0","kind":"HOW","packages":["pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0"],"schemaVersion":1,"symbols":["antlr.NewParseTreeWalker"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","executionContext":"go","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","runtime":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0","symbols":["antlr.NewParseTreeWalker"],"verifierAdapter":"golang@1"}

module example.com/antlrsample

go 1.22

require github.com/antlr4-go/antlr/v4 v4.13.0

require golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc // indirect

github.com/antlr4-go/antlr/v4 v4.13.0 h1:lxCg3LAv+EUK6t1i0y1V6/SLeUi0eKEKdhQAlS8TVTI=
github.com/antlr4-go/antlr/v4 v4.13.0/go.mod h1:pfChB/xh/Unjila75QW7+VU4TSnWnnk9UTnmpPaOR2g=
golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU=
golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=

{
  "schemaVersion": 1,
  "goal": "verify antlr.NewParseTreeWalker in pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.0"
  ],
  "symbols": [
    "antlr.NewParseTreeWalker"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

package antlrsample_test

import (
	"testing"

	"github.com/antlr4-go/antlr/v4"
)

type customListener struct {
	*antlr.BaseParseTreeListener
	enteredRules []int
	exitedRules  []int
	terminals    []string
}

func newCustomListener() *customListener {
	return &customListener{
		BaseParseTreeListener: &antlr.BaseParseTreeListener{},
		enteredRules:          make([]int, 0),
		exitedRules:           make([]int, 0),
		terminals:             make([]string, 0),
	}
}

func (l *customListener) EnterEveryRule(ctx antlr.ParserRuleContext) {
	l.enteredRules = append(l.enteredRules, ctx.GetRuleIndex())
}

func (l *customListener) ExitEveryRule(ctx antlr.ParserRuleContext) {
	l.exitedRules = append(l.exitedRules, ctx.GetRuleIndex())
}

func (l *customListener) VisitTerminal(node antlr.TerminalNode) {
	l.terminals = append(l.terminals, node.GetText())
}

const (
	ruleExpr = 0
	ruleTerm = 1
)

func createToken(tokenType int, text string) antlr.Token {
	return antlr.CommonTokenFactoryDEFAULT.Create(
		&antlr.TokenSourceCharStreamPair{},
		tokenType,
		text,
		antlr.TokenDefaultChannel,
		0,
		len(text)-1,
		1,
		0,
	)
}

func buildTree() antlr.Tree {
	root := antlr.NewBaseParserRuleContext(nil, -1)
	root.RuleIndex = ruleExpr

	left := antlr.NewBaseParserRuleContext(root, -1)
	left.RuleIndex = ruleTerm
	left.AddTokenNode(createToken(1, "alpha"))
	root.AddChild(left)

	root.AddTokenNode(createToken(2, "+"))

	right := antlr.NewBaseParserRuleContext(root, -1)
	right.RuleIndex = ruleTerm
	right.AddTokenNode(createToken(1, "beta"))
	root.AddChild(right)

	return root
}

func TestParseTreeWalker(t *testing.T) {
	tree := buildTree()
	walker := antlr.NewParseTreeWalker()
	listener := newCustomListener()

	walker.Walk(listener, tree)

	expectedEntered := []int{ruleExpr, ruleTerm, ruleTerm}
	if len(listener.enteredRules) != len(expectedEntered) {
		t.Fatalf("unexpected entered rules count: got %d, want %d", len(listener.enteredRules), len(expectedEntered))
	}
	for i, r := range expectedEntered {
		if listener.enteredRules[i] != r {
			t.Errorf("at index %d: entered rule %d != expected %d", i, listener.enteredRules[i], r)
		}
	}

	expectedExited := []int{ruleTerm, ruleTerm, ruleExpr}
	if len(listener.exitedRules) != len(expectedExited) {
		t.Fatalf("unexpected exited rules count: got %d, want %d", len(listener.exitedRules), len(expectedExited))
	}
	for i, r := range expectedExited {
		if listener.exitedRules[i] != r {
			t.Errorf("at index %d: exited rule %d != expected %d", i, listener.exitedRules[i], r)
		}
	}

	expectedTerminals := []string{"alpha", "+", "beta"}
	if len(listener.terminals) != len(expectedTerminals) {
		t.Fatalf("unexpected terminals count: got %d, want %d", len(listener.terminals), len(expectedTerminals))
	}
	for i, term := range expectedTerminals {
		if listener.terminals[i] != term {
			t.Errorf("at terminal index %d: got %q, want %q", i, listener.terminals[i], term)
		}
	}
}