Formatting, vet, fix and Static Analysis

$ go fmt -n ./...
/Users/albertoirurueta/sdk/go1.27.2/bin/gofmt -l -w fmtdemo/messy.go
$ go fmt ./...
fmtdemo/messy.go

$ gofmt -r 'a[b:len(a)] -> a[b:]' -d fmtdemo/messy.go
diff fmtdemo/messy.go.orig fmtdemo/messy.go
--- fmtdemo/messy.go.orig
+++ fmtdemo/messy.go
@@ -23,7 +23,7 @@
 }

 func Tail(s []int) []int {
-	return s[1:len(s)]
+	return s[1:]
 }

 func Pairs() []Book {

$ printf 'package p\nfunc  F( ) {  }\n' | gofmt
package p

func F() {}

package brace

func F(n int) int
{
	return n
}

$ gofmt -l brace
brace/brace.go:4:1: unexpected semicolon or newline before {
$ go build ./brace
# example.com/shelf/brace
brace/brace.go:4:1: syntax error: unexpected semicolon or newline before {

test -z "$(gofmt -s -l .)" || { echo "unformatted files:"; gofmt -s -l .; exit 1; }

$ go tool vet help
...
Registered analyzers:

    appends      check for missing values after append
    asmdecl      report mismatches between assembly files and Go declarations
    assign       check for useless assignments
    atomic       check for common mistakes using the sync/atomic package
    bools        check for common mistakes involving boolean operators
    buildtag     check //go:build and // +build directives
    cgocall      detect some violations of the cgo pointer passing rules
    composites   check for unkeyed composite literals
    copylocks    check for locks erroneously passed by value
    defers       report common mistakes in defer statements
    directive    check Go toolchain directives such as //go:debug
    errorsas     report passing non-pointer or non-error values to errors.As
    framepointer report assembly that clobbers the frame pointer before saving it
    hostport     check format of addresses passed to net.Dial
    httpresponse check for mistakes using HTTP responses
    ifaceassert  detect impossible interface-to-interface type assertions
    loopclosure  check references to loop variables from within nested functions
    lostcancel   check cancel func returned by context.WithCancel is called
    nilfunc      check for useless comparisons between functions and nil
    printf       check consistency of Printf format strings and arguments
    shift        check for shifts that equal or exceed the width of the integer
    sigchanyzer  check for unbuffered channel of os.Signal
    slog         check for invalid structured logging calls
    stdmethods   check signature of methods of well-known interfaces
    stdversion   report uses of too-new standard library symbols
    stringintconv check for string(int) conversions
    structtag    check that struct field tags conform to reflect.StructTag.Get
    testinggoroutine report calls to (*testing.T).Fatal from goroutines started by a test
    tests        check for common mistaken usages of tests and examples
    timeformat   check for calls of (time.Time).Format or time.Parse with 2006-02-01
    unmarshal    report passing non-pointer or non-interface values to unmarshal
    unreachable  check for unreachable code
    unsafeptr    check for invalid conversions of uintptr to unsafe.Pointer
    unusedresult check for unused results of calls to some functions
    waitgroup    check for misuses of sync.WaitGroup
...

$ go vet -printf=false ./vet/printf ./vet/stringint
vet/stringint/stringint.go:4:9: conversion from int to string yields a string of one rune, not a string of digits
$ go vet -stringintconv ./vet/printf ./vet/stringint
vet/stringint/stringint.go:4:9: conversion from int to string yields a string of one rune, not a string of digits

package printf

import (
	"fmt"
	"log"
)

type ISBN string

func Report(title string, copies int, isbn ISBN) {
	fmt.Printf("%s has %d copies\n", title)
	fmt.Printf("%d copies of %s\n", title, copies)
	log.Printf("lending %q", isbn, copies)
	fmt.Println("done: %s", title)
	fmt.Printf(title)
}

$ go vet ./vet/printf
vet/printf/printf.go:11:21: fmt.Printf format %d reads arg #2, but call has 1 arg
vet/printf/printf.go:12:14: fmt.Printf format %d has arg title of wrong type string
vet/printf/printf.go:13:2: log.Printf call needs 1 arg but has 2 args
vet/printf/printf.go:14:2: fmt.Println call has possible Printf formatting directive %s
vet/printf/printf.go:15:13: non-constant format string in call to fmt.Printf

package wrapptr

import (
	"errors"
	"fmt"
)

type NotFound struct{ ISBN string }

func (NotFound) Error() string { return "not found" }

func Find() error {
	p := &NotFound{ISBN: "x"}
	return fmt.Errorf("lookup: %w", p)
}

func Is(err error) bool {
	var nf NotFound
	return errors.As(err, &nf)
}

$ go vet ./vet/wrapptr
vet/wrapptr/wrapptr.go:14:29: %w wants operand of error type NotFound, not pointer type *NotFound (defeats errors.Is)

package copylocks

import "sync"

type Store struct {
	mu    sync.Mutex
	books map[string]int
}

func (s Store) Count() int {
	s.mu.Lock()
	defer s.mu.Unlock()
	return len(s.books)
}

func Clone(s *Store) Store {
	c := *s
	return c
}

func Each(stores []Store) {
	for _, s := range stores {
		_ = s.books
	}
}

$ go vet ./vet/copylocks
vet/copylocks/copylocks.go:10:9: Count passes lock by value: example.com/shelf/vet/copylocks.Store contains sync.Mutex
vet/copylocks/copylocks.go:17:7: assignment copies lock value to c: example.com/shelf/vet/copylocks.Store contains sync.Mutex
vet/copylocks/copylocks.go:18:9: return copies lock value: example.com/shelf/vet/copylocks.Store contains sync.Mutex
vet/copylocks/copylocks.go:22:9: range var s copies lock: example.com/shelf/vet/copylocks.Store contains sync.Mutex

module example.com/oldmod

go 1.21

package oldmod

import (
	"fmt"
	"slices"
	"sync"
)

func Sorted(ids []string) []string {
	return slices.Sorted(slices.Values(ids))
}

func Show(items []string) {
	var wg sync.WaitGroup
	for _, it := range items {
		wg.Add(1)
		go func() {
			defer wg.Done()
			fmt.Println(it)
		}()
	}
	wg.Wait()
}

func Min3(a, b, c int) int {
	return min(a, b, c)
}

$ go vet ./...
old.go:10:16: slices.Sorted requires go1.23 or later (module is go1.21)
old.go:10:30: slices.Values requires go1.23 or later (module is go1.21)
old.go:19:16: loop variable it captured by func literal
$ go build ./...
$

$ go test ./...
# example.com/oldmod
# [example.com/oldmod]
./old.go:10:16: slices.Sorted requires go1.23 or later (module is go1.21)
./old.go:10:30: slices.Values requires go1.23 or later (module is go1.21)
FAIL	example.com/oldmod [build failed]
FAIL
$ go test -vet=off ./...
ok  	example.com/oldmod	0.187s

package lostcancel

import (
	"context"
	"time"
)

func Fetch(parent context.Context, dry bool) context.Context {
	ctx, cancel := context.WithTimeout(parent, time.Second)
	if dry {
		return ctx
	}
	defer cancel()
	return ctx
}

$ go vet ./vet/lostcancel
vet/lostcancel/lostcancel.go:9:2: the cancel function is not used on all paths (possible context leak)
vet/lostcancel/lostcancel.go:11:3: this return statement may be reached without using the cancel var defined on line 9

package tests

import "testing"

type Store struct{}

func (Store) Get() {}

func ExampleStore_Put() {}

func ExampleMissing() {}

func Example_lower() {}

func Testlending(t *testing.T) { t.Log("never runs") }

$ go vet ./vet/tests_a
vet/tests_a/a_test.go:9:1: ExampleStore_Put refers to unknown field or method: Store.Put
vet/tests_a/a_test.go:11:1: ExampleMissing refers to unknown identifier: Missing
vet/tests_a/a_test.go:15:6: Testlending has malformed name: first letter after 'Test' must not be lowercase

$ go vet ./vet/testgo
vet/testgo/testgo_test.go:9:3: call to (*testing.T).Fatal from a non-test goroutine

package waitgroup

import "sync"

func Run(n int) {
	var wg sync.WaitGroup
	for range n {
		go func() {
			wg.Add(1)
			defer wg.Done()
		}()
	}
	wg.Wait()
}

$ go vet ./vet/waitgroup
vet/waitgroup/waitgroup.go:9:10: WaitGroup.Add called from inside new goroutine

package hostport

import (
	"fmt"
	"net"
)

func Dial(host string, port int) (net.Conn, error) {
	addr := fmt.Sprintf("%s:%d", host, port)
	return net.Dial("tcp", addr)
}

$ go vet ./vet/hostport
vet/hostport/hostport.go:9:22: address format "%s:%d" does not work with IPv6 (passed to net.Dial at L10)

package main

import (
	"errors"
	"fmt"
	"log/slog"
	"net"
	"os"
	"strings"
	"sync"
	"time"
)

type ISBN string

type NotFound struct{ ISBN ISBN }

func (e *NotFound) Error() string { return "not found: " + string(e.ISBN) }

func find(isbn ISBN) error {
	return fmt.Errorf("lookup: %w", &NotFound{ISBN: isbn})
}

func main() {
	// printf: verbs and arguments agree; a variable format string uses Print.
	title, copies := "Dune", 2
	fmt.Printf("%s has %d copies\n", title, copies)
	fmt.Print(title, "\n")

	// hostport: JoinHostPort handles IPv6 literals.
	fmt.Println(net.JoinHostPort("::1", "8080"))

	// timeformat: the reference time is 2006-01-02.
	due := time.Date(2026, time.October, 18, 0, 0, 0, 0, time.UTC)
	fmt.Println(due.Format("2006-01-02"))

	// errorsas: AsType (Go 1.26) takes the target type as a type argument.
	if nf, ok := errors.AsType[*NotFound](find("978-0-441-17271-9")); ok {
		fmt.Println("missing:", nf.ISBN)
	}

	// waitgroup: WaitGroup.Go (Go 1.25) pairs Add and Done for you.
	var (
		wg   sync.WaitGroup
		mu   sync.Mutex
		seen []string
	)
	for _, id := range []string{"a", "b", "c"} {
		wg.Go(func() {
			mu.Lock()
			defer mu.Unlock()
			seen = append(seen, strings.ToUpper(id))
		})
	}
	wg.Wait()
	fmt.Println(len(seen), "goroutines finished")

	// slog: key/value pairs come in pairs.
	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
			if a.Key == slog.TimeKey && len(groups) == 0 {
				return slog.Attr{}
			}
			return a
		},
	}))
	logger.Info("loan created", "isbn", "978-0-441-17271-9", "days", 14)
}

