github.com/mitchellh/reflectwalk v1.0.2: Walk

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 github.com/mitchellh/reflectwalk.Walk in pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2
Demonstrate these symbols/APIs:
  - github.com/mitchellh/reflectwalk.Walk

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:7595613687a65f25d0b9a98517bd99fbec10310eb4f7ae3767081e1afe76c8cf","contract":["reflectwalk.Walk traverses struct values and visits primitive fields with PrimitiveWalker","reflectwalk.Walk traverses nested structs and inspects field metadata with StructWalker","reflectwalk.Walk iterates over slices and arrays and visits elements with SliceWalker and ArrayWalker","reflectwalk.Walk iterates over map key-value pairs with MapWalker","reflectwalk.Walk detects pointer references with PointerWalker","reflectwalk.Walk respects reflectwalk.SkipEntry to skip struct field traversal","reflectwalk.Walk tracks enter and exit lifecycle locations with EnterExitWalker"],"goal":"verify github.com/mitchellh/reflectwalk.Walk in pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2","kind":"HOW","packages":["pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2"],"schemaVersion":1,"symbols":["github.com/mitchellh/reflectwalk.Walk"]},"contractCommand":["go","run","./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/mitchellh/reflectwalk@v1.0.2"],"schemaVersion":1,"subject":"pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2","symbols":["github.com/mitchellh/reflectwalk.Walk"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/mitchellh/reflectwalk v1.0.2

github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=

package main

import (
	"fmt"
	"reflect"

	"github.com/mitchellh/reflectwalk"
)

type primitiveCollector struct {
	values []interface{}
}

func (c *primitiveCollector) Primitive(v reflect.Value) error {
	c.values = append(c.values, v.Interface())
	return nil
}

type ExampleData struct {
	Name   string
	Count  int
	Active bool
	Scores []int
}

func main() {
	data := ExampleData{
		Name:   "sample",
		Count:  42,
		Active: true,
		Scores: []int{10, 20, 30},
	}

	collector := &primitiveCollector{}
	if err := reflectwalk.Walk(data, collector); err != nil {
		fmt.Printf("Error walking data: %v\n", err)
		return
	}

	fmt.Printf("Collected primitives: %v\n", collector.values)
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/mitchellh/reflectwalk.Walk in pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2"
  ],
  "symbols": [
    "github.com/mitchellh/reflectwalk.Walk"
  ]
}

package main

import (
	"errors"
	"fmt"
	"os"
	"reflect"

	"github.com/mitchellh/reflectwalk"
)

