golang.org/x/tools v0.44.0: astutil.Apply

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 golang.org/x/tools/go/ast/astutil.Apply in pkg:golang/golang.org/x/tools@v0.44.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/tools@v0.44.0
Demonstrate these symbols/APIs:
  - golang.org/x/tools/go/ast/astutil.Apply
Required runtime conditions:
  - ecosystem: golang
  - language: go
  - packageManager: go@1.26.6
  - runtime: go@1.26.6

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.

package sample

import (
	"go/ast"
	"go/parser"
	"go/token"

	"golang.org/x/tools/go/ast/astutil"
)

// RenameIdent uses astutil.Apply to rename identifier oldName to newName throughout the AST.
func RenameIdent(root ast.Node, oldName, newName string) ast.Node {
	return astutil.Apply(root, func(c *astutil.Cursor) bool {
		if id, ok := c.Node().(*ast.Ident); ok && id.Name == oldName {
			c.Replace(ast.NewIdent(newName))
		}
		return true
	}, nil)
}

// RemoveStatements uses astutil.Apply to delete statements matching shouldRemove.
func RemoveStatements(root ast.Node, shouldRemove func(ast.Stmt) bool) ast.Node {
	return astutil.Apply(root, func(c *astutil.Cursor) bool {
		if stmt, ok := c.Node().(ast.Stmt); ok && shouldRemove(stmt) {
			c.Delete()
			return false
		}
		return true
	}, nil)
}

// ParseSource parses Go source code into an AST.
func ParseSource(src string) (*token.FileSet, *ast.File, error) {
	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, "src.go", src, 0)
	if err != nil {
		return nil, nil, err
	}
	return fset, file, nil
}

{"case":{"caseId":"case:sha256:1f6dc1a65bfe6215a30e586de7a58779819fa68a3b8920cae6ec42d3251faef2","contract":["astutil.Apply traverses AST nodes with preorder and postorder callbacks","astutil.Apply replaces AST nodes using Cursor.Replace","astutil.Apply deletes AST nodes using Cursor.Delete","astutil.Apply skips subtrees when preorder callback returns false","astutil.Apply returns transformed root node"],"goal":"verify golang.org/x/tools/go/ast/astutil.Apply in pkg:golang/golang.org/x/tools@v0.44.0","kind":"HOW","packages":["pkg:golang/golang.org/x/tools@v0.44.0"],"schemaVersion":1,"symbols":["golang.org/x/tools/go/ast/astutil.Apply"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/golang.org/x/tools@v0.44.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/tools@v0.44.0","symbols":["golang.org/x/tools/go/ast/astutil.Apply"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require golang.org/x/tools v0.44.0

golang.org/x/tools v0.44.0 h1:UP4ajHPIcuMjT1GqzDWRlalUEoY+uzoZKnhOjbIPD2c=
golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI=

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/tools/go/ast/astutil.Apply in pkg:golang/golang.org/x/tools@v0.44.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/tools@v0.44.0"
  ],
  "symbols": [
    "golang.org/x/tools/go/ast/astutil.Apply"
  ],
  "runtimeConditions": {
    "ecosystem": "golang",
    "language": "go",
    "packageManager": "go@1.26.6",
    "runtime": "go@1.26.6"
  }
}

package main

import (
	"bytes"
	"fmt"
	"go/ast"
	"go/format"
	"go/parser"
	"go/token"
	"os"
	"strings"

	"golang.org/x/tools/go/ast/astutil"
)

func assert(cond bool, msg string) {
	if !cond {
		fmt.Fprintf(os.Stderr, "CONTRACT FAILURE: %s\n", msg)
		os.Exit(1)
	}
}

func main() {
	src := `package main

func main() {
	x := 10
	y := 20
	z := x + y
	println(z)
}
`

	// 1. Prove astutil.Apply traverses AST nodes with preorder and postorder callbacks
	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, "example.go", src, 0)
	assert(err == nil, "ParseFile must succeed")

	var preOrder []string
	var postOrder []string

	astutil.Apply(file, func(c *astutil.Cursor) bool {
		if id, ok := c.Node().(*ast.Ident); ok {
			preOrder = append(preOrder, id.Name)
		}
		return true
	}, func(c *astutil.Cursor) bool {
		if id, ok := c.Node().(*ast.Ident); ok {
			postOrder = append(postOrder, id.Name)
		}
		return true
	})

	assert(len(preOrder) > 0, "preorder callback should visit identifiers")
	assert(len(postOrder) == len(preOrder), "postorder callback should visit same count of identifiers")
	assert(preOrder[0] == "main", "first visited identifier should be package name 'main'")

	// 2. Prove astutil.Apply replaces AST nodes using Cursor.Replace
	astutil.Apply(file, func(c *astutil.Cursor) bool {
		if id, ok := c.Node().(*ast.Ident); ok && id.Name == "x" {
			c.Replace(ast.NewIdent("alpha"))
		}
		return true
	}, nil)

	var buf bytes.Buffer
	err = format.Node(&buf, fset, file)
	assert(err == nil, "format.Node must succeed")
	formatted := buf.String()
	assert(strings.Contains(formatted, "alpha := 10"), "Cursor.Replace should rename x to alpha in declaration")
	assert(strings.Contains(formatted, "z := alpha + y"), "Cursor.Replace should rename x to alpha in usage")
	assert(!strings.Contains(formatted, "x :="), "original identifier x should no longer exist")

	// 3. Prove astutil.Apply deletes AST nodes using Cursor.Delete
	astutil.Apply(file, func(c *astutil.Cursor) bool {
		if assign, ok := c.Node().(*ast.AssignStmt); ok {
			for _, lhs := range assign.Lhs {
				if id, ok := lhs.(*ast.Ident); ok && id.Name == "y" {
					c.Delete()
					return false
				}
			}
		}
		return true
	}, nil)

	buf.Reset()
	err = format.Node(&buf, fset, file)
	assert(err == nil, "format.Node must succeed after delete")
	formatted = buf.String()
	assert(!strings.Contains(formatted, "y := 20"), "Cursor.Delete should remove y := 20 statement")

	// 4. Prove astutil.Apply stops traversing subtree when pre returns false
	visitedSubtree := false
	astutil.Apply(file, func(c *astutil.Cursor) bool {
		if _, ok := c.Node().(*ast.FuncDecl); ok {
			return false // skip body of function
		}
		if _, ok := c.Node().(*ast.BlockStmt); ok {
			visitedSubtree = true
		}
		return true
	}, nil)
	assert(!visitedSubtree, "pre returning false must skip child nodes")

	// 5. Prove astutil.Apply returns modified root node
	newFile := astutil.Apply(file, func(c *astutil.Cursor) bool {
		if id, ok := c.Node().(*ast.Ident); ok && id.Name == "main" && c.Parent() == file {
			c.Replace(ast.NewIdent("custompkg"))
		}
		return true
	}, nil)
	assert(newFile != nil, "Apply must return root node")
	if f, ok := newFile.(*ast.File); ok {
		assert(f.Name.Name == "custompkg", "Package name should be updated to custompkg")
	} else {
		assert(false, "Result must be *ast.File")
	}

	fmt.Println("PASS: golang.org/x/tools/go/ast/astutil.Apply contract verified")
}