$ go vet ./clean && go run ./clean
Dune has 2 copies
Dune
[::1]:8080
2026-10-18
missing: 978-0-441-17271-9
3 goroutines finished
level=INFO msg="loan created" isbn=978-0-441-17271-9 days=14

$ go test ./vet/printf
# example.com/shelf/vet/printf
# [example.com/shelf/vet/printf]
vet/printf/printf.go:11:21: fmt.Printf format %d reads arg #2, but call has 1 arg
vet/printf/printf.go:12:14: fmt.Printf format %d has arg title of wrong type string
vet/printf/printf.go:13:2: log.Printf call needs 1 arg but has 2 args
vet/printf/printf.go:14:2: fmt.Println call has possible Printf formatting directive %s
vet/printf/printf.go:15:13: non-constant format string in call to fmt.Printf
vet/printf/printf_test.go:7:18: (*testing.common).Logf format %d has arg "two" of wrong type string
FAIL	example.com/shelf/vet/printf [build failed]
FAIL
$ go test -vet=off ./vet/printf
ok  	example.com/shelf/vet/printf	0.195s

$ go vet -fix -diff ./vet/hostport
--- vet/hostport/hostport.go (old)
+++ vet/hostport/hostport.go (new)
@@ -6,6 +6,6 @@
 )

 func Dial(host string, port int) (net.Conn, error) {
-	addr := fmt.Sprintf("%s:%d", host, port)
+	addr := net.JoinHostPort(host, fmt.Sprintf("%d", port))
 	return net.Dial("tcp", addr)
 }