func main() {
	if err := runContract(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract verification failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All reflectwalk contract assertions passed successfully.")
}

func runContract() error {
	if err := testPrimitiveWalker(); err != nil {
		return fmt.Errorf("testPrimitiveWalker: %w", err)
	}
	if err := testStructWalker(); err != nil {
		return fmt.Errorf("testStructWalker: %w", err)
	}
	if err := testSliceAndArrayWalker(); err != nil {
		return fmt.Errorf("testSliceAndArrayWalker: %w", err)
	}
	if err := testMapWalker(); err != nil {
		return fmt.Errorf("testMapWalker: %w", err)
	}
	if err := testPointerWalker(); err != nil {
		return fmt.Errorf("testPointerWalker: %w", err)
	}
	if err := testSkipEntry(); err != nil {
		return fmt.Errorf("testSkipEntry: %w", err)
	}
	if err := testEnterExitWalker(); err != nil {
		return fmt.Errorf("testEnterExitWalker: %w", err)
	}
	return nil
}

// 1. PrimitiveWalker test
type primitiveRecorder struct {
	primitives []interface{}
}

func (r *primitiveRecorder) Primitive(v reflect.Value) error {
	r.primitives = append(r.primitives, v.Interface())
	return nil
}

func testPrimitiveWalker() error {
	type Sample struct {
		Name  string
		Age   int
		Valid bool
	}
	data := Sample{Name: "item1", Age: 25, Valid: true}
	rec := &primitiveRecorder{}
	if err := reflectwalk.Walk(data, rec); err != nil {
		return err
	}
	if len(rec.primitives) != 3 {
		return fmt.Errorf("expected 3 primitives, got %d", len(rec.primitives))
	}
	if rec.primitives[0] != "item1" || rec.primitives[1] != 25 || rec.primitives[2] != true {
		return fmt.Errorf("unexpected primitives: %v", rec.primitives)
	}
	return nil
}

// 2. StructWalker test
type structRecorder struct {
	structCount int
	fieldNames  []string
}

func (r *structRecorder) Struct(v reflect.Value) error {
	r.structCount++
	return nil
}

func (r *structRecorder) StructField(sf reflect.StructField, v reflect.Value) error {
	r.fieldNames = append(r.fieldNames, sf.Name)
	return nil
}

func testStructWalker() error {
	type Nested struct {
		FieldA string
		FieldB int
	}
	type Parent struct {
		Child Nested
		Extra string
	}
	data := Parent{
		Child: Nested{FieldA: "valA", FieldB: 100},
		Extra: "extraVal",
	}
	rec := &structRecorder{}
	if err := reflectwalk.Walk(data, rec); err != nil {
		return err
	}
	if rec.structCount != 2 {
		return fmt.Errorf("expected 2 structs visited, got %d", rec.structCount)
	}
	expectedFields := []string{"Child", "FieldA", "FieldB", "Extra"}
	if !reflect.DeepEqual(rec.fieldNames, expectedFields) {
		return fmt.Errorf("expected fields %v, got %v", expectedFields, rec.fieldNames)
	}
	return nil
}

// 3. SliceWalker and ArrayWalker test
type collectionRecorder struct {
	sliceCounts []int
	sliceElems  []interface{}
	arrayCounts []int
	arrayElems  []interface{}
}

func (r *collectionRecorder) Slice(v reflect.Value) error {
	r.sliceCounts = append(r.sliceCounts, v.Len())
	return nil
}

func (r *collectionRecorder) SliceElem(i int, v reflect.Value) error {
	r.sliceElems = append(r.sliceElems, v.Interface())
	return nil
}

func (r *collectionRecorder) Array(v reflect.Value) error {
	r.arrayCounts = append(r.arrayCounts, v.Len())
	return nil
}

func (r *collectionRecorder) ArrayElem(i int, v reflect.Value) error {
	r.arrayElems = append(r.arrayElems, v.Interface())
	return nil
}

func testSliceAndArrayWalker() error {
	type Container struct {
		Items [2]string
		List  []int
	}
	data := Container{
		Items: [2]string{"first", "second"},
		List:  []int{10, 20, 30},
	}
	rec := &collectionRecorder{}
	if err := reflectwalk.Walk(data, rec); err != nil {
		return err
	}
	if len(rec.sliceCounts) != 1 || rec.sliceCounts[0] != 3 {
		return fmt.Errorf("unexpected sliceCounts: %v", rec.sliceCounts)
	}
	if len(rec.arrayCounts) != 1 || rec.arrayCounts[0] != 2 {
		return fmt.Errorf("unexpected arrayCounts: %v", rec.arrayCounts)
	}
	if len(rec.sliceElems) != 3 || rec.sliceElems[0] != 10 || rec.sliceElems[2] != 30 {
		return fmt.Errorf("unexpected sliceElems: %v", rec.sliceElems)
	}
	if len(rec.arrayElems) != 2 || rec.arrayElems[0] != "first" || rec.arrayElems[1] != "second" {
		return fmt.Errorf("unexpected arrayElems: %v", rec.arrayElems)
	}
	return nil
}

// 4. MapWalker test
type mapRecorder struct {
	mapsVisited int
	entries     map[string]int
}

func (r *mapRecorder) Map(m reflect.Value) error {
	r.mapsVisited++
	return nil
}

func (r *mapRecorder) MapElem(m, k, v reflect.Value) error {
	r.entries[k.String()] = int(v.Int())
	return nil
}

func testMapWalker() error {
	data := map[string]int{"alpha": 1, "beta": 2}
	rec := &mapRecorder{entries: make(map[string]int)}
	if err := reflectwalk.Walk(data, rec); err != nil {
		return err
	}
	if rec.mapsVisited != 1 {
		return fmt.Errorf("expected 1 map visited, got %d", rec.mapsVisited)
	}
	if len(rec.entries) != 2 || rec.entries["alpha"] != 1 || rec.entries["beta"] != 2 {
		return fmt.Errorf("unexpected map entries: %v", rec.entries)
	}
	return nil
}

// 5. PointerWalker test
type pointerRecorder struct {
	enterCount int
	exitCount  int
	isPointer  []bool
}

func (r *pointerRecorder) PointerEnter(isPtr bool) error {
	r.enterCount++
	r.isPointer = append(r.isPointer, isPtr)
	return nil
}

func (r *pointerRecorder) PointerExit(isPtr bool) error {
	r.exitCount++
	return nil
}

func testPointerWalker() error {
	val := 42
	ptr := &val
	rec := &pointerRecorder{}
	if err := reflectwalk.Walk(ptr, rec); err != nil {
		return err
	}
	if rec.enterCount != rec.exitCount {
		return fmt.Errorf("enterCount %d != exitCount %d", rec.enterCount, rec.exitCount)
	}
	hasPtr := false
	for _, p := range rec.isPointer {
		if p {
			hasPtr = true
		}
	}
	if !hasPtr {
		return errors.New("expected at least one pointer enter event with isPtr=true")
	}
	return nil
}

// 6. SkipEntry test
type skippingWalker struct {
	visitedFields []string
}

func (w *skippingWalker) Struct(v reflect.Value) error {
	return nil
}

func (w *skippingWalker) StructField(sf reflect.StructField, v reflect.Value) error {
	if sf.Name == "Secret" {
		return reflectwalk.SkipEntry
	}
	w.visitedFields = append(w.visitedFields, sf.Name)
	return nil
}

func (w *skippingWalker) Primitive(v reflect.Value) error {
	return nil
}

func testSkipEntry() error {
	type SecretData struct {
		Public string
		Secret string
		Other  int
	}
	data := SecretData{
		Public: "open",
		Secret: "hidden",
		Other:  99,
	}
	walker := &skippingWalker{}
	if err := reflectwalk.Walk(data, walker); err != nil {
		return err
	}
	for _, f := range walker.visitedFields {
		if f == "Secret" {
			return errors.New("Secret field should have been skipped")
		}
	}
	if len(walker.visitedFields) != 2 {
		return fmt.Errorf("expected 2 visited fields, got %v", walker.visitedFields)
	}
	return nil
}

// 7. EnterExitWalker test
type enterExitRecorder struct {
	enters []reflectwalk.Location
	exits  []reflectwalk.Location
}

func (r *enterExitRecorder) Enter(loc reflectwalk.Location) error {
	r.enters = append(r.enters, loc)
	return nil
}

func (r *enterExitRecorder) Exit(loc reflectwalk.Location) error {
	r.exits = append(r.exits, loc)
	return nil
}

func testEnterExitWalker() error {
	type Inner struct {
		Val string
	}
	data := Inner{Val: "test"}
	rec := &enterExitRecorder{}
	if err := reflectwalk.Walk(data, rec); err != nil {
		return err
	}
	if len(rec.enters) == 0 || len(rec.enters) != len(rec.exits) {
		return fmt.Errorf("mismatched enters (%d) and exits (%d)", len(rec.enters), len(rec.exits))
	}
	return nil
}