github.com/antlr4-go/antlr/v4 v4.13.1: antlr.BaseParseTreeVisitor

# antlr4-go BaseParseTreeVisitor Verification Notes

## Search Results
An initial search via `search_known_solution` for `pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1` with `antlr.BaseParseTreeVisitor` returned `NO_SAFE_MATCH`.

## Pinned Version
- Package: `github.com/antlr4-go/antlr/v4`
- Release: `v4.13.1` (in `go.mod` / `go.sum`)

## Observed Behavior
1. **BaseParseTreeVisitor Default Methods**:
   - `antlr.BaseParseTreeVisitor` provides default implementations for `Visit`, `VisitChildren`, `VisitTerminal`, and `VisitErrorNode` that return `nil` without panicking.
2. **Parse Tree Traversal**:
   - Custom visitors embedding `antlr.BaseParseTreeVisitor` can traverse parse tree hierarchies including rule contexts, terminal nodes, and error nodes by overriding `Visit` and `VisitChildren`.

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.BaseParseTreeVisitor in pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1
Demonstrate these symbols/APIs:
  - antlr.BaseParseTreeVisitor

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:d134d7bfbcd34ed2c3b40717ebcb6e9901c8e94667be828ac8308aa2d71dd380","contract":["antlr.BaseParseTreeVisitor provides default implementations returning nil for Visit, VisitChildren, VisitTerminal, and VisitErrorNode.","Custom visitors embedding antlr.BaseParseTreeVisitor can traverse parse tree hierarchies including rules, terminal nodes, and error nodes by overriding Visit and VisitChildren."],"goal":"verify antlr.BaseParseTreeVisitor in pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1","kind":"HOW","packages":["pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1"],"schemaVersion":1,"symbols":["antlr.BaseParseTreeVisitor"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1"],"schemaVersion":1,"subject":"pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1","symbols":["antlr.BaseParseTreeVisitor"],"verifierAdapter":"golang@1"}

module example.com/antlrvisitor

go 1.22

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

require golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect

github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ=
github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw=
golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=

{
  "schemaVersion": 1,
  "goal": "verify antlr.BaseParseTreeVisitor in pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/antlr4-go/antlr/v4@v4.13.1"
  ],
  "symbols": [
    "antlr.BaseParseTreeVisitor"
  ]
}

package antlrvisitor_test

import (
	"testing"

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

// CustomVisitor embeds antlr.BaseParseTreeVisitor to traverse parse trees and collect visited node texts.
type CustomVisitor struct {
	antlr.BaseParseTreeVisitor
	visitedRules []int
	terminals    []string
	errorNodes   []string
}

func (v *CustomVisitor) Visit(tree antlr.ParseTree) interface{} {
	return tree.Accept(v)
}

func (v *CustomVisitor) VisitChildren(node antlr.RuleNode) interface{} {
	for i := 0; i < node.GetChildCount(); i++ {
		child := node.GetChild(i)
		if pt, ok := child.(antlr.ParseTree); ok {
			v.Visit(pt)
		}
	}
	return nil
}

func (v *CustomVisitor) VisitTerminal(node antlr.TerminalNode) interface{} {
	v.terminals = append(v.terminals, node.GetText())
	return node.GetText()
}

func (v *CustomVisitor) VisitErrorNode(node antlr.ErrorNode) interface{} {
	v.errorNodes = append(v.errorNodes, node.GetText())
	return node.GetText()
}

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 TestBaseParseTreeVisitorDefaultMethods(t *testing.T) {
	base := &antlr.BaseParseTreeVisitor{}
	ruleCtx := antlr.NewBaseParserRuleContext(nil, -1)
	token := createToken(1, "leaf")
	terminalNode := antlr.NewTerminalNodeImpl(token)
	errorNode := antlr.NewErrorNodeImpl(token)

	// BaseParseTreeVisitor default methods should return nil without panicking
	if res := base.VisitChildren(ruleCtx); res != nil {
		t.Errorf("expected nil from VisitChildren, got %v", res)
	}

	if res := base.VisitTerminal(terminalNode); res != nil {
		t.Errorf("expected nil from VisitTerminal, got %v", res)
	}

	if res := base.VisitErrorNode(errorNode); res != nil {
		t.Errorf("expected nil from VisitErrorNode, got %v", res)
	}

	if res := base.Visit(terminalNode); res != nil {
		t.Errorf("expected nil from Visit(terminal), got %v", res)
	}
}

func TestCustomVisitorTreeTraversal(t *testing.T) {
	const (
		RuleProgram   = 0
		RuleStatement = 1
	)

	// Build parse tree: Program -> [ Statement("x"), Statement("y"), ErrorNode("!") ]
	rootCtx := antlr.NewBaseParserRuleContext(nil, -1)
	rootCtx.RuleIndex = RuleProgram

	stmt1 := antlr.NewBaseParserRuleContext(rootCtx, -1)
	stmt1.RuleIndex = RuleStatement
	stmt1.AddTokenNode(createToken(1, "x"))
	rootCtx.AddChild(stmt1)

	stmt2 := antlr.NewBaseParserRuleContext(rootCtx, -1)
	stmt2.RuleIndex = RuleStatement
	stmt2.AddTokenNode(createToken(1, "y"))
	rootCtx.AddChild(stmt2)

	errToken := createToken(antlr.TokenInvalidType, "!")
	rootCtx.AddErrorNode(errToken)

	visitor := &CustomVisitor{}
	visitor.Visit(rootCtx)

	// Verify terminals visited in tree order
	expectedTerminals := []string{"x", "y"}
	if len(visitor.terminals) != len(expectedTerminals) {
		t.Fatalf("expected %d terminals, got %d", len(expectedTerminals), len(visitor.terminals))
	}
	for i, term := range expectedTerminals {
		if visitor.terminals[i] != term {
			t.Errorf("terminal at %d: expected %q, got %q", i, term, visitor.terminals[i])
		}
	}

	// Verify error nodes visited
	expectedErrors := []string{"!"}
	if len(visitor.errorNodes) != len(expectedErrors) {
		t.Fatalf("expected %d error nodes, got %d", len(expectedErrors), len(visitor.errorNodes))
	}
	for i, err := range expectedErrors {
		if visitor.errorNodes[i] != err {
			t.Errorf("error node at %d: expected %q, got %q", i, err, visitor.errorNodes[i])
		}
	}
}