$ go vet -fix -diff ./vet/timefmt
--- vet/timefmt/timefmt.go (old)
+++ vet/timefmt/timefmt.go (new)
@@ -3,5 +3,5 @@
 import "time"

 func Stamp(t time.Time) string {
-	return t.Format("2006-02-01")
+	return t.Format("2006-01-02")
 }
$ go vet -fix -diff ./vet/printf
--- vet/printf/printf.go (old)
+++ vet/printf/printf.go (new)
@@ -12,5 +12,5 @@
 	fmt.Printf("%d copies of %s\n", title, copies)
 	log.Printf("lending %q", isbn, copies)
 	fmt.Println("done: %s", title)
-	fmt.Printf(title)
+	fmt.Printf("%s", title)
 }

$ go tool -n vet
/Users/albertoirurueta/sdk/go1.27.2/pkg/tool/darwin_arm64/vet
$ go vet -vettool=$(go tool -n vet) ./vet/timefmt
vet/timefmt/timefmt.go:6:19: 2006-02-01 should be 2006-01-02

go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow@v0.52.0
go vet -vettool=$(which shadow) ./...

$ go tool fix help
...
Registered analyzers:

    any          replace interface{} with any
    atomictypes  replace basic types in sync/atomic calls with atomic types
    buildtag     check //go:build and // +build directives
    embedlit     simplify references to embedded fields in composite literals
    errorsastype replace errors.As with errors.AsType[T]
    forvar       remove redundant re-declaration of loop variables
    hostport     check format of addresses passed to net.Dial
    inline       apply fixes based on 'go:fix inline' comment directives
    mapsloop     replace explicit loops over maps with calls to maps package
    minmax       replace if/else statements with calls to min or max
    newexpr      simplify code by using go1.26's new(expr)
    omitzero     suggest replacing omitempty with omitzero for struct fields
    plusbuild    remove obsolete //+build comments
    rangeint     replace 3-clause for loops with for-range over integers
    reflecttypefor replace reflect.TypeOf(x) with TypeFor[T]()
    slicesbackward replace backward loops over slices with slices.Backward
    slicescontains replace loops with slices.Contains or slices.ContainsFunc
    slicessort   replace sort.Slice with slices.Sort for basic types
    stditerators use iterators instead of Len/At-style APIs
    stringsbuilder replace += with strings.Builder
    stringscut   replace strings.Index etc. with strings.Cut
    stringscutprefix replace HasPrefix/TrimPrefix with CutPrefix
    stringsseq   replace ranging over Split/Fields with SplitSeq/FieldsSeq
    testingcontext replace context.WithCancel with t.Context in tests
    unsafefuncs  replace unsafe pointer arithmetic with function calls
    waitgroupgo  replace wg.Add(1)/go/wg.Done() with wg.Go
...

package legacy

import (
	"errors"
	"fmt"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
)

type Book struct {
	Title string
	Pages int
}

type NotFound struct{ ISBN string }

func (e *NotFound) Error() string { return "not found: " + e.ISBN }

// Describe accepts anything.
func Describe(v interface{}) string {
	return fmt.Sprint(v)
}

// ByTitle sorts books by title.
func ByTitle(books []Book) {
	sort.Slice(books, func(i, j int) bool { return books[i].Title < books[j].Title })
}

// Pages clamps a page count to at least one page.
func Pages(n int) int {
	p := n
	if p < 1 {
		p = 1
	}
	return p
}

// Total sums every page count.
func Total(books []Book) int {
	total := 0
	for i := 0; i < len(books); i++ {
		total += books[i].Pages
	}
	return total
}

// Split splits "key=value".
func Split(pair string) (string, string) {
	eq := strings.Index(pair, "=")
	if eq < 0 {
		return pair, ""
	}
	return pair[:eq], pair[eq+1:]
}

// Strip removes a prefix.
func Strip(isbn string) string {
	if strings.HasPrefix(isbn, "ISBN ") {
		return strings.TrimPrefix(isbn, "ISBN ")
	}
	return isbn
}

// Clone copies a map.
func Clone(src map[string]int) map[string]int {
	dst := make(map[string]int)
	for k, v := range src {
		dst[k] = v
	}
	return dst
}

// Has reports whether want is present.
func Has(ids []string, want string) bool {
	for _, id := range ids {
		if id == want {
			return true
		}
	}
	return false
}

// Last prints from the end.
func Last(ids []string) {
	for i := len(ids) - 1; i >= 0; i-- {
		fmt.Println(ids[i])
	}
}

// Fan starts one goroutine per id.
func Fan(ids []string) {
	var wg sync.WaitGroup
	for _, id := range ids {
		id := id
		wg.Add(1)
		go func() {
			defer wg.Done()
			fmt.Println(id)
		}()
	}
	wg.Wait()
}

// Count increments a counter.
func Count(n *int64) {
	atomic.AddInt64(n, 1)
}

// Fields splits a line.
func Fields(line string) {
	for _, f := range strings.Fields(line) {
		fmt.Println(f)
	}
}

// Join concatenates in a loop.
func Join(ids []string) string {
	s := ""
	for _, id := range ids {
		s += id + ","
	}
	return s
}

// Missing unwraps.
func Missing(err error) bool {
	var nf *NotFound
	return errors.As(err, &nf)
}

// Days returns a pointer to a copy of 14.
func Days() *int {
	d := 14
	return &d
}

$ go fix -diff ./legacy
--- legacy/legacy.go (old)
+++ legacy/legacy.go (new)
@@ -3,6 +3,8 @@
 import (
 	"errors"
 	"fmt"
+	"maps"
+	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -19,7 +21,7 @@
 func (e *NotFound) Error() string { return "not found: " + e.ISBN }

 // Describe accepts anything.
-func Describe(v interface{}) string {
+func Describe(v any) string {
 	return fmt.Sprint(v)
 }

@@ -30,17 +32,14 @@

 // Pages clamps a page count to at least one page.
 func Pages(n int) int {
-	p := n
-	if p < 1 {
-		p = 1
-	}
+	p := max(n, 1)
 	return p
 }

 // Total sums every page count.
 func Total(books []Book) int {
 	total := 0
-	for i := 0; i < len(books); i++ {
+	for i := range books {
 		total += books[i].Pages
 	}
 	return total
@@ -48,17 +41,17 @@

 // Split splits "key=value".
 func Split(pair string) (string, string) {
-	eq := strings.Index(pair, "=")
-	if eq < 0 {
+	before, after, ok := strings.Cut(pair, "=")
+	if !ok {
 		return pair, ""
 	}
-	return pair[:eq], pair[eq+1:]
+	return before, after
 }

 // Strip removes a prefix.
 func Strip(isbn string) string {
-	if strings.HasPrefix(isbn, "ISBN ") {
-		return strings.TrimPrefix(isbn, "ISBN ")
+	if after, ok := strings.CutPrefix(isbn, "ISBN "); ok {
+		return after
 	}
 	return isbn
 }
@@ -66,26 +53,19 @@
 // Clone copies a map.
 func Clone(src map[string]int) map[string]int {
 	dst := make(map[string]int)
-	for k, v := range src {
-		dst[k] = v
-	}
+	maps.Copy(dst, src)
 	return dst
 }

 // Has reports whether want is present.
 func Has(ids []string, want string) bool {
-	for _, id := range ids {
-		if id == want {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(ids, want)
 }

 // Last prints from the end.
 func Last(ids []string) {
-	for i := len(ids) - 1; i >= 0; i-- {
-		fmt.Println(ids[i])
+	for _, id := range slices.Backward(ids) {
+		fmt.Println(id)
 	}
 }

@@ -93,12 +64,9 @@
 func Fan(ids []string) {
 	var wg sync.WaitGroup
 	for _, id := range ids {
-		id := id
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
+		wg.Go(func() {
 			fmt.Println(id)
-		}()
+		})
 	}
 	wg.Wait()
 }
@@ -110,18 +77,18 @@

 // Fields splits a line.
 func Fields(line string) {
-	for _, f := range strings.Fields(line) {
+	for f := range strings.FieldsSeq(line) {
 		fmt.Println(f)
 	}
 }

 // Join concatenates in a loop.
 func Join(ids []string) string {
-	s := ""
+	var s strings.Builder
 	for _, id := range ids {
-		s += id + ","
+		s.WriteString(id + ",")
 	}
-	return s
+	return s.String()
 }

 // Missing unwraps.
--- legacy/legacy_test.go (old)
+++ legacy/legacy_test.go (new)
@@ -1,13 +1,11 @@
 package legacy

 import (
-	"context"
 	"testing"
 )

 func TestDescribe(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 	if ctx.Err() != nil {
 		t.Fatal("unexpected")
 	}

package legacy2

import (
	"errors"
	"fmt"
	"reflect"
	"sort"
	"sync/atomic"
	"time"
	"unsafe"
)

type NotFound struct{ ISBN string }

func (e *NotFound) Error() string { return "not found: " + e.ISBN }

// Report prints the ISBN of a missing book.
func Report(err error) {
	var nf *NotFound
	if errors.As(err, &nf) {
		fmt.Println(nf.ISBN)
	}
}

// Counter counts loans.
type Counter struct {
	loans int64
}

// Inc adds one loan.
func (c *Counter) Inc() {
	atomic.AddInt64(&c.loans, 1)
}

// Load reads the counter.
func (c *Counter) Load() int64 {
	return atomic.LoadInt64(&c.loans)
}

func newInt(v int) *int {
	return &v
}

// Default returns the standard loan period.
func Default() *int {
	return newInt(14)
}

// Sorted sorts ISBNs in place.
func Sorted(ids []string) {
	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
}

// Kind returns the reflect type of a string.
func Kind() reflect.Type {
	return reflect.TypeOf("")
}

// Loan is serialised to JSON.
type Loan struct {
	ISBN string    `json:"isbn"`
	Due  time.Time `json:"due,omitempty"`
}

// Second returns a pointer to the second element.
func Second(p *[4]int32) *int32 {
	return (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + unsafe.Sizeof(p[0])))
}

type Base struct{ ID int }

type Item struct {
	Base
	Name string
}

// NewItem builds an item.
func NewItem() Item {
	return Item{Base: Base{ID: 1}, Name: "x"}
}

$ go fix -diff ./legacy2
# example.com/shelf/legacy2
fix: omitzero: ignoring alternative fix "Replace omitempty with omitzero (behavior change)"
--- legacy2/legacy2.go (old)
+++ legacy2/legacy2.go (new)
@@ -4,7 +4,7 @@
 	"errors"
 	"fmt"
 	"reflect"
-	"sort"
+	"slices"
 	"sync/atomic"
 	"time"
 	"unsafe"
@@ -16,55 +16,55 @@

 // Report prints the ISBN of a missing book.
 func Report(err error) {
-	var nf *NotFound
-	if errors.As(err, &nf) {
+	if nf, ok := errors.AsType[*NotFound](err); ok {
 		fmt.Println(nf.ISBN)
 	}
 }

 // Counter counts loans.
 type Counter struct {
-	loans int64
+	loans atomic.Int64
 }

 // Inc adds one loan.
 func (c *Counter) Inc() {
-	atomic.AddInt64(&c.loans, 1)
+	c.loans.Add(1)
 }

 // Load reads the counter.
 func (c *Counter) Load() int64 {
-	return atomic.LoadInt64(&c.loans)
+	return c.loans.Load()
 }

+//go:fix inline
 func newInt(v int) *int {
-	return &v
+	return new(v)
 }

 // Default returns the standard loan period.
 func Default() *int {
-	return newInt(14)
+	return new(14)
 }

 // Sorted sorts ISBNs in place.
 func Sorted(ids []string) {
-	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
+	slices.Sort(ids)
 }

 // Kind returns the reflect type of a string.
 func Kind() reflect.Type {
-	return reflect.TypeOf("")
+	return reflect.TypeFor[string]()
 }

 // Loan is serialised to JSON.
 type Loan struct {
 	ISBN string    `json:"isbn"`
-	Due  time.Time `json:"due,omitempty"`
+	Due  time.Time `json:"due"`
 }

 // Second returns a pointer to the second element.
 func Second(p *[4]int32) *int32 {
-	return (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + unsafe.Sizeof(p[0])))
+	return (*int32)(unsafe.Add(unsafe.Pointer(p), unsafe.Sizeof(p[0])))
 }

 type Base struct{ ID int }
@@ -76,5 +38,5 @@

 // NewItem builds an item.
 func NewItem() Item {
-	return Item{Base: Base{ID: 1}, Name: "x"}
+	return Item{ID: 1, Name: "x"}
 }

$ go fix -any -diff ./legacy
--- legacy/legacy.go (old)
+++ legacy/legacy.go (new)
@@ -19,7 +19,7 @@
 func (e *NotFound) Error() string { return "not found: " + e.ISBN }

 // Describe accepts anything.
-func Describe(v interface{}) string {
+func Describe(v any) string {
 	return fmt.Sprint(v)
 }

$ go fix ./...
# example.com/shelf/legacy2
fix: omitzero: ignoring alternative fix "Replace omitempty with omitzero (behavior change)"
$ go vet ./...
$ go fix -diff ./... ; echo "exit=$?"
exit=0

// Package oldapi is the catalogue's v1 helper package.
package oldapi

import "strings"

// Normalize trims and lower-cases an ISBN.
//
// Deprecated: use Clean.
//
//go:fix inline
func Normalize(s string) string {
	return Clean(s)
}

// Clean trims and lower-cases an ISBN.
func Clean(s string) string {
	return strings.ToLower(strings.TrimSpace(s))
}

package inl

import "example.com/shelf/oldapi"

func Key(isbn string) string {
	return oldapi.Normalize(isbn)
}

$ go fix -diff ./inl
--- inl/inl.go (old)
+++ inl/inl.go (new)
@@ -3,5 +3,5 @@
 import "example.com/shelf/oldapi"

 func Key(isbn string) string {
-	return oldapi.Normalize(isbn)
+	return oldapi.Clean(isbn)
 }

// +build linux darwin

package legacy

$ gofmt -w tag.go
$ go fix -diff .
--- tag.go (old)
+++ tag.go (new)
@@ -1,4 +1,3 @@
 //go:build linux || darwin
-// +build linux darwin

 package legacy