Copy disabled (too large)
Download .txt
Showing preview only (14,775K chars total). Download the full file to get everything.
Repository: golang/tools
Branch: master
Commit: 02548f745018
Files: 2761
Total size: 13.6 MB
Directory structure:
gitextract_5udc9x7r/
├── .gitattributes
├── .gitignore
├── .prettierrc
├── CONTRIBUTING.md
├── LICENSE
├── PATENTS
├── README.md
├── benchmark/
│ └── parse/
│ ├── parse.go
│ └── parse_test.go
├── blog/
│ ├── atom/
│ │ └── atom.go
│ ├── blog.go
│ └── blog_test.go
├── cmd/
│ ├── benchcmp/
│ │ ├── benchcmp.go
│ │ ├── benchcmp_test.go
│ │ ├── compare.go
│ │ ├── compare_test.go
│ │ └── doc.go
│ ├── bisect/
│ │ ├── go120.go
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ ├── README.md
│ │ ├── basic.txt
│ │ ├── count2.txt
│ │ ├── double.txt
│ │ ├── max1.txt
│ │ ├── max2.txt
│ │ ├── maxset.txt
│ │ ├── maxset1.txt
│ │ ├── maxset4.txt
│ │ ├── negate.txt
│ │ ├── rand.txt
│ │ ├── rand1.txt
│ │ └── rand2.txt
│ ├── bundle/
│ │ ├── .gitignore
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ ├── out.golden
│ │ └── src/
│ │ ├── domain.name/
│ │ │ └── importdecl/
│ │ │ └── p.go
│ │ └── initial/
│ │ ├── a.go
│ │ ├── b.go
│ │ └── c.go
│ ├── callgraph/
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ └── src/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── pkg_test.go
│ ├── compilebench/
│ │ └── main.go
│ ├── deadcode/
│ │ ├── deadcode.go
│ │ ├── deadcode_test.go
│ │ ├── doc.go
│ │ └── testdata/
│ │ ├── basic.txtar
│ │ ├── filterflag.txtar
│ │ ├── generated.txtar
│ │ ├── issue65915.txtar
│ │ ├── issue67915.txt
│ │ ├── issue73652.txtar
│ │ ├── jsonflag.txtar
│ │ ├── lineflag.txtar
│ │ ├── marker.txtar
│ │ ├── testflag.txtar
│ │ └── whylive.txtar
│ ├── digraph/
│ │ ├── digraph.go
│ │ ├── digraph_test.go
│ │ └── doc.go
│ ├── eg/
│ │ └── eg.go
│ ├── file2fuzz/
│ │ ├── main.go
│ │ └── main_test.go
│ ├── fiximports/
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ └── src/
│ │ ├── fruit.io/
│ │ │ ├── banana/
│ │ │ │ └── banana.go
│ │ │ ├── orange/
│ │ │ │ └── orange.go
│ │ │ └── pear/
│ │ │ └── pear.go
│ │ ├── new.com/
│ │ │ └── one/
│ │ │ └── one.go
│ │ ├── old.com/
│ │ │ ├── bad/
│ │ │ │ └── bad.go
│ │ │ └── one/
│ │ │ └── one.go
│ │ └── titanic.biz/
│ │ ├── bar/
│ │ │ └── bar.go
│ │ └── foo/
│ │ └── foo.go
│ ├── go-contrib-init/
│ │ ├── contrib.go
│ │ └── contrib_test.go
│ ├── godex/
│ │ ├── doc.go
│ │ ├── gc.go
│ │ ├── gccgo.go
│ │ ├── godex.go
│ │ ├── isAlias18.go
│ │ ├── isAlias19.go
│ │ ├── print.go
│ │ ├── source.go
│ │ └── writetype.go
│ ├── goimports/
│ │ ├── doc.go
│ │ ├── goimports.go
│ │ ├── goimports_gc.go
│ │ └── goimports_not_gc.go
│ ├── gomvpkg/
│ │ └── main.go
│ ├── gonew/
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ └── quote.txt
│ ├── gotype/
│ │ ├── gotype.go
│ │ ├── sizesFor18.go
│ │ └── sizesFor19.go
│ ├── goyacc/
│ │ ├── doc.go
│ │ ├── testdata/
│ │ │ └── expr/
│ │ │ ├── README
│ │ │ ├── expr.y
│ │ │ └── main.go
│ │ └── yacc.go
│ ├── html2article/
│ │ └── conv.go
│ ├── present/
│ │ ├── dir.go
│ │ ├── doc.go
│ │ ├── main.go
│ │ ├── play.go
│ │ ├── static/
│ │ │ ├── article.css
│ │ │ ├── dir.css
│ │ │ ├── dir.js
│ │ │ ├── jquery-ui.js
│ │ │ ├── jquery.js
│ │ │ ├── notes.css
│ │ │ ├── notes.js
│ │ │ ├── play.js
│ │ │ ├── playground.js
│ │ │ ├── slides.js
│ │ │ └── styles.css
│ │ └── templates/
│ │ ├── action.tmpl
│ │ ├── article.tmpl
│ │ ├── dir.tmpl
│ │ └── slides.tmpl
│ ├── present2md/
│ │ └── main.go
│ ├── signature-fuzzer/
│ │ ├── README.md
│ │ ├── fuzz-driver/
│ │ │ ├── driver.go
│ │ │ └── drv_test.go
│ │ ├── fuzz-runner/
│ │ │ ├── rnr_test.go
│ │ │ ├── runner.go
│ │ │ └── testdata/
│ │ │ └── himom.go
│ │ └── internal/
│ │ └── fuzz-generator/
│ │ ├── arrayparm.go
│ │ ├── gen_test.go
│ │ ├── generator.go
│ │ ├── mapparm.go
│ │ ├── numparm.go
│ │ ├── parm.go
│ │ ├── pointerparm.go
│ │ ├── stringparm.go
│ │ ├── structparm.go
│ │ ├── typedefparm.go
│ │ └── wraprand.go
│ ├── splitdwarf/
│ │ ├── internal/
│ │ │ └── macho/
│ │ │ ├── fat.go
│ │ │ ├── file.go
│ │ │ ├── file_test.go
│ │ │ ├── macho.go
│ │ │ ├── reloctype.go
│ │ │ ├── reloctype_string.go
│ │ │ └── testdata/
│ │ │ ├── clang-386-darwin-exec-with-rpath
│ │ │ ├── clang-386-darwin.obj
│ │ │ ├── clang-amd64-darwin-exec-with-rpath
│ │ │ ├── clang-amd64-darwin.obj
│ │ │ ├── fat-gcc-386-amd64-darwin-exec
│ │ │ ├── gcc-386-darwin-exec
│ │ │ ├── gcc-amd64-darwin-exec
│ │ │ ├── gcc-amd64-darwin-exec-debug
│ │ │ └── hello.c
│ │ └── splitdwarf.go
│ ├── ssadump/
│ │ └── main.go
│ ├── stress/
│ │ └── stress.go
│ ├── stringer/
│ │ ├── endtoend_test.go
│ │ ├── golden_test.go
│ │ ├── multifile_test.go
│ │ ├── stringer.go
│ │ ├── testdata/
│ │ │ ├── cgo.go
│ │ │ ├── conv.go
│ │ │ ├── conv2.go
│ │ │ ├── day.go
│ │ │ ├── gap.go
│ │ │ ├── int8overflow.go
│ │ │ ├── num.go
│ │ │ ├── number.go
│ │ │ ├── prime.go
│ │ │ ├── prime2.go
│ │ │ ├── tag_main.go
│ │ │ ├── tag_tag.go
│ │ │ ├── unum.go
│ │ │ ├── unum2.go
│ │ │ └── vary_day.go
│ │ └── util_test.go
│ └── toolstash/
│ ├── buildall
│ ├── cmp.go
│ └── main.go
├── codereview.cfg
├── container/
│ └── intsets/
│ ├── export_test.go
│ ├── sparse.go
│ └── sparse_test.go
├── copyright/
│ ├── copyright.go
│ └── copyright_test.go
├── cover/
│ ├── profile.go
│ └── profile_test.go
├── go/
│ ├── analysis/
│ │ ├── analysis.go
│ │ ├── analysistest/
│ │ │ ├── analysistest.go
│ │ │ └── analysistest_test.go
│ │ ├── checker/
│ │ │ ├── checker.go
│ │ │ ├── checker_test.go
│ │ │ ├── example_test.go
│ │ │ └── print.go
│ │ ├── diagnostic.go
│ │ ├── doc/
│ │ │ └── suggested_fixes.md
│ │ ├── doc.go
│ │ ├── internal/
│ │ │ ├── analysisflags/
│ │ │ │ ├── flags.go
│ │ │ │ ├── flags_test.go
│ │ │ │ └── help.go
│ │ │ ├── checker/
│ │ │ │ ├── checker.go
│ │ │ │ ├── checker_test.go
│ │ │ │ ├── fix_test.go
│ │ │ │ ├── start_test.go
│ │ │ │ └── testdata/
│ │ │ │ ├── conflict.txt
│ │ │ │ ├── diff.txt
│ │ │ │ ├── fixes.txt
│ │ │ │ ├── generated.txt
│ │ │ │ ├── importdup.txt
│ │ │ │ ├── importdup2.txt
│ │ │ │ ├── json.txt
│ │ │ │ ├── noend.txt
│ │ │ │ ├── overlap.txt
│ │ │ │ └── plain.txt
│ │ │ ├── internal.go
│ │ │ └── versiontest/
│ │ │ └── version_test.go
│ │ ├── multichecker/
│ │ │ ├── multichecker.go
│ │ │ └── multichecker_test.go
│ │ ├── passes/
│ │ │ ├── README
│ │ │ ├── appends/
│ │ │ │ ├── appends.go
│ │ │ │ ├── appends_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── asmdecl/
│ │ │ │ ├── asmdecl.go
│ │ │ │ ├── asmdecl_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── asm.go
│ │ │ │ ├── asm1.s
│ │ │ │ ├── asm10.s
│ │ │ │ ├── asm11.s
│ │ │ │ ├── asm2.s
│ │ │ │ ├── asm3.s
│ │ │ │ ├── asm4.s
│ │ │ │ ├── asm5.s
│ │ │ │ ├── asm6.s
│ │ │ │ ├── asm7.s
│ │ │ │ ├── asm8.s
│ │ │ │ └── asm9.s
│ │ │ ├── assign/
│ │ │ │ ├── assign.go
│ │ │ │ ├── assign_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── typeparams.go
│ │ │ │ └── typeparams.go.golden
│ │ │ ├── atomic/
│ │ │ │ ├── atomic.go
│ │ │ │ ├── atomic_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── atomicalign/
│ │ │ │ ├── atomicalign.go
│ │ │ │ ├── atomicalign_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── stub.go
│ │ │ │ └── b/
│ │ │ │ ├── b.go
│ │ │ │ └── stub.go
│ │ │ ├── bools/
│ │ │ │ ├── bools.go
│ │ │ │ ├── bools_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── buildssa/
│ │ │ │ ├── buildssa.go
│ │ │ │ ├── buildssa_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── buildtag/
│ │ │ │ ├── buildtag.go
│ │ │ │ ├── buildtag_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── buildtag.go
│ │ │ │ │ ├── buildtag2.go
│ │ │ │ │ ├── buildtag3.go
│ │ │ │ │ ├── buildtag4.go
│ │ │ │ │ ├── buildtag5.go
│ │ │ │ │ ├── buildtag6.s
│ │ │ │ │ ├── buildtag7.s
│ │ │ │ │ └── buildtag8.s
│ │ │ │ └── b/
│ │ │ │ ├── vers.go
│ │ │ │ ├── vers1.go
│ │ │ │ ├── vers2.go
│ │ │ │ ├── vers3.go
│ │ │ │ ├── vers4.go
│ │ │ │ ├── vers5.go
│ │ │ │ └── vers6.go
│ │ │ ├── cgocall/
│ │ │ │ ├── cgocall.go
│ │ │ │ ├── cgocall_go120.go
│ │ │ │ ├── cgocall_go121.go
│ │ │ │ ├── cgocall_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── cgo.go
│ │ │ │ │ └── cgo3.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ ├── c/
│ │ │ │ │ └── c.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── composite/
│ │ │ │ ├── composite.go
│ │ │ │ ├── composite_test.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ ├── a.go.golden
│ │ │ │ │ │ ├── a_fuzz_test.go
│ │ │ │ │ │ └── a_fuzz_test.go.golden
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── lib/
│ │ │ │ │ │ └── lib.go
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── typeparams.go.golden
│ │ │ │ └── whitelist.go
│ │ │ ├── copylock/
│ │ │ │ ├── copylock.go
│ │ │ │ ├── copylock_test.go
│ │ │ │ ├── main.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── copylock.go
│ │ │ │ │ ├── copylock_func.go
│ │ │ │ │ ├── copylock_range.go
│ │ │ │ │ ├── issue61678.go
│ │ │ │ │ └── newexpr_go126.go
│ │ │ │ ├── forstmt/
│ │ │ │ │ ├── go21.txtar
│ │ │ │ │ └── go22.txtar
│ │ │ │ ├── issue67787/
│ │ │ │ │ └── issue67787.go
│ │ │ │ ├── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ └── unfortunate/
│ │ │ │ ├── local_go123.go
│ │ │ │ └── local_go124.go
│ │ │ ├── ctrlflow/
│ │ │ │ ├── ctrlflow.go
│ │ │ │ ├── ctrlflow_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── lib/
│ │ │ │ │ └── lib.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── deepequalerrors/
│ │ │ │ ├── deepequalerrors.go
│ │ │ │ ├── deepequalerrors_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── defers/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── defers/
│ │ │ │ │ └── main.go
│ │ │ │ ├── defers.go
│ │ │ │ ├── defers_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── directive/
│ │ │ │ ├── directive.go
│ │ │ │ ├── directive_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── badspace.go
│ │ │ │ ├── issue66046.go
│ │ │ │ ├── misplaced.go
│ │ │ │ ├── misplaced.s
│ │ │ │ ├── misplaced_test.go
│ │ │ │ └── p.go
│ │ │ ├── errorsas/
│ │ │ │ ├── errorsas.go
│ │ │ │ ├── errorsas_test.go
│ │ │ │ ├── main.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── fieldalignment/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── fieldalignment/
│ │ │ │ │ └── main.go
│ │ │ │ ├── fieldalignment.go
│ │ │ │ ├── fieldalignment_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ ├── a.go.golden
│ │ │ │ ├── a_386.go
│ │ │ │ ├── a_386.go.golden
│ │ │ │ ├── a_amd64.go
│ │ │ │ └── a_amd64.go.golden
│ │ │ ├── findcall/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── findcall/
│ │ │ │ │ └── main.go
│ │ │ │ ├── findcall.go
│ │ │ │ ├── findcall_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── framepointer/
│ │ │ │ ├── framepointer.go
│ │ │ │ ├── framepointer_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── asm.go
│ │ │ │ ├── asm_amd64.s
│ │ │ │ ├── asm_arm64.s
│ │ │ │ ├── asm_darwin_amd64.s
│ │ │ │ ├── asm_linux_amd64.s
│ │ │ │ ├── asm_windows_amd64.s
│ │ │ │ └── buildtag_amd64.s
│ │ │ ├── gofix/
│ │ │ │ ├── doc.go
│ │ │ │ ├── gofix.go
│ │ │ │ ├── gofix_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── hostport/
│ │ │ │ ├── hostport.go
│ │ │ │ ├── hostport_test.go
│ │ │ │ ├── main.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── httpmux/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── httpmux/
│ │ │ │ │ └── main.go
│ │ │ │ ├── httpmux.go
│ │ │ │ ├── httpmux_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── httpresponse/
│ │ │ │ ├── httpresponse.go
│ │ │ │ ├── httpresponse_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── ifaceassert/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── ifaceassert/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── ifaceassert.go
│ │ │ │ ├── ifaceassert_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── inline/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── inline/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── inline.go
│ │ │ │ ├── inline_test.go
│ │ │ │ ├── issue77844_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ ├── a.go.golden
│ │ │ │ │ └── internal/
│ │ │ │ │ └── d.go
│ │ │ │ ├── b/
│ │ │ │ │ ├── b.go
│ │ │ │ │ └── b.go.golden
│ │ │ │ ├── binding_false/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── binding_true/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── c/
│ │ │ │ │ └── c.go
│ │ │ │ ├── directive/
│ │ │ │ │ ├── directive.go
│ │ │ │ │ └── directive.go.golden
│ │ │ │ ├── issue76190.txtar
│ │ │ │ ├── issue77610.txtar
│ │ │ │ ├── issue77844.txtar
│ │ │ │ └── rmimport/
│ │ │ │ ├── rmimport.go
│ │ │ │ └── rmimport.go.golden
│ │ │ ├── inspect/
│ │ │ │ └── inspect.go
│ │ │ ├── internal/
│ │ │ │ └── gofixdirective/
│ │ │ │ └── gofixdirective.go
│ │ │ ├── loopclosure/
│ │ │ │ ├── doc.go
│ │ │ │ ├── loopclosure.go
│ │ │ │ ├── loopclosure_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── b.go
│ │ │ │ ├── golang.org/
│ │ │ │ │ └── x/
│ │ │ │ │ └── sync/
│ │ │ │ │ └── errgroup/
│ │ │ │ │ └── errgroup.go
│ │ │ │ ├── subtests/
│ │ │ │ │ └── subtest.go
│ │ │ │ ├── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ └── versions/
│ │ │ │ ├── go18.txtar
│ │ │ │ └── go22.txtar
│ │ │ ├── lostcancel/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── lostcancel/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── lostcancel.go
│ │ │ │ ├── lostcancel_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── modernize/
│ │ │ │ ├── any.go
│ │ │ │ ├── atomictypes.go
│ │ │ │ ├── bloop.go
│ │ │ │ ├── cmd/
│ │ │ │ │ └── modernize/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── errorsastype.go
│ │ │ │ ├── fmtappendf.go
│ │ │ │ ├── forvar.go
│ │ │ │ ├── maps.go
│ │ │ │ ├── minmax.go
│ │ │ │ ├── modernize.go
│ │ │ │ ├── modernize_test.go
│ │ │ │ ├── newexpr.go
│ │ │ │ ├── omitzero.go
│ │ │ │ ├── plusbuild.go
│ │ │ │ ├── rangeint.go
│ │ │ │ ├── reflect.go
│ │ │ │ ├── slices.go
│ │ │ │ ├── slicescontains.go
│ │ │ │ ├── slicesdelete.go
│ │ │ │ ├── sortslice.go
│ │ │ │ ├── stditerators.go
│ │ │ │ ├── stringsbuilder.go
│ │ │ │ ├── stringscut.go
│ │ │ │ ├── stringscutprefix.go
│ │ │ │ ├── stringsseq.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── any/
│ │ │ │ │ │ ├── any.go
│ │ │ │ │ │ ├── any.go.golden
│ │ │ │ │ │ ├── generated.go
│ │ │ │ │ │ └── generated.go.golden
│ │ │ │ │ ├── appendclipped/
│ │ │ │ │ │ ├── appendclipped.go
│ │ │ │ │ │ ├── appendclipped.go.golden
│ │ │ │ │ │ ├── bytesclone.go
│ │ │ │ │ │ └── bytesclone.go.golden
│ │ │ │ │ ├── atomictypes/
│ │ │ │ │ │ ├── atomic.go
│ │ │ │ │ │ ├── atomic.go.golden
│ │ │ │ │ │ ├── atomic_shadow.go
│ │ │ │ │ │ ├── atomic_shadow.go.golden
│ │ │ │ │ │ ├── go118/
│ │ │ │ │ │ │ ├── atomic_go118.go
│ │ │ │ │ │ │ └── atomic_go118.go.golden
│ │ │ │ │ │ ├── go120/
│ │ │ │ │ │ │ ├── atomic_go120.go
│ │ │ │ │ │ │ └── atomic_go120.go.golden
│ │ │ │ │ │ └── ignored/
│ │ │ │ │ │ ├── atomic.go
│ │ │ │ │ │ ├── atomic.go.golden
│ │ │ │ │ │ └── atomic_ignored.go
│ │ │ │ │ ├── bloop/
│ │ │ │ │ │ ├── bloop.go
│ │ │ │ │ │ ├── bloop_test.go
│ │ │ │ │ │ └── bloop_test.go.golden
│ │ │ │ │ ├── errorsastype/
│ │ │ │ │ │ ├── dotimport/
│ │ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ │ ├── errorsastype.go
│ │ │ │ │ │ └── errorsastype.go.golden
│ │ │ │ │ ├── fieldsseq/
│ │ │ │ │ │ ├── fieldsseq.go
│ │ │ │ │ │ ├── fieldsseq.go.golden
│ │ │ │ │ │ └── fieldsseq_go123.go
│ │ │ │ │ ├── fmtappendf/
│ │ │ │ │ │ ├── fmtappendf.go
│ │ │ │ │ │ └── fmtappendf.go.golden
│ │ │ │ │ ├── forvar/
│ │ │ │ │ │ ├── forvar.go
│ │ │ │ │ │ └── forvar.go.golden
│ │ │ │ │ ├── mapsloop/
│ │ │ │ │ │ ├── mapsloop.go
│ │ │ │ │ │ ├── mapsloop.go.golden
│ │ │ │ │ │ ├── mapsloop_dot.go
│ │ │ │ │ │ └── mapsloop_dot.go.golden
│ │ │ │ │ ├── minmax/
│ │ │ │ │ │ ├── go120/
│ │ │ │ │ │ │ ├── minmax.go
│ │ │ │ │ │ │ ├── minmax_go120.go
│ │ │ │ │ │ │ └── minmax_go120.go.golden
│ │ │ │ │ │ ├── minmax.go
│ │ │ │ │ │ ├── minmax.go.golden
│ │ │ │ │ │ ├── nonstrict/
│ │ │ │ │ │ │ ├── nonstrict.go
│ │ │ │ │ │ │ └── nonstrict.go.golden
│ │ │ │ │ │ ├── userdefined/
│ │ │ │ │ │ │ ├── userdefined.go
│ │ │ │ │ │ │ └── userdefined.go.golden
│ │ │ │ │ │ ├── wrongoperators/
│ │ │ │ │ │ │ ├── wrongoperators.go
│ │ │ │ │ │ │ └── wrongoperators.go.golden
│ │ │ │ │ │ └── wrongreturn/
│ │ │ │ │ │ ├── wrongreturn.go
│ │ │ │ │ │ └── wrongreturn.go.golden
│ │ │ │ │ ├── newexpr/
│ │ │ │ │ │ ├── newexpr.go
│ │ │ │ │ │ ├── newexpr.go.golden
│ │ │ │ │ │ └── newexpr_go125.go
│ │ │ │ │ ├── omitzero/
│ │ │ │ │ │ ├── kube/
│ │ │ │ │ │ │ └── kube.go
│ │ │ │ │ │ ├── omitzero.go
│ │ │ │ │ │ └── omitzero.go.golden
│ │ │ │ │ ├── plusbuild/
│ │ │ │ │ │ ├── plusbuild.go
│ │ │ │ │ │ ├── plusbuild.go.golden
│ │ │ │ │ │ └── plusbuild2.go
│ │ │ │ │ ├── rangeint/
│ │ │ │ │ │ ├── a/
│ │ │ │ │ │ │ └── a.go
│ │ │ │ │ │ ├── rangeint.go
│ │ │ │ │ │ └── rangeint.go.golden
│ │ │ │ │ ├── reflecttypefor/
│ │ │ │ │ │ ├── reflecttypefor.go
│ │ │ │ │ │ └── reflecttypefor.go.golden
│ │ │ │ │ ├── slicescontains/
│ │ │ │ │ │ ├── slicescontains.go
│ │ │ │ │ │ └── slicescontains.go.golden
│ │ │ │ │ ├── slicesdelete/
│ │ │ │ │ │ ├── slicesdelete.go
│ │ │ │ │ │ └── slicesdelete.go.golden
│ │ │ │ │ ├── slicessort/
│ │ │ │ │ │ ├── slicessort.go
│ │ │ │ │ │ ├── slicessort.go.golden
│ │ │ │ │ │ ├── slicessort_dot.go
│ │ │ │ │ │ └── slicessort_dot.go.golden
│ │ │ │ │ ├── splitseq/
│ │ │ │ │ │ ├── splitseq.go
│ │ │ │ │ │ ├── splitseq.go.golden
│ │ │ │ │ │ └── splitseq_go123.go
│ │ │ │ │ ├── stditerators/
│ │ │ │ │ │ ├── stditerators.go
│ │ │ │ │ │ └── stditerators.go.golden
│ │ │ │ │ ├── stringsbuilder/
│ │ │ │ │ │ ├── stringsbuilder.go
│ │ │ │ │ │ └── stringsbuilder.go.golden
│ │ │ │ │ ├── stringscut/
│ │ │ │ │ │ ├── stringscut.go
│ │ │ │ │ │ └── stringscut.go.golden
│ │ │ │ │ ├── stringscutprefix/
│ │ │ │ │ │ ├── bytescutprefix/
│ │ │ │ │ │ │ ├── bytescutprefix.go
│ │ │ │ │ │ │ ├── bytescutprefix.go.golden
│ │ │ │ │ │ │ ├── bytescutprefix_dot.go
│ │ │ │ │ │ │ └── bytescutprefix_dot.go.golden
│ │ │ │ │ │ ├── stringscutprefix.go
│ │ │ │ │ │ ├── stringscutprefix.go.golden
│ │ │ │ │ │ ├── stringscutprefix_dot.go
│ │ │ │ │ │ └── stringscutprefix_dot.go.golden
│ │ │ │ │ ├── testingcontext/
│ │ │ │ │ │ ├── testingcontext.go
│ │ │ │ │ │ ├── testingcontext_test.go
│ │ │ │ │ │ └── testingcontext_test.go.golden
│ │ │ │ │ ├── unsafefuncs/
│ │ │ │ │ │ ├── unsafefuncs.go
│ │ │ │ │ │ └── unsafefuncs.go.golden
│ │ │ │ │ └── waitgroupgo/
│ │ │ │ │ ├── waitgroup.go
│ │ │ │ │ ├── waitgroup.go.golden
│ │ │ │ │ ├── waitgroup_alias.go
│ │ │ │ │ ├── waitgroup_alias.go.golden
│ │ │ │ │ ├── waitgroup_dot.go
│ │ │ │ │ └── waitgroup_dot.go.golden
│ │ │ │ ├── testingcontext.go
│ │ │ │ ├── unsafefuncs.go
│ │ │ │ └── waitgroupgo.go
│ │ │ ├── nilfunc/
│ │ │ │ ├── doc.go
│ │ │ │ ├── nilfunc.go
│ │ │ │ ├── nilfunc_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── nilness/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── nilness/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── nilness.go
│ │ │ │ ├── nilness_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ ├── c/
│ │ │ │ │ └── c.go
│ │ │ │ └── d/
│ │ │ │ └── d.go
│ │ │ ├── pkgfact/
│ │ │ │ ├── pkgfact.go
│ │ │ │ ├── pkgfact_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── printf/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── printf.go
│ │ │ │ ├── printf_test.go
│ │ │ │ ├── testdata/
│ │ │ │ │ ├── nonconst_go123.txtar
│ │ │ │ │ ├── nonconst_go124.txtar
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a2.go
│ │ │ │ │ ├── b/
│ │ │ │ │ │ └── b.go
│ │ │ │ │ ├── issue68744/
│ │ │ │ │ │ └── issue68744.go
│ │ │ │ │ ├── issue70572/
│ │ │ │ │ │ └── issue70572.go
│ │ │ │ │ ├── issue72850/
│ │ │ │ │ │ ├── a_go125.go
│ │ │ │ │ │ └── a_go126.go
│ │ │ │ │ ├── issue76616/
│ │ │ │ │ │ └── issue76616.go
│ │ │ │ │ ├── nofmt/
│ │ │ │ │ │ └── nofmt.go
│ │ │ │ │ ├── nonconst/
│ │ │ │ │ │ └── nonconst.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── diagnostics.go
│ │ │ │ │ └── wrappers.go
│ │ │ │ └── types.go
│ │ │ ├── reflectvaluecompare/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── reflectvaluecompare/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── reflectvaluecompare.go
│ │ │ │ ├── reflectvaluecompare_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── shadow/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── shadow/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── shadow.go
│ │ │ │ ├── shadow_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── shift/
│ │ │ │ ├── dead.go
│ │ │ │ ├── shift.go
│ │ │ │ ├── shift_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── sigchanyzer/
│ │ │ │ ├── doc.go
│ │ │ │ ├── sigchanyzer.go
│ │ │ │ ├── sigchanyzer_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── slog/
│ │ │ │ ├── doc.go
│ │ │ │ ├── slog.go
│ │ │ │ ├── slog_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── sortslice/
│ │ │ │ ├── analyzer.go
│ │ │ │ ├── analyzer_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── stdmethods/
│ │ │ │ ├── doc.go
│ │ │ │ ├── stdmethods.go
│ │ │ │ ├── stdmethods_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── b.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── stdversion/
│ │ │ │ ├── main.go
│ │ │ │ ├── stdversion.go
│ │ │ │ ├── stdversion_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── test.txtar
│ │ │ ├── stringintconv/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── stringintconv/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── string.go
│ │ │ │ ├── string_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── fix/
│ │ │ │ │ ├── fix.go
│ │ │ │ │ ├── fix.go.golden
│ │ │ │ │ ├── fixdot.go
│ │ │ │ │ ├── fixdot.go.golden
│ │ │ │ │ ├── fixnamed.go
│ │ │ │ │ └── fixnamed.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── structtag/
│ │ │ │ ├── structtag.go
│ │ │ │ ├── structtag_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── testinggoroutine/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── b.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ ├── testinggoroutine.go
│ │ │ │ ├── testinggoroutine_test.go
│ │ │ │ └── util.go
│ │ │ ├── tests/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ ├── a_test.go
│ │ │ │ │ │ ├── ax_test.go
│ │ │ │ │ │ └── go118_test.go
│ │ │ │ │ ├── b/
│ │ │ │ │ │ └── b.go
│ │ │ │ │ ├── b_x_test/
│ │ │ │ │ │ └── b_test.go
│ │ │ │ │ ├── divergent/
│ │ │ │ │ │ ├── buf.go
│ │ │ │ │ │ └── buf_test.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── typeparams_test.go
│ │ │ │ ├── tests.go
│ │ │ │ └── tests_test.go
│ │ │ ├── timeformat/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ └── b/
│ │ │ │ │ └── b.go
│ │ │ │ ├── timeformat.go
│ │ │ │ └── timeformat_test.go
│ │ │ ├── unmarshal/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── unmarshal/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── a.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ ├── unmarshal.go
│ │ │ │ └── unmarshal_test.go
│ │ │ ├── unreachable/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ └── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── unreachable.go
│ │ │ │ └── unreachable_test.go
│ │ │ ├── unsafeptr/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── issue40701.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ ├── unsafeptr.go
│ │ │ │ └── unsafeptr_test.go
│ │ │ ├── unusedresult/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── unusedresult/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── a.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── userdefs/
│ │ │ │ │ └── userdefs.go
│ │ │ │ ├── unusedresult.go
│ │ │ │ └── unusedresult_test.go
│ │ │ ├── unusedwrite/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── unusedwrite.go
│ │ │ │ │ └── importsunsafe/
│ │ │ │ │ └── i.go
│ │ │ │ ├── unusedwrite.go
│ │ │ │ └── unusedwrite_test.go
│ │ │ ├── usesgenerics/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── a.go
│ │ │ │ │ ├── b/
│ │ │ │ │ │ └── b.go
│ │ │ │ │ ├── c/
│ │ │ │ │ │ └── c.go
│ │ │ │ │ └── d/
│ │ │ │ │ └── d.go
│ │ │ │ ├── usesgenerics.go
│ │ │ │ └── usesgenerics_test.go
│ │ │ └── waitgroup/
│ │ │ ├── doc.go
│ │ │ ├── main.go
│ │ │ ├── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── waitgroup.go
│ │ │ └── waitgroup_test.go
│ │ ├── singlechecker/
│ │ │ └── singlechecker.go
│ │ ├── unitchecker/
│ │ │ ├── export_test.go
│ │ │ ├── main.go
│ │ │ ├── separate_test.go
│ │ │ ├── unitchecker.go
│ │ │ ├── unitchecker_test.go
│ │ │ └── vet_std_test.go
│ │ ├── validate.go
│ │ └── validate_test.go
│ ├── ast/
│ │ ├── astutil/
│ │ │ ├── enclosing.go
│ │ │ ├── enclosing_test.go
│ │ │ ├── imports.go
│ │ │ ├── imports_test.go
│ │ │ ├── rewrite.go
│ │ │ ├── rewrite_test.go
│ │ │ └── util.go
│ │ ├── edge/
│ │ │ └── edge.go
│ │ └── inspector/
│ │ ├── cursor.go
│ │ ├── cursor_test.go
│ │ ├── inspector.go
│ │ ├── inspector_test.go
│ │ ├── iter.go
│ │ ├── iter_test.go
│ │ ├── typeof.go
│ │ └── walk.go
│ ├── buildutil/
│ │ ├── allpackages.go
│ │ ├── allpackages_test.go
│ │ ├── fakecontext.go
│ │ ├── overlay.go
│ │ ├── overlay_test.go
│ │ ├── tags.go
│ │ ├── tags_test.go
│ │ ├── util.go
│ │ ├── util_test.go
│ │ └── util_windows_test.go
│ ├── callgraph/
│ │ ├── callgraph.go
│ │ ├── callgraph_test.go
│ │ ├── cha/
│ │ │ ├── cha.go
│ │ │ ├── cha_test.go
│ │ │ └── testdata/
│ │ │ ├── func.go
│ │ │ ├── generics.go
│ │ │ ├── iface.go
│ │ │ ├── issue23925.go
│ │ │ └── recv.go
│ │ ├── internal/
│ │ │ └── chautil/
│ │ │ └── lazy.go
│ │ ├── rta/
│ │ │ ├── rta.go
│ │ │ ├── rta_test.go
│ │ │ └── testdata/
│ │ │ ├── func.txtar
│ │ │ ├── generics.txtar
│ │ │ ├── iface.txtar
│ │ │ ├── multipkgs.txtar
│ │ │ ├── reflectcall.txtar
│ │ │ └── rtype.txtar
│ │ ├── static/
│ │ │ ├── static.go
│ │ │ └── static_test.go
│ │ ├── util.go
│ │ └── vta/
│ │ ├── graph.go
│ │ ├── graph_test.go
│ │ ├── helpers_test.go
│ │ ├── initial.go
│ │ ├── internal/
│ │ │ └── trie/
│ │ │ ├── bits.go
│ │ │ ├── bits_test.go
│ │ │ ├── builder.go
│ │ │ ├── op_test.go
│ │ │ ├── scope.go
│ │ │ ├── trie.go
│ │ │ └── trie_test.go
│ │ ├── propagation.go
│ │ ├── propagation_test.go
│ │ ├── testdata/
│ │ │ └── src/
│ │ │ ├── arrays_generics.go
│ │ │ ├── callgraph_collections.go
│ │ │ ├── callgraph_comma_maps.go
│ │ │ ├── callgraph_field_funcs.go
│ │ │ ├── callgraph_fields.go
│ │ │ ├── callgraph_generics.go
│ │ │ ├── callgraph_ho.go
│ │ │ ├── callgraph_interfaces.go
│ │ │ ├── callgraph_issue_57756.go
│ │ │ ├── callgraph_nested_ptr.go
│ │ │ ├── callgraph_pointers.go
│ │ │ ├── callgraph_range_over_func.go
│ │ │ ├── callgraph_recursive_types.go
│ │ │ ├── callgraph_static.go
│ │ │ ├── callgraph_type_aliases.go
│ │ │ ├── channels.go
│ │ │ ├── closures.go
│ │ │ ├── d/
│ │ │ │ └── d.go
│ │ │ ├── dynamic_calls.go
│ │ │ ├── fields.go
│ │ │ ├── function_alias.go
│ │ │ ├── generic_channels.go
│ │ │ ├── go117.go
│ │ │ ├── issue63146.go
│ │ │ ├── maps.go
│ │ │ ├── node_uniqueness.go
│ │ │ ├── panic.go
│ │ │ ├── phi.go
│ │ │ ├── phi_alias.go
│ │ │ ├── ranges.go
│ │ │ ├── returns.go
│ │ │ ├── select.go
│ │ │ ├── simple.go
│ │ │ ├── static_calls.go
│ │ │ ├── store.go
│ │ │ ├── store_load_alias.go
│ │ │ ├── stores_arrays.go
│ │ │ ├── t/
│ │ │ │ └── t.go
│ │ │ ├── type_assertions.go
│ │ │ └── type_conversions.go
│ │ ├── utils.go
│ │ ├── vta.go
│ │ └── vta_test.go
│ ├── cfg/
│ │ ├── builder.go
│ │ ├── cfg.go
│ │ ├── cfg_test.go
│ │ └── main.go
│ ├── gccgoexportdata/
│ │ ├── gccgoexportdata.go
│ │ ├── gccgoexportdata_test.go
│ │ └── testdata/
│ │ ├── errors.gox
│ │ ├── long.a
│ │ └── short.a
│ ├── gcexportdata/
│ │ ├── example_test.go
│ │ ├── gcexportdata.go
│ │ ├── importer.go
│ │ └── main.go
│ ├── internal/
│ │ ├── cgo/
│ │ │ ├── cgo.go
│ │ │ └── cgo_pkgconfig.go
│ │ └── gccgoimporter/
│ │ ├── ar.go
│ │ ├── backdoor.go
│ │ ├── gccgoinstallation.go
│ │ ├── gccgoinstallation_test.go
│ │ ├── importer.go
│ │ ├── importer_test.go
│ │ ├── newInterface10.go
│ │ ├── newInterface11.go
│ │ ├── parser.go
│ │ ├── parser_test.go
│ │ ├── testdata/
│ │ │ ├── aliases.go
│ │ │ ├── aliases.gox
│ │ │ ├── complexnums.go
│ │ │ ├── complexnums.gox
│ │ │ ├── conversions.go
│ │ │ ├── conversions.gox
│ │ │ ├── escapeinfo.go
│ │ │ ├── escapeinfo.gox
│ │ │ ├── imports.go
│ │ │ ├── imports.gox
│ │ │ ├── issue27856.go
│ │ │ ├── issue27856.gox
│ │ │ ├── issue29198.go
│ │ │ ├── issue29198.gox
│ │ │ ├── issue30628.go
│ │ │ ├── issue30628.gox
│ │ │ ├── issue31540.go
│ │ │ ├── issue31540.gox
│ │ │ ├── issue34182.go
│ │ │ ├── issue34182.gox
│ │ │ ├── libimportsar.a
│ │ │ ├── nointerface.go
│ │ │ ├── nointerface.gox
│ │ │ ├── notinheap.go
│ │ │ ├── notinheap.gox
│ │ │ ├── pointer.go
│ │ │ ├── pointer.gox
│ │ │ ├── time.gox
│ │ │ ├── unicode.gox
│ │ │ └── v1reflect.gox
│ │ └── testenv_test.go
│ ├── loader/
│ │ ├── doc.go
│ │ ├── loader.go
│ │ ├── loader_test.go
│ │ ├── stdlib_test.go
│ │ ├── testdata/
│ │ │ ├── a.go
│ │ │ ├── b.go
│ │ │ ├── badpkgdecl.go
│ │ │ └── issue46877/
│ │ │ ├── x.go
│ │ │ └── x.h
│ │ └── util.go
│ ├── packages/
│ │ ├── doc.go
│ │ ├── example_test.go
│ │ ├── external.go
│ │ ├── golist.go
│ │ ├── golist_overlay.go
│ │ ├── gopackages/
│ │ │ └── main.go
│ │ ├── internal/
│ │ │ ├── linecount/
│ │ │ │ └── linecount.go
│ │ │ └── nodecount/
│ │ │ └── nodecount.go
│ │ ├── loadmode_string.go
│ │ ├── overlay_test.go
│ │ ├── packages.go
│ │ ├── packages_test.go
│ │ ├── stdlib_test.go
│ │ └── visit.go
│ ├── ssa/
│ │ ├── TODO
│ │ ├── block.go
│ │ ├── blockopt.go
│ │ ├── builder.go
│ │ ├── builder_generic_test.go
│ │ ├── builder_test.go
│ │ ├── const.go
│ │ ├── const_test.go
│ │ ├── create.go
│ │ ├── doc.go
│ │ ├── dom.go
│ │ ├── dom_test.go
│ │ ├── emit.go
│ │ ├── example_test.go
│ │ ├── func.go
│ │ ├── instantiate.go
│ │ ├── instantiate_test.go
│ │ ├── interp/
│ │ │ ├── external.go
│ │ │ ├── interp.go
│ │ │ ├── interp_test.go
│ │ │ ├── map.go
│ │ │ ├── ops.go
│ │ │ ├── rangefunc_test.go
│ │ │ ├── reflect.go
│ │ │ ├── testdata/
│ │ │ │ ├── boundmeth.go
│ │ │ │ ├── complit.go
│ │ │ │ ├── convert.go
│ │ │ │ ├── coverage.go
│ │ │ │ ├── deepequal.go
│ │ │ │ ├── defer.go
│ │ │ │ ├── fieldprom.go
│ │ │ │ ├── fixedbugs/
│ │ │ │ │ ├── issue52342.go
│ │ │ │ │ ├── issue52835.go
│ │ │ │ │ ├── issue55086.go
│ │ │ │ │ ├── issue55115.go
│ │ │ │ │ ├── issue66783.go
│ │ │ │ │ ├── issue69298.go
│ │ │ │ │ └── issue69929.go
│ │ │ │ ├── forvarlifetime_go122.go
│ │ │ │ ├── forvarlifetime_old.go
│ │ │ │ ├── ifaceconv.go
│ │ │ │ ├── ifaceprom.go
│ │ │ │ ├── initorder.go
│ │ │ │ ├── methprom.go
│ │ │ │ ├── minmax.go
│ │ │ │ ├── mrvchain.go
│ │ │ │ ├── newexpr_go126.go
│ │ │ │ ├── range.go
│ │ │ │ ├── rangefunc.go
│ │ │ │ ├── rangeoverint.go
│ │ │ │ ├── rangevarlifetime_go122.go
│ │ │ │ ├── rangevarlifetime_old.go
│ │ │ │ ├── recover.go
│ │ │ │ ├── reflect.go
│ │ │ │ ├── slice2array.go
│ │ │ │ ├── slice2arrayptr.go
│ │ │ │ ├── src/
│ │ │ │ │ ├── encoding/
│ │ │ │ │ │ └── encoding.go
│ │ │ │ │ ├── errors/
│ │ │ │ │ │ └── errors.go
│ │ │ │ │ ├── fmt/
│ │ │ │ │ │ └── fmt.go
│ │ │ │ │ ├── io/
│ │ │ │ │ │ └── io.go
│ │ │ │ │ ├── log/
│ │ │ │ │ │ └── log.go
│ │ │ │ │ ├── math/
│ │ │ │ │ │ └── math.go
│ │ │ │ │ ├── os/
│ │ │ │ │ │ └── os.go
│ │ │ │ │ ├── reflect/
│ │ │ │ │ │ ├── deepequal.go
│ │ │ │ │ │ └── reflect.go
│ │ │ │ │ ├── runtime/
│ │ │ │ │ │ └── runtime.go
│ │ │ │ │ ├── sort/
│ │ │ │ │ │ └── sort.go
│ │ │ │ │ ├── strconv/
│ │ │ │ │ │ └── strconv.go
│ │ │ │ │ ├── strings/
│ │ │ │ │ │ └── strings.go
│ │ │ │ │ ├── sync/
│ │ │ │ │ │ └── sync.go
│ │ │ │ │ ├── time/
│ │ │ │ │ │ └── time.go
│ │ │ │ │ ├── unicode/
│ │ │ │ │ │ └── utf8/
│ │ │ │ │ │ └── utf8.go
│ │ │ │ │ └── unsafe/
│ │ │ │ │ └── unsafe.go
│ │ │ │ ├── static.go
│ │ │ │ ├── typeassert.go
│ │ │ │ ├── width32.go
│ │ │ │ └── zeros.go
│ │ │ └── value.go
│ │ ├── lift.go
│ │ ├── lvalue.go
│ │ ├── methods.go
│ │ ├── methods_test.go
│ │ ├── mode.go
│ │ ├── print.go
│ │ ├── sanity.go
│ │ ├── source.go
│ │ ├── source_test.go
│ │ ├── ssa.go
│ │ ├── ssautil/
│ │ │ ├── deprecated.go
│ │ │ ├── deprecated_test.go
│ │ │ ├── load.go
│ │ │ ├── load_test.go
│ │ │ ├── switch.go
│ │ │ ├── switch_test.go
│ │ │ ├── testdata/
│ │ │ │ └── switches.txtar
│ │ │ └── visit.go
│ │ ├── stdlib_test.go
│ │ ├── subst.go
│ │ ├── subst_test.go
│ │ ├── task.go
│ │ ├── testdata/
│ │ │ ├── fixedbugs/
│ │ │ │ ├── issue66783a.go
│ │ │ │ ├── issue66783b.go
│ │ │ │ └── issue73594.go
│ │ │ ├── indirect.txtar
│ │ │ ├── objlookup.go
│ │ │ ├── src/
│ │ │ │ ├── README.txt
│ │ │ │ ├── bytes/
│ │ │ │ │ └── bytes.go
│ │ │ │ ├── context/
│ │ │ │ │ └── context.go
│ │ │ │ ├── encoding/
│ │ │ │ │ ├── encoding.go
│ │ │ │ │ ├── json/
│ │ │ │ │ │ └── json.go
│ │ │ │ │ └── xml/
│ │ │ │ │ └── xml.go
│ │ │ │ ├── errors/
│ │ │ │ │ └── errors.go
│ │ │ │ ├── fmt/
│ │ │ │ │ └── fmt.go
│ │ │ │ ├── io/
│ │ │ │ │ └── io.go
│ │ │ │ ├── log/
│ │ │ │ │ └── log.go
│ │ │ │ ├── math/
│ │ │ │ │ └── math.go
│ │ │ │ ├── os/
│ │ │ │ │ └── os.go
│ │ │ │ ├── reflect/
│ │ │ │ │ └── reflect.go
│ │ │ │ ├── runtime/
│ │ │ │ │ └── runtime.go
│ │ │ │ ├── sort/
│ │ │ │ │ └── sort.go
│ │ │ │ ├── strconv/
│ │ │ │ │ └── strconv.go
│ │ │ │ ├── strings/
│ │ │ │ │ └── strings.go
│ │ │ │ ├── sync/
│ │ │ │ │ ├── atomic/
│ │ │ │ │ │ └── atomic.go
│ │ │ │ │ └── sync.go
│ │ │ │ ├── time/
│ │ │ │ │ └── time.go
│ │ │ │ └── unsafe/
│ │ │ │ └── unsafe.go
│ │ │ ├── structconv.go
│ │ │ └── valueforexpr.go
│ │ ├── testutil_test.go
│ │ ├── typeset.go
│ │ ├── util.go
│ │ └── wrappers.go
│ └── types/
│ ├── internal/
│ │ └── play/
│ │ └── play.go
│ ├── objectpath/
│ │ ├── objectpath.go
│ │ ├── objectpath_go118_test.go
│ │ └── objectpath_test.go
│ └── typeutil/
│ ├── callee.go
│ ├── callee_test.go
│ ├── example_test.go
│ ├── imports.go
│ ├── imports_test.go
│ ├── map.go
│ ├── map_test.go
│ ├── methodsetcache.go
│ ├── ui.go
│ └── ui_test.go
├── go.mod
├── go.sum
├── gopls/
│ ├── README.md
│ ├── contributors.txt
│ ├── doc/
│ │ ├── README.md
│ │ ├── advanced.md
│ │ ├── analyzers.md
│ │ ├── assets/
│ │ │ ├── assets.go
│ │ │ └── go.mod
│ │ ├── codelenses.md
│ │ ├── command-line.md
│ │ ├── contributing.md
│ │ ├── daemon.md
│ │ ├── default.tmpl
│ │ ├── design/
│ │ │ ├── design.md
│ │ │ ├── implementation.md
│ │ │ └── integrating.md
│ │ ├── editor/
│ │ │ ├── emacs.md
│ │ │ ├── helix.md
│ │ │ ├── sublime.md
│ │ │ ├── vim.md
│ │ │ └── zed.md
│ │ ├── features/
│ │ │ ├── README.md
│ │ │ ├── assembly.md
│ │ │ ├── completion.md
│ │ │ ├── diagnostics.md
│ │ │ ├── index.md
│ │ │ ├── mcp.md
│ │ │ ├── modfiles.md
│ │ │ ├── navigation.md
│ │ │ ├── passive.md
│ │ │ ├── templates.md
│ │ │ ├── transformation.md
│ │ │ └── web.md
│ │ ├── index.md
│ │ ├── inlayHints.md
│ │ ├── release/
│ │ │ ├── README
│ │ │ ├── v0.16.0.md
│ │ │ ├── v0.17.0.md
│ │ │ ├── v0.18.0.md
│ │ │ ├── v0.19.0.md
│ │ │ ├── v0.20.0.md
│ │ │ ├── v0.21.0.md
│ │ │ └── v0.22.0.md
│ │ ├── settings.md
│ │ ├── troubleshooting.md
│ │ └── workspace.md
│ ├── go.mod
│ ├── go.sum
│ ├── integration/
│ │ └── govim/
│ │ ├── Dockerfile
│ │ ├── README.md
│ │ ├── artifacts.go
│ │ ├── cloudbuild.harness.yaml
│ │ ├── cloudbuild.yaml
│ │ ├── run_local.sh
│ │ └── run_tests_for_cloudbuild.sh
│ ├── internal/
│ │ ├── analysis/
│ │ │ ├── deprecated/
│ │ │ │ ├── deprecated.go
│ │ │ │ ├── deprecated_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a_test.go
│ │ │ ├── embeddirective/
│ │ │ │ ├── doc.go
│ │ │ │ ├── embeddirective.go
│ │ │ │ ├── embeddirective_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── embedText
│ │ │ │ ├── import_missing.go
│ │ │ │ ├── import_missing.go.golden
│ │ │ │ ├── import_present.go
│ │ │ │ └── import_present_go120.go
│ │ │ ├── fillreturns/
│ │ │ │ ├── doc.go
│ │ │ │ ├── fillreturns.go
│ │ │ │ ├── fillreturns_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── fillstruct/
│ │ │ │ ├── fillstruct.go
│ │ │ │ ├── fillstruct_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── fillswitch/
│ │ │ │ ├── doc.go
│ │ │ │ ├── fillswitch.go
│ │ │ │ ├── fillswitch_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── infertypeargs/
│ │ │ │ ├── infertypeargs.go
│ │ │ │ ├── infertypeargs_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── basic.go
│ │ │ │ ├── basic.go.golden
│ │ │ │ ├── imported/
│ │ │ │ │ └── imported.go
│ │ │ │ ├── imported.go
│ │ │ │ ├── imported.go.golden
│ │ │ │ ├── notypechange.go
│ │ │ │ └── notypechange.go.golden
│ │ │ ├── maprange/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── maprange/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── maprange.go
│ │ │ │ ├── maprange_test.go
│ │ │ │ └── testdata/
│ │ │ │ ├── basic.txtar
│ │ │ │ └── old.txtar
│ │ │ ├── modernize/
│ │ │ │ └── cmd/
│ │ │ │ └── modernize/
│ │ │ │ └── main.go
│ │ │ ├── nonewvars/
│ │ │ │ ├── doc.go
│ │ │ │ ├── nonewvars.go
│ │ │ │ ├── nonewvars_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── noresultvalues/
│ │ │ │ ├── doc.go
│ │ │ │ ├── noresultvalues.go
│ │ │ │ ├── noresultvalues_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── recursiveiter/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── recursiveiter.go
│ │ │ │ ├── recursiveiter_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── simplifycompositelit/
│ │ │ │ ├── doc.go
│ │ │ │ ├── simplifycompositelit.go
│ │ │ │ ├── simplifycompositelit_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── generatedcode/
│ │ │ │ ├── generatedcode.go
│ │ │ │ └── generatedcode.go.golden
│ │ │ ├── simplifyrange/
│ │ │ │ ├── doc.go
│ │ │ │ ├── simplifyrange.go
│ │ │ │ ├── simplifyrange_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── generatedcode/
│ │ │ │ │ ├── generatedcode.go
│ │ │ │ │ └── generatedcode.go.golden
│ │ │ │ └── rangeoverfunc/
│ │ │ │ ├── rangeoverfunc.go
│ │ │ │ └── rangeoverfunc.go.golden
│ │ │ ├── simplifyslice/
│ │ │ │ ├── doc.go
│ │ │ │ ├── simplifyslice.go
│ │ │ │ ├── simplifyslice_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── generatedcode/
│ │ │ │ │ ├── generatedcode.go
│ │ │ │ │ └── generatedcode.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── typeparams.go
│ │ │ │ └── typeparams.go.golden
│ │ │ ├── unusedfunc/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── basic.txtar
│ │ │ │ ├── unusedfunc.go
│ │ │ │ └── unusedfunc_test.go
│ │ │ ├── unusedparams/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ ├── generatedcode/
│ │ │ │ │ │ ├── generatedcode.go
│ │ │ │ │ │ ├── generatedcode.go.golden
│ │ │ │ │ │ ├── nongeneratedcode.go
│ │ │ │ │ │ └── nongeneratedcode.go.golden
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── typeparams.go.golden
│ │ │ │ ├── unusedparams.go
│ │ │ │ └── unusedparams_test.go
│ │ │ ├── unusedvariable/
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── assign/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ └── decl/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── unusedvariable.go
│ │ │ │ └── unusedvariable_test.go
│ │ │ ├── writestring/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ └── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── writestring.go
│ │ │ │ └── writestring_test.go
│ │ │ └── yield/
│ │ │ ├── doc.go
│ │ │ ├── main.go
│ │ │ ├── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── yield.go
│ │ │ └── yield_test.go
│ │ ├── bloom/
│ │ │ ├── filter.go
│ │ │ └── filter_test.go
│ │ ├── cache/
│ │ │ ├── analysis.go
│ │ │ ├── cache.go
│ │ │ ├── check.go
│ │ │ ├── constraints.go
│ │ │ ├── constraints_test.go
│ │ │ ├── debug.go
│ │ │ ├── diagnostics.go
│ │ │ ├── errors.go
│ │ │ ├── errors_test.go
│ │ │ ├── filemap.go
│ │ │ ├── filemap_test.go
│ │ │ ├── filterer.go
│ │ │ ├── fs_memoized.go
│ │ │ ├── fs_overlay.go
│ │ │ ├── future.go
│ │ │ ├── future_test.go
│ │ │ ├── imports.go
│ │ │ ├── keys.go
│ │ │ ├── load.go
│ │ │ ├── metadata/
│ │ │ │ ├── cycle_test.go
│ │ │ │ ├── graph.go
│ │ │ │ └── metadata.go
│ │ │ ├── methodsets/
│ │ │ │ └── methodsets.go
│ │ │ ├── mod.go
│ │ │ ├── mod_tidy.go
│ │ │ ├── mod_vuln.go
│ │ │ ├── os_darwin.go
│ │ │ ├── os_windows.go
│ │ │ ├── package.go
│ │ │ ├── parse.go
│ │ │ ├── parse_cache.go
│ │ │ ├── parse_cache_test.go
│ │ │ ├── parsego/
│ │ │ │ ├── file.go
│ │ │ │ ├── parse.go
│ │ │ │ ├── parse_test.go
│ │ │ │ ├── resolver.go
│ │ │ │ ├── resolver_compat.go
│ │ │ │ ├── resolver_gen.go
│ │ │ │ └── resolver_test.go
│ │ │ ├── port.go
│ │ │ ├── port_test.go
│ │ │ ├── session.go
│ │ │ ├── session_test.go
│ │ │ ├── snapshot.go
│ │ │ ├── source.go
│ │ │ ├── symbols/
│ │ │ │ └── symbols.go
│ │ │ ├── symbols.go
│ │ │ ├── testfuncs/
│ │ │ │ ├── match.go
│ │ │ │ └── tests.go
│ │ │ ├── typerefs/
│ │ │ │ ├── doc.go
│ │ │ │ ├── packageset.go
│ │ │ │ ├── pkggraph_test.go
│ │ │ │ ├── pkgrefs_test.go
│ │ │ │ ├── refs.go
│ │ │ │ └── refs_test.go
│ │ │ ├── view.go
│ │ │ ├── view_test.go
│ │ │ ├── workspace.go
│ │ │ └── xrefs/
│ │ │ └── xrefs.go
│ │ ├── clonetest/
│ │ │ ├── clonetest.go
│ │ │ └── clonetest_test.go
│ │ ├── cmd/
│ │ │ ├── call_hierarchy.go
│ │ │ ├── capabilities_test.go
│ │ │ ├── check.go
│ │ │ ├── cmd.go
│ │ │ ├── codeaction.go
│ │ │ ├── codelens.go
│ │ │ ├── counters.go
│ │ │ ├── definition.go
│ │ │ ├── execute.go
│ │ │ ├── folding_range.go
│ │ │ ├── format.go
│ │ │ ├── help_test.go
│ │ │ ├── highlight.go
│ │ │ ├── implementation.go
│ │ │ ├── imports.go
│ │ │ ├── info.go
│ │ │ ├── integration_test.go
│ │ │ ├── links.go
│ │ │ ├── mcp.go
│ │ │ ├── mcp_test.go
│ │ │ ├── parsespan.go
│ │ │ ├── prepare_rename.go
│ │ │ ├── references.go
│ │ │ ├── remote.go
│ │ │ ├── rename.go
│ │ │ ├── semantictokens.go
│ │ │ ├── serve.go
│ │ │ ├── signature.go
│ │ │ ├── span.go
│ │ │ ├── spanformat_test.go
│ │ │ ├── stats.go
│ │ │ ├── subcommands.go
│ │ │ ├── symbols.go
│ │ │ ├── usage/
│ │ │ │ ├── api-json.hlp
│ │ │ │ ├── bug.hlp
│ │ │ │ ├── call_hierarchy.hlp
│ │ │ │ ├── check.hlp
│ │ │ │ ├── codeaction.hlp
│ │ │ │ ├── codelens.hlp
│ │ │ │ ├── definition.hlp
│ │ │ │ ├── execute.hlp
│ │ │ │ ├── fix.hlp
│ │ │ │ ├── folding_ranges.hlp
│ │ │ │ ├── format.hlp
│ │ │ │ ├── help.hlp
│ │ │ │ ├── highlight.hlp
│ │ │ │ ├── implementation.hlp
│ │ │ │ ├── imports.hlp
│ │ │ │ ├── inspect.hlp
│ │ │ │ ├── licenses.hlp
│ │ │ │ ├── links.hlp
│ │ │ │ ├── mcp.hlp
│ │ │ │ ├── prepare_rename.hlp
│ │ │ │ ├── references.hlp
│ │ │ │ ├── remote.hlp
│ │ │ │ ├── rename.hlp
│ │ │ │ ├── semtok.hlp
│ │ │ │ ├── serve.hlp
│ │ │ │ ├── signature.hlp
│ │ │ │ ├── stats.hlp
│ │ │ │ ├── symbols.hlp
│ │ │ │ ├── usage-v.hlp
│ │ │ │ ├── usage.hlp
│ │ │ │ ├── version.hlp
│ │ │ │ ├── vulncheck.hlp
│ │ │ │ └── workspace_symbol.hlp
│ │ │ ├── vulncheck.go
│ │ │ └── workspace_symbol.go
│ │ ├── debug/
│ │ │ ├── flight.go
│ │ │ ├── flight_go124.go
│ │ │ ├── flight_unix.go
│ │ │ ├── info.go
│ │ │ ├── info_test.go
│ │ │ ├── log/
│ │ │ │ └── log.go
│ │ │ ├── metrics.go
│ │ │ ├── rpc.go
│ │ │ ├── serve.go
│ │ │ ├── template_test.go
│ │ │ └── trace.go
│ │ ├── doc/
│ │ │ ├── api.go
│ │ │ ├── api.json
│ │ │ └── generate/
│ │ │ ├── generate.go
│ │ │ └── generate_test.go
│ │ ├── file/
│ │ │ ├── file.go
│ │ │ ├── hash.go
│ │ │ ├── kind.go
│ │ │ └── modification.go
│ │ ├── filecache/
│ │ │ ├── filecache.go
│ │ │ └── filecache_test.go
│ │ ├── filewatcher/
│ │ │ ├── export_test.go
│ │ │ ├── filewatcher.go
│ │ │ ├── filewatcher_test.go
│ │ │ └── fsnotify_watcher.go
│ │ ├── fuzzy/
│ │ │ ├── input.go
│ │ │ ├── input_test.go
│ │ │ ├── matcher.go
│ │ │ ├── matcher_test.go
│ │ │ ├── self_test.go
│ │ │ ├── symbol.go
│ │ │ └── symbol_test.go
│ │ ├── goasm/
│ │ │ └── definition.go
│ │ ├── golang/
│ │ │ ├── add_import.go
│ │ │ ├── addtest.go
│ │ │ ├── assembly.go
│ │ │ ├── call_hierarchy.go
│ │ │ ├── change_quote.go
│ │ │ ├── change_signature.go
│ │ │ ├── code_lens.go
│ │ │ ├── codeaction.go
│ │ │ ├── comment.go
│ │ │ ├── compileropt.go
│ │ │ ├── completion/
│ │ │ │ ├── builtin.go
│ │ │ │ ├── completion.go
│ │ │ │ ├── deep_completion.go
│ │ │ │ ├── deep_completion_test.go
│ │ │ │ ├── definition.go
│ │ │ │ ├── format.go
│ │ │ │ ├── fuzz.go
│ │ │ │ ├── keywords.go
│ │ │ │ ├── labels.go
│ │ │ │ ├── literal.go
│ │ │ │ ├── newfile.go
│ │ │ │ ├── package.go
│ │ │ │ ├── package_test.go
│ │ │ │ ├── postfix_snippets.go
│ │ │ │ ├── printf.go
│ │ │ │ ├── printf_test.go
│ │ │ │ ├── snippet/
│ │ │ │ │ ├── snippet_builder.go
│ │ │ │ │ └── snippet_builder_test.go
│ │ │ │ ├── snippet.go
│ │ │ │ ├── statements.go
│ │ │ │ ├── unify.go
│ │ │ │ ├── unimported.go
│ │ │ │ └── util.go
│ │ │ ├── counters.go
│ │ │ ├── definition.go
│ │ │ ├── diagnostics.go
│ │ │ ├── embeddirective.go
│ │ │ ├── extract.go
│ │ │ ├── extracttofile.go
│ │ │ ├── fix.go
│ │ │ ├── folding_range.go
│ │ │ ├── format.go
│ │ │ ├── format_test.go
│ │ │ ├── freesymbols.go
│ │ │ ├── freesymbols_test.go
│ │ │ ├── highlight.go
│ │ │ ├── hover.go
│ │ │ ├── hover_test.go
│ │ │ ├── identifier.go
│ │ │ ├── identifier_test.go
│ │ │ ├── implementation.go
│ │ │ ├── implementation_test.go
│ │ │ ├── inlay_hint.go
│ │ │ ├── inline.go
│ │ │ ├── inline_all.go
│ │ │ ├── invertifcondition.go
│ │ │ ├── known_packages.go
│ │ │ ├── lines.go
│ │ │ ├── linkname.go
│ │ │ ├── modify_tags.go
│ │ │ ├── movetype.go
│ │ │ ├── origin.go
│ │ │ ├── pkgdoc.go
│ │ │ ├── references.go
│ │ │ ├── rename.go
│ │ │ ├── rename_check.go
│ │ │ ├── semtok.go
│ │ │ ├── signature_help.go
│ │ │ ├── snapshot.go
│ │ │ ├── splitpkg/
│ │ │ │ ├── graph.go
│ │ │ │ ├── splitpkg.go
│ │ │ │ └── splitpkg.html.tmpl
│ │ │ ├── stub.go
│ │ │ ├── stubmethods/
│ │ │ │ ├── stubcalledfunc.go
│ │ │ │ └── stubmethods.go
│ │ │ ├── symbols.go
│ │ │ ├── type_definition.go
│ │ │ ├── type_hierarchy.go
│ │ │ ├── types_format.go
│ │ │ ├── undeclared.go
│ │ │ ├── util.go
│ │ │ ├── workspace_symbol.go
│ │ │ └── workspace_symbol_test.go
│ │ ├── label/
│ │ │ └── keys.go
│ │ ├── licenses/
│ │ │ ├── gen-licenses.sh
│ │ │ ├── licenses.go
│ │ │ └── licenses_test.go
│ │ ├── lsprpc/
│ │ │ ├── autostart_default.go
│ │ │ ├── autostart_posix.go
│ │ │ ├── binder.go
│ │ │ ├── binder_test.go
│ │ │ ├── commandinterceptor_test.go
│ │ │ ├── dialer.go
│ │ │ ├── export_test.go
│ │ │ ├── goenv.go
│ │ │ ├── goenv_test.go
│ │ │ ├── lsprpc.go
│ │ │ ├── lsprpc_test.go
│ │ │ └── middleware_test.go
│ │ ├── mcp/
│ │ │ ├── context.go
│ │ │ ├── counters.go
│ │ │ ├── file_context.go
│ │ │ ├── file_diagnostics.go
│ │ │ ├── file_metadata.go
│ │ │ ├── instructions.md
│ │ │ ├── mcp.go
│ │ │ ├── mcp_test.go
│ │ │ ├── outline.go
│ │ │ ├── references.go
│ │ │ ├── rename_symbol.go
│ │ │ ├── search.go
│ │ │ ├── symbol_references.go
│ │ │ ├── vulncheck.go
│ │ │ ├── workspace.go
│ │ │ └── workspace_diagnostics.go
│ │ ├── mod/
│ │ │ ├── code_lens.go
│ │ │ ├── diagnostics.go
│ │ │ ├── format.go
│ │ │ ├── hover.go
│ │ │ ├── inlay_hint.go
│ │ │ └── references.go
│ │ ├── progress/
│ │ │ ├── progress.go
│ │ │ └── progress_test.go
│ │ ├── protocol/
│ │ │ ├── command/
│ │ │ │ ├── command_gen.go
│ │ │ │ ├── commandmeta/
│ │ │ │ │ └── meta.go
│ │ │ │ ├── gen/
│ │ │ │ │ └── gen.go
│ │ │ │ ├── generate.go
│ │ │ │ ├── interface.go
│ │ │ │ ├── interface_test.go
│ │ │ │ └── util.go
│ │ │ ├── context.go
│ │ │ ├── doc.go
│ │ │ ├── edits.go
│ │ │ ├── enums.go
│ │ │ ├── form.go
│ │ │ ├── generate/
│ │ │ │ ├── README.md
│ │ │ │ ├── generate.go
│ │ │ │ ├── main.go
│ │ │ │ ├── main_test.go
│ │ │ │ ├── output.go
│ │ │ │ ├── tables.go
│ │ │ │ ├── typenames.go
│ │ │ │ └── types.go
│ │ │ ├── json_test.go
│ │ │ ├── log.go
│ │ │ ├── mapper.go
│ │ │ ├── mapper_test.go
│ │ │ ├── protocol.go
│ │ │ ├── semtok/
│ │ │ │ ├── README.txt
│ │ │ │ └── semtok.go
│ │ │ ├── span.go
│ │ │ ├── tsclient.go
│ │ │ ├── tsdocument_changes.go
│ │ │ ├── tsinsertreplaceedit.go
│ │ │ ├── tsinsertreplaceedit_test.go
│ │ │ ├── tsjson.go
│ │ │ ├── tsprotocol.go
│ │ │ ├── tsserver.go
│ │ │ ├── uri.go
│ │ │ ├── uri_test.go
│ │ │ └── uri_windows_test.go
│ │ ├── server/
│ │ │ ├── assets/
│ │ │ │ ├── common.css
│ │ │ │ ├── common.js
│ │ │ │ ├── splitpkg.css
│ │ │ │ └── splitpkg.js
│ │ │ ├── call_hierarchy.go
│ │ │ ├── code_action.go
│ │ │ ├── code_lens.go
│ │ │ ├── command.go
│ │ │ ├── completion.go
│ │ │ ├── counters.go
│ │ │ ├── debug.go
│ │ │ ├── definition.go
│ │ │ ├── diagnostics.go
│ │ │ ├── folding_range.go
│ │ │ ├── format.go
│ │ │ ├── general.go
│ │ │ ├── highlight.go
│ │ │ ├── hover.go
│ │ │ ├── implementation.go
│ │ │ ├── inlay_hint.go
│ │ │ ├── link.go
│ │ │ ├── prompt.go
│ │ │ ├── prompt_test.go
│ │ │ ├── references.go
│ │ │ ├── rename.go
│ │ │ ├── resolve.go
│ │ │ ├── selection_range.go
│ │ │ ├── semantic.go
│ │ │ ├── server.go
│ │ │ ├── signature_help.go
│ │ │ ├── symbols.go
│ │ │ ├── text_synchronization.go
│ │ │ ├── type_hierarchy.go
│ │ │ ├── unimplemented.go
│ │ │ ├── vulncheck_prompt.go
│ │ │ ├── vulncheck_prompt_test.go
│ │ │ ├── workspace.go
│ │ │ └── workspace_symbol.go
│ │ ├── settings/
│ │ │ ├── analysis.go
│ │ │ ├── codeactionkind.go
│ │ │ ├── default.go
│ │ │ ├── settings.go
│ │ │ ├── settings_test.go
│ │ │ ├── staticcheck.go
│ │ │ └── vet_test.go
│ │ ├── telemetry/
│ │ │ ├── counterpath.go
│ │ │ ├── counterpath_test.go
│ │ │ ├── latency.go
│ │ │ └── telemetry_test.go
│ │ ├── template/
│ │ │ ├── completion.go
│ │ │ ├── completion_test.go
│ │ │ ├── highlight.go
│ │ │ ├── implementations.go
│ │ │ ├── parse.go
│ │ │ ├── parse_test.go
│ │ │ └── symbols.go
│ │ ├── test/
│ │ │ ├── compare/
│ │ │ │ ├── text.go
│ │ │ │ └── text_test.go
│ │ │ ├── integration/
│ │ │ │ ├── bench/
│ │ │ │ │ ├── bench_test.go
│ │ │ │ │ ├── codeaction_test.go
│ │ │ │ │ ├── completion_test.go
│ │ │ │ │ ├── definition_test.go
│ │ │ │ │ ├── diagnostic_test.go
│ │ │ │ │ ├── didchange_test.go
│ │ │ │ │ ├── doc.go
│ │ │ │ │ ├── hover_test.go
│ │ │ │ │ ├── implementations_test.go
│ │ │ │ │ ├── imports_test.go
│ │ │ │ │ ├── iwl_test.go
│ │ │ │ │ ├── references_test.go
│ │ │ │ │ ├── reload_test.go
│ │ │ │ │ ├── rename_test.go
│ │ │ │ │ ├── repo_test.go
│ │ │ │ │ ├── stress_test.go
│ │ │ │ │ ├── tests_test.go
│ │ │ │ │ ├── typing_test.go
│ │ │ │ │ ├── unimported_test.go
│ │ │ │ │ └── workspace_symbols_test.go
│ │ │ │ ├── codelens/
│ │ │ │ │ └── codelens_test.go
│ │ │ │ ├── completion/
│ │ │ │ │ ├── completion18_test.go
│ │ │ │ │ ├── completion_test.go
│ │ │ │ │ ├── fixedbugs_test.go
│ │ │ │ │ └── postfix_snippet_test.go
│ │ │ │ ├── debug/
│ │ │ │ │ └── debug_test.go
│ │ │ │ ├── diagnostics/
│ │ │ │ │ ├── analysis_test.go
│ │ │ │ │ ├── builtin_test.go
│ │ │ │ │ ├── diagnostics_test.go
│ │ │ │ │ ├── golist_test.go
│ │ │ │ │ ├── gopackagesdriver_test.go
│ │ │ │ │ ├── invalidation_test.go
│ │ │ │ │ └── undeclared_test.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── env.go
│ │ │ │ ├── env_test.go
│ │ │ │ ├── expectation.go
│ │ │ │ ├── fake/
│ │ │ │ │ ├── client.go
│ │ │ │ │ ├── doc.go
│ │ │ │ │ ├── edit.go
│ │ │ │ │ ├── edit_test.go
│ │ │ │ │ ├── editor.go
│ │ │ │ │ ├── editor_test.go
│ │ │ │ │ ├── glob/
│ │ │ │ │ │ ├── glob.go
│ │ │ │ │ │ └── glob_test.go
│ │ │ │ │ ├── proxy.go
│ │ │ │ │ ├── sandbox.go
│ │ │ │ │ ├── workdir.go
│ │ │ │ │ ├── workdir_test.go
│ │ │ │ │ └── workdir_windows.go
│ │ │ │ ├── hover/
│ │ │ │ │ └── hover_test.go
│ │ │ │ ├── inlayhints/
│ │ │ │ │ └── inlayhints_test.go
│ │ │ │ ├── misc/
│ │ │ │ │ ├── addtest_test.go
│ │ │ │ │ ├── call_hierarchy_test.go
│ │ │ │ │ ├── codeactions_test.go
│ │ │ │ │ ├── compileropt_test.go
│ │ │ │ │ ├── configuration_test.go
│ │ │ │ │ ├── debugserver_test.go
│ │ │ │ │ ├── definition_test.go
│ │ │ │ │ ├── embed_test.go
│ │ │ │ │ ├── extract_test.go
│ │ │ │ │ ├── failures_test.go
│ │ │ │ │ ├── filecache_test.go
│ │ │ │ │ ├── fix_test.go
│ │ │ │ │ ├── formatting_test.go
│ │ │ │ │ ├── generate_test.go
│ │ │ │ │ ├── highlight_test.go
│ │ │ │ │ ├── hover_test.go
│ │ │ │ │ ├── import_test.go
│ │ │ │ │ ├── imports_test.go
│ │ │ │ │ ├── link_test.go
│ │ │ │ │ ├── misc_test.go
│ │ │ │ │ ├── modify_tags_test.go
│ │ │ │ │ ├── multiple_adhoc_test.go
│ │ │ │ │ ├── package_symbols_test.go
│ │ │ │ │ ├── prompt_test.go
│ │ │ │ │ ├── references_test.go
│ │ │ │ │ ├── rename_test.go
│ │ │ │ │ ├── semantictokens_test.go
│ │ │ │ │ ├── settings_test.go
│ │ │ │ │ ├── shared_test.go
│ │ │ │ │ ├── signature_help_test.go
│ │ │ │ │ ├── staticcheck_test.go
│ │ │ │ │ ├── test_test.go
│ │ │ │ │ ├── vendor_test.go
│ │ │ │ │ ├── vuln_test.go
│ │ │ │ │ └── workspace_symbol_test.go
│ │ │ │ ├── modfile/
│ │ │ │ │ ├── modfile_test.go
│ │ │ │ │ └── tempmodfile_test.go
│ │ │ │ ├── options.go
│ │ │ │ ├── regtest.go
│ │ │ │ ├── runner.go
│ │ │ │ ├── template/
│ │ │ │ │ └── template_test.go
│ │ │ │ ├── watch/
│ │ │ │ │ ├── setting_test.go
│ │ │ │ │ └── watch_test.go
│ │ │ │ ├── web/
│ │ │ │ │ ├── assembly_test.go
│ │ │ │ │ ├── flight_test.go
│ │ │ │ │ ├── freesymbols_test.go
│ │ │ │ │ ├── pkdoc_test.go
│ │ │ │ │ ├── splitpkg_test.go
│ │ │ │ │ └── util_test.go
│ │ │ │ ├── workspace/
│ │ │ │ │ ├── adhoc_test.go
│ │ │ │ │ ├── broken_test.go
│ │ │ │ │ ├── didcreatefiles_test.go
│ │ │ │ │ ├── directoryfilters_test.go
│ │ │ │ │ ├── fromenv_test.go
│ │ │ │ │ ├── goversion_test.go
│ │ │ │ │ ├── metadata_test.go
│ │ │ │ │ ├── misspelling_test.go
│ │ │ │ │ ├── modules_test.go
│ │ │ │ │ ├── multi_folder_test.go
│ │ │ │ │ ├── packages_test.go
│ │ │ │ │ ├── quickfix_test.go
│ │ │ │ │ ├── standalone_test.go
│ │ │ │ │ ├── std_test.go
│ │ │ │ │ ├── vendor_test.go
│ │ │ │ │ ├── workspace_test.go
│ │ │ │ │ └── zero_config_test.go
│ │ │ │ └── wrappers.go
│ │ │ └── marker/
│ │ │ ├── doc.go
│ │ │ ├── marker_test.go
│ │ │ └── testdata/
│ │ │ ├── callhierarchy/
│ │ │ │ ├── callhierarchy.txt
│ │ │ │ ├── issue64451.txt
│ │ │ │ ├── issue66923.txt
│ │ │ │ └── issue75230.txt
│ │ │ ├── codeaction/
│ │ │ │ ├── add_struct_tags.txt
│ │ │ │ ├── addtest.txt
│ │ │ │ ├── change_quote.txt
│ │ │ │ ├── eliminate_dot_import.txt
│ │ │ │ ├── extract-variadic-63287.txt
│ │ │ │ ├── extract_anonymous_struct.txt
│ │ │ │ ├── extract_control.txt
│ │ │ │ ├── extract_control_label.txt
│ │ │ │ ├── extract_method.txt
│ │ │ │ ├── extract_return_err.txt
│ │ │ │ ├── extract_variable-67905.txt
│ │ │ │ ├── extract_variable-70563.txt
│ │ │ │ ├── extract_variable-if.txt
│ │ │ │ ├── extract_variable-inexact.txt
│ │ │ │ ├── extract_variable-toplevel.txt
│ │ │ │ ├── extract_variable.txt
│ │ │ │ ├── extract_variable_all.txt
│ │ │ │ ├── extract_variable_all_resolve.txt
│ │ │ │ ├── extract_variable_resolve.txt
│ │ │ │ ├── extracttofile.txt
│ │ │ │ ├── failedresolve.txt
│ │ │ │ ├── fill_struct.txt
│ │ │ │ ├── fill_struct_resolve.txt
│ │ │ │ ├── fill_switch.txt
│ │ │ │ ├── fill_switch_resolve.txt
│ │ │ │ ├── functionextraction.txt
│ │ │ │ ├── functionextraction_issue44813.txt
│ │ │ │ ├── functionextraction_issue50851.txt
│ │ │ │ ├── functionextraction_issue66289.txt
│ │ │ │ ├── functionextraction_issue73972.txt
│ │ │ │ ├── grouplines.txt
│ │ │ │ ├── import-shadows-builtin.txt
│ │ │ │ ├── imports-generated.txt
│ │ │ │ ├── imports.txt
│ │ │ │ ├── inline-lhs-var-method.txt
│ │ │ │ ├── inline-lhs-var.txt
│ │ │ │ ├── inline-var-74347.txt
│ │ │ │ ├── inline-var-74347b.txt
│ │ │ │ ├── inline-var-76144.txt
│ │ │ │ ├── inline-var-parens.txt
│ │ │ │ ├── inline-var.txt
│ │ │ │ ├── inline-version.txt
│ │ │ │ ├── inline.txt
│ │ │ │ ├── inline_issue67336.txt
│ │ │ │ ├── inline_issue68554.txt
│ │ │ │ ├── inline_resolve.txt
│ │ │ │ ├── invertif.txt
│ │ │ │ ├── issue64558.txt
│ │ │ │ ├── issue70268.txt
│ │ │ │ ├── moveparam.txt
│ │ │ │ ├── moveparam_issue70599.txt
│ │ │ │ ├── remove_struct_tags.txt
│ │ │ │ ├── removeparam.txt
│ │ │ │ ├── removeparam_formatting.txt
│ │ │ │ ├── removeparam_funcvalue.txt
│ │ │ │ ├── removeparam_imports.txt
│ │ │ │ ├── removeparam_issue65217.txt
│ │ │ │ ├── removeparam_method.txt
│ │ │ │ ├── removeparam_resolve.txt
│ │ │ │ ├── removeparam_satisfies.txt
│ │ │ │ ├── removeparam_witherrs.txt
│ │ │ │ ├── splitlines-variadic.txt
│ │ │ │ └── splitlines.txt
│ │ │ ├── codelens/
│ │ │ │ ├── generate.txt
│ │ │ │ └── test.txt
│ │ │ ├── completion/
│ │ │ │ ├── address.txt
│ │ │ │ ├── alias.txt
│ │ │ │ ├── anon.txt
│ │ │ │ ├── append.txt
│ │ │ │ ├── assign.txt
│ │ │ │ ├── bad.txt
│ │ │ │ ├── basic_lit.txt
│ │ │ │ ├── builtins.txt
│ │ │ │ ├── casesensitive.txt
│ │ │ │ ├── cast.txt
│ │ │ │ ├── channel.txt
│ │ │ │ ├── comment.txt
│ │ │ │ ├── complit.txt
│ │ │ │ ├── constant.txt
│ │ │ │ ├── danglingstmt.txt
│ │ │ │ ├── deep.txt
│ │ │ │ ├── deep2.txt
│ │ │ │ ├── errors.txt
│ │ │ │ ├── field_list.txt
│ │ │ │ ├── foobarbaz.txt
│ │ │ │ ├── func_rank.txt
│ │ │ │ ├── func_sig.txt
│ │ │ │ ├── func_snippets.txt
│ │ │ │ ├── func_value.txt
│ │ │ │ ├── fuzzy.txt
│ │ │ │ ├── imported-std.txt
│ │ │ │ ├── index.txt
│ │ │ │ ├── interfacerank.txt
│ │ │ │ ├── issue51783.txt
│ │ │ │ ├── issue56505.txt
│ │ │ │ ├── issue59096.txt
│ │ │ │ ├── issue60545.txt
│ │ │ │ ├── issue62141.txt
│ │ │ │ ├── issue62560.txt
│ │ │ │ ├── issue62676.txt
│ │ │ │ ├── issue70636.txt
│ │ │ │ ├── issue72753.txt
│ │ │ │ ├── keywords.txt
│ │ │ │ ├── labels.txt
│ │ │ │ ├── lit.txt
│ │ │ │ ├── maps.txt
│ │ │ │ ├── multi_return.txt
│ │ │ │ ├── nested_complit.txt
│ │ │ │ ├── postfix.txt
│ │ │ │ ├── postfix_placeholder.txt
│ │ │ │ ├── printf.txt
│ │ │ │ ├── randv2.txt
│ │ │ │ ├── range_func.txt
│ │ │ │ ├── rank.txt
│ │ │ │ ├── snippet.txt
│ │ │ │ ├── snippet_placeholder.txt
│ │ │ │ ├── statements.txt
│ │ │ │ ├── testy.txt
│ │ │ │ ├── type_assert.txt
│ │ │ │ ├── type_mods.txt
│ │ │ │ ├── type_params.txt
│ │ │ │ ├── type_params_reverse_infer.txt
│ │ │ │ ├── unimported-std.txt
│ │ │ │ ├── unimported.txt
│ │ │ │ ├── unresolved.txt
│ │ │ │ ├── unsafe.txt
│ │ │ │ └── variadic.txt
│ │ │ ├── configuration/
│ │ │ │ └── static.txt
│ │ │ ├── definition/
│ │ │ │ ├── asm.txt
│ │ │ │ ├── branch.txt
│ │ │ │ ├── branch_issue73797.txt
│ │ │ │ ├── branch_issue73797_go124.txt
│ │ │ │ ├── cgo.txt
│ │ │ │ ├── comment.txt
│ │ │ │ ├── embed.txt
│ │ │ │ ├── import.txt
│ │ │ │ ├── misc.txt
│ │ │ │ ├── nearby.txt
│ │ │ │ ├── return.txt
│ │ │ │ ├── standalone.txt
│ │ │ │ └── standalone_issue64557.txt
│ │ │ ├── diagnostics/
│ │ │ │ ├── addgowork.txt
│ │ │ │ ├── analyzers.txt
│ │ │ │ ├── excludedfile.txt
│ │ │ │ ├── generated.txt
│ │ │ │ ├── initcycle.txt
│ │ │ │ ├── issue56943.txt
│ │ │ │ ├── issue59005.txt
│ │ │ │ ├── issue60544.txt
│ │ │ │ ├── issue60605.txt
│ │ │ │ ├── issue64547.txt
│ │ │ │ ├── issue67360.txt
│ │ │ │ ├── issue69505.txt
│ │ │ │ ├── issue70791.txt
│ │ │ │ ├── issue71812.txt
│ │ │ │ ├── osarch_suffix.txt
│ │ │ │ ├── parseerr.txt
│ │ │ │ ├── rundespiteerrors.txt
│ │ │ │ ├── stdversion.txt
│ │ │ │ ├── stdversion_synctest.txt
│ │ │ │ ├── strangefiles.txt
│ │ │ │ ├── typeerr.txt
│ │ │ │ ├── useinternal.txt
│ │ │ │ └── usemodule.txt
│ │ │ ├── fixedbugs/
│ │ │ │ ├── issue59318.txt
│ │ │ │ ├── issue59944.txt
│ │ │ │ ├── issue61543.txt
│ │ │ │ ├── issue66109.txt
│ │ │ │ ├── issue66250.txt
│ │ │ │ ├── issue66876.txt
│ │ │ │ ├── issue71044.txt
│ │ │ │ └── issue74581.txt
│ │ │ ├── foldingrange/
│ │ │ │ ├── a.txt
│ │ │ │ ├── a_lineonly.txt
│ │ │ │ ├── bad.txt
│ │ │ │ └── parse_errors.txt
│ │ │ ├── format/
│ │ │ │ ├── format.txt
│ │ │ │ ├── generated.txt
│ │ │ │ ├── issue59554.txt
│ │ │ │ └── noparse.txt
│ │ │ ├── highlight/
│ │ │ │ ├── controlflow.txt
│ │ │ │ ├── highlight.txt
│ │ │ │ ├── highlight_kind.txt
│ │ │ │ ├── highlight_printf.txt
│ │ │ │ ├── issue60435.txt
│ │ │ │ ├── issue68918.txt
│ │ │ │ └── switchbreak.txt
│ │ │ ├── hover/
│ │ │ │ ├── basiclit.txt
│ │ │ │ ├── comment.txt
│ │ │ │ ├── const.txt
│ │ │ │ ├── embed.txt
│ │ │ │ ├── expression.txt
│ │ │ │ ├── fileuri.txt
│ │ │ │ ├── generics.txt
│ │ │ │ ├── godef.txt
│ │ │ │ ├── goprivate.txt
│ │ │ │ ├── hover-74351.txt
│ │ │ │ ├── hover.txt
│ │ │ │ ├── hover_alias.txt
│ │ │ │ ├── issue74361.txt
│ │ │ │ ├── issue75975.txt
│ │ │ │ ├── issues.txt
│ │ │ │ ├── json.txt
│ │ │ │ ├── linkable.txt
│ │ │ │ ├── linkable_generics.txt
│ │ │ │ ├── linkname.txt
│ │ │ │ ├── methods.txt
│ │ │ │ ├── pointerdoclink.txt
│ │ │ │ ├── return.txt
│ │ │ │ ├── sizeoffset.txt
│ │ │ │ ├── std.txt
│ │ │ │ └── structfield.txt
│ │ │ ├── implementation/
│ │ │ │ ├── basic.txt
│ │ │ │ ├── generics-basicalias.txt
│ │ │ │ ├── generics.txt
│ │ │ │ ├── issue43655.txt
│ │ │ │ ├── issue67041.txt
│ │ │ │ ├── issue68641.txt
│ │ │ │ ├── issue74305.txt
│ │ │ │ └── signature.txt
│ │ │ ├── inlayhints/
│ │ │ │ ├── ignored-error.txt
│ │ │ │ ├── inlayhints.txt
│ │ │ │ └── issue67142.txt
│ │ │ ├── links/
│ │ │ │ └── links.txt
│ │ │ ├── mcptools/
│ │ │ │ ├── context.txt
│ │ │ │ ├── file_context.txt
│ │ │ │ ├── file_diagnostics.txt
│ │ │ │ ├── file_metadata.txt
│ │ │ │ ├── package_api.txt
│ │ │ │ ├── references.txt
│ │ │ │ ├── rename_symbol.txt
│ │ │ │ ├── search.txt
│ │ │ │ ├── symbol_references.txt
│ │ │ │ ├── workspace.txt
│ │ │ │ ├── workspace_diagnostics.txt
│ │ │ │ └── workspace_diagnostics_empty.txt
│ │ │ ├── modfile/
│ │ │ │ ├── godebug.txt
│ │ │ │ └── godebug_bad.txt
│ │ │ ├── quickfix/
│ │ │ │ ├── embeddirective.txt
│ │ │ │ ├── infertypeargs.txt
│ │ │ │ ├── issue65024.txt
│ │ │ │ ├── noresultvalues.txt
│ │ │ │ ├── self_assignment.txt
│ │ │ │ ├── stub.txt
│ │ │ │ ├── stubmethods/
│ │ │ │ │ ├── basic.txt
│ │ │ │ │ ├── basic_resolve.txt
│ │ │ │ │ ├── fromcall_basic.txt
│ │ │ │ │ ├── fromcall_params.txt
│ │ │ │ │ ├── fromcall_returns.txt
│ │ │ │ │ ├── issue61693.txt
│ │ │ │ │ ├── issue61830.txt
│ │ │ │ │ ├── issue64078.txt
│ │ │ │ │ ├── issue64114.txt
│ │ │ │ │ ├── shadowedmethods.txt
│ │ │ │ │ └── stuberrors.txt
│ │ │ │ ├── undeclared/
│ │ │ │ │ ├── diag.txt
│ │ │ │ │ ├── missingfunction.txt
│ │ │ │ │ ├── undeclared_variable.txt
│ │ │ │ │ └── undeclaredfunc.txt
│ │ │ │ ├── unusedrequire.txt
│ │ │ │ └── unusedrequire_gowork.txt
│ │ │ ├── references/
│ │ │ │ ├── crosspackage.txt
│ │ │ │ ├── imports.txt
│ │ │ │ ├── interfaces.txt
│ │ │ │ ├── intrapackage.txt
│ │ │ │ ├── issue58506.txt
│ │ │ │ ├── issue59851.txt
│ │ │ │ ├── issue60369.txt
│ │ │ │ ├── issue60622.txt
│ │ │ │ ├── issue60676.txt
│ │ │ │ ├── issue61618.txt
│ │ │ │ ├── issue67978.txt
│ │ │ │ ├── issue75810.txt
│ │ │ │ ├── issue75810A.txt
│ │ │ │ ├── issue76872.txt
│ │ │ │ ├── shadow.txt
│ │ │ │ ├── test.txt
│ │ │ │ └── typeswitch.txt
│ │ │ ├── rename/
│ │ │ │ ├── bad.txt
│ │ │ │ ├── basic.txt
│ │ │ │ ├── conflict.txt
│ │ │ │ ├── crosspkg.txt
│ │ │ │ ├── doclink.txt
│ │ │ │ ├── embed.txt
│ │ │ │ ├── func.txt
│ │ │ │ ├── generics.txt
│ │ │ │ ├── generics_basic.txt
│ │ │ │ ├── issue39614.txt
│ │ │ │ ├── issue42134.txt
│ │ │ │ ├── issue42301.txt
│ │ │ │ ├── issue43616.txt
│ │ │ │ ├── issue57479.txt
│ │ │ │ ├── issue60752.txt
│ │ │ │ ├── issue60789.txt
│ │ │ │ ├── issue61294.txt
│ │ │ │ ├── issue61640.txt
│ │ │ │ ├── issue61813.txt
│ │ │ │ ├── issue65098.txt
│ │ │ │ ├── issue67069.txt
│ │ │ │ ├── issue70968.txt
│ │ │ │ ├── methods.txt
│ │ │ │ ├── packagedecl.txt
│ │ │ │ ├── pkgpath.txt
│ │ │ │ ├── prepare.txt
│ │ │ │ ├── prepare_func.txt
│ │ │ │ ├── prepare_move.txt
│ │ │ │ ├── random.txt
│ │ │ │ ├── recv.txt
│ │ │ │ ├── shadow.txt
│ │ │ │ ├── testy.txt
│ │ │ │ ├── typeswitch.txt
│ │ │ │ └── unexported.txt
│ │ │ ├── selectionrange/
│ │ │ │ └── selectionrange.txt
│ │ │ ├── signature/
│ │ │ │ ├── generic.txt
│ │ │ │ ├── issue63804.txt
│ │ │ │ ├── issue69552.txt
│ │ │ │ └── signature.txt
│ │ │ ├── symbol/
│ │ │ │ ├── basic.txt
│ │ │ │ └── generic.txt
│ │ │ ├── token/
│ │ │ │ ├── comment.txt
│ │ │ │ ├── format.txt
│ │ │ │ ├── illformed.txt
│ │ │ │ ├── issue66809.txt
│ │ │ │ ├── issue70251.txt
│ │ │ │ ├── modifiers.txt
│ │ │ │ └── range.txt
│ │ │ ├── typedef/
│ │ │ │ ├── expression.txt
│ │ │ │ ├── issue60544.txt
│ │ │ │ └── typedef.txt
│ │ │ ├── typehierarchy/
│ │ │ │ └── basic.txt
│ │ │ ├── workfile/
│ │ │ │ ├── godebug.txt
│ │ │ │ └── godebug_bad.txt
│ │ │ ├── workspacesymbol/
│ │ │ │ ├── allscope.txt
│ │ │ │ ├── caseinsensitive.txt
│ │ │ │ ├── casesensitive.txt
│ │ │ │ ├── issue44806.txt
│ │ │ │ ├── workspacesymbol.txt
│ │ │ │ └── wsscope.txt
│ │ │ └── zeroconfig/
│ │ │ ├── adhoc.txt
│ │ │ ├── dynamicports.txt
│ │ │ ├── nested.txt
│ │ │ └── nonworkspacemodule.txt
│ │ ├── util/
│ │ │ ├── README.md
│ │ │ ├── asm/
│ │ │ │ ├── parse.go
│ │ │ │ └── parse_test.go
│ │ │ ├── browser/
│ │ │ │ ├── README.md
│ │ │ │ └── browser.go
│ │ │ ├── bug/
│ │ │ │ ├── bug.go
│ │ │ │ └── bug_test.go
│ │ │ ├── constraints/
│ │ │ │ └── constraint.go
│ │ │ ├── cursorutil/
│ │ │ │ └── util.go
│ │ │ ├── fakenet/
│ │ │ │ └── conn.go
│ │ │ ├── fingerprint/
│ │ │ │ ├── fingerprint.go
│ │ │ │ └── fingerprint_test.go
│ │ │ ├── frob/
│ │ │ │ ├── frob.go
│ │ │ │ └── frob_test.go
│ │ │ ├── goversion/
│ │ │ │ ├── goversion.go
│ │ │ │ └── goversion_test.go
│ │ │ ├── immutable/
│ │ │ │ └── immutable.go
│ │ │ ├── lru/
│ │ │ │ ├── lru.go
│ │ │ │ ├── lru_fuzz_test.go
│ │ │ │ ├── lru_nil_test.go
│ │ │ │ └── lru_test.go
│ │ │ ├── memoize/
│ │ │ │ ├── memoize.go
│ │ │ │ └── memoize_test.go
│ │ │ ├── moremaps/
│ │ │ │ └── maps.go
│ │ │ ├── moreslices/
│ │ │ │ └── slices.go
│ │ │ ├── morestrings/
│ │ │ │ └── strings.go
│ │ │ ├── pathutil/
│ │ │ │ └── util.go
│ │ │ ├── persistent/
│ │ │ │ ├── map.go
│ │ │ │ ├── map_test.go
│ │ │ │ ├── race_test.go
│ │ │ │ ├── set.go
│ │ │ │ └── set_test.go
│ │ │ ├── safetoken/
│ │ │ │ ├── safetoken.go
│ │ │ │ └── safetoken_test.go
│ │ │ ├── tokeninternal/
│ │ │ │ └── tokeninternal.go
│ │ │ └── typesutil/
│ │ │ └── typesutil.go
│ │ ├── version/
│ │ │ └── version.go
│ │ ├── vulncheck/
│ │ │ ├── copier.go
│ │ │ ├── govulncheck/
│ │ │ │ ├── govulncheck.go
│ │ │ │ ├── handler.go
│ │ │ │ └── jsonhandler.go
│ │ │ ├── osv/
│ │ │ │ └── osv.go
│ │ │ ├── scan/
│ │ │ │ └── command.go
│ │ │ ├── semver/
│ │ │ │ ├── semver.go
│ │ │ │ └── semver_test.go
│ │ │ ├── types.go
│ │ │ └── vulntest/
│ │ │ ├── db.go
│ │ │ ├── db_test.go
│ │ │ ├── report.go
│ │ │ ├── report_test.go
│ │ │ ├── stdlib.go
│ │ │ ├── stdlib_test.go
│ │ │ └── testdata/
│ │ │ ├── GO-2020-0001.json
│ │ │ └── report.yaml
│ │ └── work/
│ │ ├── completion.go
│ │ ├── diagnostics.go
│ │ ├── format.go
│ │ └── hover.go
│ └── main.go
├── imports/
│ └── forward.go
├── internal/
│ ├── aliases/
│ │ ├── aliases.go
│ │ └── aliases_test.go
│ ├── analysis/
│ │ ├── README
│ │ ├── analyzerutil/
│ │ │ ├── doc.go
│ │ │ ├── extractdoc.go
│ │ │ ├── extractdoc_test.go
│ │ │ ├── readfile.go
│ │ │ └── version.go
│ │ ├── driverutil/
│ │ │ ├── fix.go
│ │ │ ├── print.go
│ │ │ ├── readfile.go
│ │ │ ├── url.go
│ │ │ ├── url_test.go
│ │ │ └── validatefix.go
│ │ ├── generated/
│ │ │ └── generated.go
│ │ └── typeindex/
│ │ └── typeindex.go
│ ├── astutil/
│ │ ├── clone.go
│ │ ├── comment.go
│ │ ├── comment_test.go
│ │ ├── equal.go
│ │ ├── fields.go
│ │ ├── fields_test.go
│ │ ├── free/
│ │ │ ├── free.go
│ │ │ └── free_test.go
│ │ ├── purge.go
│ │ ├── purge_test.go
│ │ ├── stringlit.go
│ │ ├── stringlit_test.go
│ │ ├── unpack.go
│ │ └── util.go
│ ├── bisect/
│ │ ├── bisect.go
│ │ └── bisect_test.go
│ ├── diff/
│ │ ├── diff.go
│ │ ├── diff_test.go
│ │ ├── difftest/
│ │ │ ├── difftest.go
│ │ │ └── difftest_test.go
│ │ ├── export_test.go
│ │ ├── lcs/
│ │ │ ├── common.go
│ │ │ ├── common_test.go
│ │ │ ├── doc.go
│ │ │ ├── git.sh
│ │ │ ├── labels.go
│ │ │ ├── old.go
│ │ │ ├── old_test.go
│ │ │ └── sequence.go
│ │ ├── merge.go
│ │ ├── merge_test.go
│ │ ├── ndiff.go
│ │ └── unified.go
│ ├── diffp/
│ │ ├── diff.go
│ │ ├── diff_test.go
│ │ └── testdata/
│ │ ├── allnew.txt
│ │ ├── allold.txt
│ │ ├── basic.txt
│ │ ├── dups.txt
│ │ ├── end.txt
│ │ ├── eof.txt
│ │ ├── eof1.txt
│ │ ├── eof2.txt
│ │ ├── long.txt
│ │ ├── same.txt
│ │ ├── start.txt
│ │ └── triv.txt
│ ├── drivertest/
│ │ ├── driver.go
│ │ └── driver_test.go
│ ├── edit/
│ │ ├── edit.go
│ │ └── edit_test.go
│ ├── event/
│ │ ├── bench_test.go
│ │ ├── core/
│ │ │ ├── event.go
│ │ │ ├── export.go
│ │ │ └── fast.go
│ │ ├── doc.go
│ │ ├── event.go
│ │ ├── export/
│ │ │ ├── eventtest/
│ │ │ │ └── eventtest.go
│ │ │ ├── id.go
│ │ │ ├── labels.go
│ │ │ ├── log.go
│ │ │ ├── log_test.go
│ │ │ ├── metric/
│ │ │ │ ├── data.go
│ │ │ │ ├── exporter.go
│ │ │ │ └── info.go
│ │ │ ├── otel/
│ │ │ │ ├── common.go
│ │ │ │ ├── metrics.go
│ │ │ │ ├── metrics_test.go
│ │ │ │ ├── options.go
│ │ │ │ ├── otel.go
│ │ │ │ ├── otel_test.go
│ │ │ │ ├── otlp.go
│ │ │ │ ├── traces.go
│ │ │ │ └── traces_test.go
│ │ │ ├── printer.go
│ │ │ ├── prometheus/
│ │ │ │ └── prometheus.go
│ │ │ └── trace.go
│ │ ├── keys/
│ │ │ ├── keys.go
│ │ │ ├── standard.go
│ │ │ ├── util.go
│ │ │ └── util_test.go
│ │ └── label/
│ │ ├── label.go
│ │ └── label_test.go
│ ├── expect/
│ │ ├── expect.go
│ │ ├── expect_test.go
│ │ ├── extract.go
│ │ └── testdata/
│ │ ├── go.fake.mod
│ │ ├── go.fake.work
│ │ └── test.go
│ ├── facts/
│ │ ├── facts.go
│ │ ├── facts_test.go
│ │ └── imports.go
│ ├── fmtstr/
│ │ ├── main.go
│ │ └── parse.go
│ ├── gcimporter/
│ │ ├── bexport_test.go
│ │ ├── bimport.go
│ │ ├── exportdata.go
│ │ ├── gcimporter.go
│ │ ├── gcimporter_test.go
│ │ ├── iexport.go
│ │ ├── iexport_common_test.go
│ │ ├── iexport_go118_test.go
│ │ ├── iexport_test.go
│ │ ├── iimport.go
│ │ ├── israce_test.go
│ │ ├── main.go
│ │ ├── predeclared.go
│ │ ├── shallow_test.go
│ │ ├── stdlib_test.go
│ │ ├── support.go
│ │ ├── testdata/
│ │ │ ├── a/
│ │ │ │ └── a.go
│ │ │ ├── a.go
│ │ │ ├── aliases/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── b.go
│ │ │ ├── exports.go
│ │ │ ├── issue15920.go
│ │ │ ├── issue20046.go
│ │ │ ├── issue25301.go
│ │ │ ├── issue51836/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── a.go
│ │ │ │ └── aa.go
│ │ │ ├── issue57015.go
│ │ │ ├── issue58296/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── p.go
│ │ │ └── versions/
│ │ │ ├── test.go
│ │ │ └── test_go1.20_u.a
│ │ └── ureader_yes.go
│ ├── gocommand/
│ │ ├── invoke.go
│ │ ├── invoke_notunix.go
│ │ ├── invoke_test.go
│ │ ├── invoke_unix.go
│ │ ├── vendor.go
│ │ ├── version.go
│ │ └── version_test.go
│ ├── gopathwalk/
│ │ ├── walk.go
│ │ └── walk_test.go
│ ├── goplsexport/
│ │ └── export.go
│ ├── goroot/
│ │ └── importcfg.go
│ ├── imports/
│ │ ├── fix.go
│ │ ├── fix_test.go
│ │ ├── imports.go
│ │ ├── imports_test.go
│ │ ├── mkindex.go
│ │ ├── mod.go
│ │ ├── mod_cache.go
│ │ ├── mod_cache_test.go
│ │ ├── mod_test.go
│ │ ├── sortimports.go
│ │ ├── source.go
│ │ ├── source_env.go
│ │ ├── source_modindex.go
│ │ ├── sourcex_test.go
│ │ └── testdata/
│ │ └── mod/
│ │ ├── example.com_v1.0.0.txt
│ │ ├── golang.org_x_text_v0.0.0-20170915032832-14c0d48ead0c.txt
│ │ ├── rsc.io_!q!u!o!t!e_v1.5.2.txt
│ │ ├── rsc.io_!q!u!o!t!e_v1.5.3-!p!r!e.txt
│ │ ├── rsc.io_quote_v1.5.1.txt
│ │ ├── rsc.io_quote_v1.5.2.txt
│ │ ├── rsc.io_quote_v2_v2.0.1.txt
│ │ ├── rsc.io_quote_v3_v3.0.0.txt
│ │ ├── rsc.io_sampler_v1.3.0.txt
│ │ └── rsc.io_sampler_v1.3.1.txt
│ ├── jsonrpc2/
│ │ ├── conn.go
│ │ ├── handler.go
│ │ ├── jsonrpc2.go
│ │ ├── jsonrpc2_test.go
│ │ ├── labels.go
│ │ ├── messages.go
│ │ ├── serve.go
│ │ ├── serve_test.go
│ │ ├── servertest/
│ │ │ ├── servertest.go
│ │ │ └── servertest_test.go
│ │ ├── stack/
│ │ │ ├── parse.go
│ │ │ ├── process.go
│ │ │ ├── stack.go
│ │ │ ├── stack_test.go
│ │ │ └── stacktest/
│ │ │ └── stacktest.go
│ │ ├── stream.go
│ │ ├── wire.go
│ │ └── wire_test.go
│ ├── jsonrpc2_v2/
│ │ ├── conn.go
│ │ ├── frame.go
│ │ ├── jsonrpc2.go
│ │ ├── jsonrpc2_test.go
│ │ ├── messages.go
│ │ ├── net.go
│ │ ├── serve.go
│ │ ├── serve_test.go
│ │ ├── wire.go
│ │ └── wire_test.go
│ ├── mcp/
│ │ ├── CONTRIBUTING.md
│ │ ├── README.md
│ │ ├── client.go
│ │ ├── client_list_test.go
│ │ ├── client_test.go
│ │ ├── cmd.go
│ │ ├── cmd_test.go
│ │ ├── conformance_go124_test.go
│ │ ├── conformance_go125_test.go
│ │ ├── conformance_test.go
│ │ ├── content.go
│ │ ├── content_test.go
│ │ ├── create-repo.sh
│ │ ├── design/
│ │ │ └── design.md
│ │ ├── example_progress_test.go
│ │ ├── examples/
│ │ │ ├── hello/
│ │ │ │ └── main.go
│ │ │ └── sse/
│ │ │ └── main.go
│ │ ├── features.go
│ │ ├── features_test.go
│ │ ├── generate.go
│ │ ├── internal/
│ │ │ ├── oauthex/
│ │ │ │ ├── oauth2.go
│ │ │ │ ├── oauth2_test.go
│ │ │ │ └── resource_meta.go
│ │ │ ├── readme/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.src.md
│ │ │ │ ├── build.sh
│ │ │ │ ├── client/
│ │ │ │ │ └── client.go
│ │ │ │ └── server/
│ │ │ │ └── server.go
│ │ │ └── util/
│ │ │ ├── util.go
│ │ │ └── util_test.go
│ │ ├── jsonschema/
│ │ │ ├── annotations.go
│ │ │ ├── doc.go
│ │ │ ├── infer.go
│ │ │ ├── infer_test.go
│ │ │ ├── json_pointer.go
│ │ │ ├── json_pointer_test.go
│ │ │ ├── meta-schemas/
│ │ │ │ └── draft2020-12/
│ │ │ │ ├── meta/
│ │ │ │ │ ├── applicator.json
│ │ │ │ │ ├── content.json
│ │ │ │ │ ├── core.json
│ │ │ │ │ ├── format-annotation.json
│ │ │ │ │ ├── meta-data.json
│ │ │ │ │ ├── unevaluated.json
│ │ │ │ │ └── validation.json
│ │ │ │ └── schema.json
│ │ │ ├── resolve.go
│ │ │ ├── resolve_test.go
│ │ │ ├── schema.go
│ │ │ ├── schema_test.go
│ │ │ ├── testdata/
│ │ │ │ ├── draft2020-12/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── additionalProperties.json
│ │ │ │ │ ├── allOf.json
│ │ │ │ │ ├── anchor.json
│ │ │ │ │ ├── anyOf.json
│ │ │ │ │ ├── boolean_schema.json
│ │ │ │ │ ├── const.json
│ │ │ │ │ ├── contains.json
│ │ │ │ │ ├── default.json
│ │ │ │ │ ├── defs.json
│ │ │ │ │ ├── dependentRequired.json
│ │ │ │ │ ├── dependentSchemas.json
│ │ │ │ │ ├── dynamicRef.json
│ │ │ │ │ ├── enum.json
│ │ │ │ │ ├── exclusiveMaximum.json
│ │ │ │ │ ├── exclusiveMinimum.json
│ │ │ │ │ ├── if-then-else.json
│ │ │ │ │ ├── infinite-loop-detection.json
│ │ │ │ │ ├── items.json
│ │ │ │ │ ├── maxContains.json
│ │ │ │ │ ├── maxItems.json
│ │ │ │ │ ├── maxLength.json
│ │ │ │ │ ├── maxProperties.json
│ │ │ │ │ ├── maximum.json
│ │ │ │ │ ├── minContains.json
│ │ │ │ │ ├── minItems.json
│ │ │ │ │ ├── minLength.json
│ │ │ │ │ ├── minProperties.json
│ │ │ │ │ ├── minimum.json
│ │ │ │ │ ├── multipleOf.json
│ │ │ │ │ ├── not.json
│ │ │ │ │ ├── oneOf.json
│ │ │ │ │ ├── pattern.json
│ │ │ │ │ ├── patternProperties.json
│ │ │ │ │ ├── prefixItems.json
│ │ │ │ │ ├── properties.json
│ │ │ │ │ ├── propertyNames.json
│ │ │ │ │ ├── ref.json
│ │ │ │ │ ├── refRemote.json
│ │ │ │ │ ├── required.json
│ │ │ │ │ ├── type.json
│ │ │ │ │ ├── unevaluatedItems.json
│ │ │ │ │ ├── unevaluatedProperties.json
│ │ │ │ │ └── uniqueItems.json
│ │ │ │ └── remotes/
│ │ │ │ ├── README.md
│ │ │ │ ├── different-id-ref-string.json
│ │ │ │ ├── draft2020-12/
│ │ │ │ │ ├── baseUriChange/
│ │ │ │ │ │ └── folderInteger.json
│ │ │ │ │ ├── baseUriChangeFolder/
│ │ │ │ │ │ └── folderInteger.json
│ │ │ │ │ ├── baseUriChangeFolderInSubschema/
│ │ │ │ │ │ └── folderInteger.json
│ │ │ │ │ ├── detached-dynamicref.json
│ │ │ │ │ ├── detached-ref.json
│ │ │ │ │ ├── extendible-dynamic-ref.json
│ │ │ │ │ ├── format-assertion-false.json
│ │ │ │ │ ├── format-assertion-true.json
│ │ │ │ │ ├── integer.json
│ │ │ │ │ ├── locationIndependentIdentifier.json
│ │ │ │ │ ├── metaschema-no-validation.json
│ │ │ │ │ ├── metaschema-optional-vocabulary.json
│ │ │ │ │ ├── name-defs.json
│ │ │ │ │ ├── nested/
│ │ │ │ │ │ ├── foo-ref-string.json
│ │ │ │ │ │ └── string.json
│ │ │ │ │ ├── prefixItems.json
│ │ │ │ │ ├── ref-and-defs.json
│ │ │ │ │ ├── subSchemas.json
│ │ │ │ │ └── tree.json
│ │ │ │ ├── nested-absolute-ref-to-string.json
│ │ │ │ └── urn-ref-string.json
│ │ │ ├── util.go
│ │ │ ├── util_test.go
│ │ │ ├── validate.go
│ │ │ └── validate_test.go
│ │ ├── logging.go
│ │ ├── mcp-repo-replace.txt
│ │ ├── mcp.go
│ │ ├── mcp_test.go
│ │ ├── prompt.go
│ │ ├── protocol.go
│ │ ├── resource.go
│ │ ├── resource_test.go
│ │ ├── root.go
│ │ ├── server.go
│ │ ├── server_example_test.go
│ │ ├── server_test.go
│ │ ├── shared.go
│ │ ├── shared_test.go
│ │ ├── sse.go
│ │ ├── sse_example_test.go
│ │ ├── sse_test.go
│ │ ├── streamable.go
│ │ ├── streamable_test.go
│ │ ├── testdata/
│ │ │ ├── conformance/
│ │ │ │ └── server/
│ │ │ │ ├── prompts.txtar
│ │ │ │ ├── resources.txtar
│ │ │ │ ├── tools.txtar
│ │ │ │ ├── version-latest.txtar
│ │ │ │ └── version-older.txtar
│ │ │ ├── files/
│ │ │ │ ├── info.txt
│ │ │ │ └── template.txt
│ │ │ ├── private.txt
│ │ │ └── public/
│ │ │ ├── dir/
│ │ │ │ └── file3.txt
│ │ │ ├── file1.txt
│ │ │ └── file2.txt
│ │ ├── tool.go
│ │ ├── tool_test.go
│ │ ├── transport.go
│ │ ├── transport_test.go
│ │ ├── util.go
│ │ └── util_test.go
│ ├── modindex/
│ │ ├── dir_test.go
│ │ ├── directories.go
│ │ ├── export_test.go
│ │ ├── gomodindex/
│ │ │ └── cmd.go
│ │ ├── index.go
│ │ ├── lookup.go
│ │ ├── lookup_test.go
│ │ ├── modindex.go
│ │ └── symbols.go
│ ├── moreiters/
│ │ └── iters.go
│ ├── packagepath/
│ │ ├── packagepath.go
│ │ └── packagepath_test.go
│ ├── packagesinternal/
│ │ └── packages.go
│ ├── packagestest/
│ │ ├── expect.go
│ │ ├── expect_test.go
│ │ ├── export.go
│ │ ├── export_test.go
│ │ ├── gopath.go
│ │ ├── gopath_test.go
│ │ ├── modules.go
│ │ ├── modules_test.go
│ │ └── testdata/
│ │ ├── groups/
│ │ │ ├── one/
│ │ │ │ ├── modules/
│ │ │ │ │ └── example.com/
│ │ │ │ │ └── extra/
│ │ │ │ │ └── help.go
│ │ │ │ └── primarymod/
│ │ │ │ └── main.go
│ │ │ └── two/
│ │ │ ├── modules/
│ │ │ │ └── example.com/
│ │ │ │ ├── extra/
│ │ │ │ │ ├── geez/
│ │ │ │ │ │ └── help.go
│ │ │ │ │ ├── v2/
│ │ │ │ │ │ ├── geez/
│ │ │ │ │ │ │ └── help.go
│ │ │ │ │ │ └── me.go
│ │ │ │ │ └── yo.go
│ │ │ │ ├── tempmod/
│ │ │ │ │ └── main.go
│ │ │ │ ├── what@v1.0.0/
│ │ │ │ │ └── main.go
│ │ │ │ └── what@v1.1.0/
│ │ │ │ └── main.go
│ │ │ └── primarymod/
│ │ │ ├── expect/
│ │ │ │ ├── yo.go
│ │ │ │ └── yo_test.go
│ │ │ └── main.go
│ │ ├── test.go
│ │ ├── test_test.go
│ │ └── x_test.go
│ ├── pkgbits/
│ │ ├── codes.go
│ │ ├── decoder.go
│ │ ├── doc.go
│ │ ├── encoder.go
│ │ ├── flags.go
│ │ ├── pkgbits_test.go
│ │ ├── reloc.go
│ │ ├── support.go
│ │ ├── sync.go
│ │ ├── syncmarker_string.go
│ │ └── version.go
│ ├── pprof/
│ │ ├── main.go
│ │ ├── pprof.go
│ │ ├── pprof_test.go
│ │ └── testdata/
│ │ └── sample.pprof
│ ├── proxydir/
│ │ ├── proxydir.go
│ │ └── proxydir_test.go
│ ├── refactor/
│ │ ├── delete.go
│ │ ├── delete_test.go
│ │ ├── edit.go
│ │ ├── imports.go
│ │ ├── imports_test.go
│ │ ├── inline/
│ │ │ ├── callee.go
│ │ │ ├── calleefx.go
│ │ │ ├── calleefx_test.go
│ │ │ ├── doc.go
│ │ │ ├── escape.go
│ │ │ ├── everything_test.go
│ │ │ ├── export_test.go
│ │ │ ├── falcon.go
│ │ │ ├── falcon_test.go
│ │ │ ├── inline.go
│ │ │ ├── inline_test.go
│ │ │ ├── testdata/
│ │ │ │ ├── assignment-splice.txtar
│ │ │ │ ├── assignment.txtar
│ │ │ │ ├── basic-err.txtar
│ │ │ │ ├── basic-literal.txtar
│ │ │ │ ├── basic-reduce.txtar
│ │ │ │ ├── cgo.txtar
│ │ │ │ ├── comments.txtar
│ │ │ │ ├── crosspkg-selfref.txtar
│ │ │ │ ├── crosspkg.txtar
│ │ │ │ ├── dotimport.txtar
│ │ │ │ ├── embed.txtar
│ │ │ │ ├── empty-body.txtar
│ │ │ │ ├── err-basic.txtar
│ │ │ │ ├── err-shadow-builtin.txtar
│ │ │ │ ├── err-shadow-pkg.txtar
│ │ │ │ ├── err-unexported.txtar
│ │ │ │ ├── exprstmt.txtar
│ │ │ │ ├── generic.txtar
│ │ │ │ ├── import-comments.txtar
│ │ │ │ ├── import-comments2.txtar
│ │ │ │ ├── import-preserve-local-pkgname.txtar
│ │ │ │ ├── import-rename.txtar
│ │ │ │ ├── import-shadow-1.txtar
│ │ │ │ ├── import-shadow-2.txtar
│ │ │ │ ├── import-shadow.txtar
│ │ │ │ ├── internal.txtar
│ │ │ │ ├── issue62667.txtar
│ │ │ │ ├── issue63298.txtar
│ │ │ │ ├── issue69441.txtar
│ │ │ │ ├── issue69442.txtar
│ │ │ │ ├── line-directives.txtar
│ │ │ │ ├── method.txtar
│ │ │ │ ├── multistmt-body.txtar
│ │ │ │ ├── n-ary.txtar
│ │ │ │ ├── newexpr.txtar
│ │ │ │ ├── param-subst.txtar
│ │ │ │ ├── revdotimport.txtar
│ │ │ │ ├── std-internal.txtar
│ │ │ │ ├── substgroups.txtar
│ │ │ │ └── tailcall.txtar
│ │ │ └── util.go
│ │ └── refactor.go
│ ├── robustio/
│ │ ├── copyfiles.go
│ │ ├── gopls_windows.go
│ │ ├── robustio.go
│ │ ├── robustio_darwin.go
│ │ ├── robustio_flaky.go
│ │ ├── robustio_other.go
│ │ ├── robustio_plan9.go
│ │ ├── robustio_posix.go
│ │ ├── robustio_test.go
│ │ └── robustio_windows.go
│ ├── stdlib/
│ │ ├── deps.go
│ │ ├── deps_test.go
│ │ ├── generate.go
│ │ ├── import.go
│ │ ├── manifest.go
│ │ ├── stdlib.go
│ │ └── testdata/
│ │ ├── nethttp.deps
│ │ └── nethttp.imports
│ ├── testenv/
│ │ ├── exec.go
│ │ ├── testenv.go
│ │ ├── testenv_notunix.go
│ │ └── testenv_unix.go
│ ├── testfiles/
│ │ ├── testdata/
│ │ │ ├── somefile.txt
│ │ │ └── versions/
│ │ │ ├── go.mod.test
│ │ │ ├── mod.go
│ │ │ ├── post.go
│ │ │ ├── pre.go
│ │ │ └── sub.test/
│ │ │ └── sub.go.test
│ │ ├── testfiles.go
│ │ └── testfiles_test.go
│ ├── tool/
│ │ └── tool.go
│ ├── typeparams/
│ │ ├── common.go
│ │ ├── common_test.go
│ │ ├── copytermlist.go
│ │ ├── coretype.go
│ │ ├── coretype_test.go
│ │ ├── free.go
│ │ ├── free_test.go
│ │ ├── genericfeatures/
│ │ │ └── features.go
│ │ ├── normalize.go
│ │ ├── normalize_test.go
│ │ ├── termlist.go
│ │ └── typeterm.go
│ ├── typesinternal/
│ │ ├── classify_call.go
│ │ ├── classify_call_test.go
│ │ ├── element.go
│ │ ├── element_test.go
│ │ ├── errorcode.go
│ │ ├── errorcode_string.go
│ │ ├── errorcode_test.go
│ │ ├── fx.go
│ │ ├── fx_test.go
│ │ ├── isnamed.go
│ │ ├── qualifier.go
│ │ ├── recv.go
│ │ ├── toonew.go
│ │ ├── typeindex/
│ │ │ ├── typeindex.go
│ │ │ └── typeindex_test.go
│ │ ├── types.go
│ │ ├── varkind.go
│ │ ├── varkind_go124.go
│ │ ├── zerovalue.go
│ │ └── zerovalue_test.go
│ ├── versions/
│ │ ├── features.go
│ │ ├── gover.go
│ │ ├── types.go
│ │ ├── types_test.go
│ │ ├── versions.go
│ │ └── versions_test.go
│ └── xcontext/
│ └── xcontext.go
├── playground/
│ ├── playground.go
│ └── socket/
│ ├── socket.go
│ └── socket_test.go
├── present/
│ ├── args.go
│ ├── caption.go
│ ├── code.go
│ ├── code_test.go
│ ├── doc.go
│ ├── html.go
│ ├── iframe.go
│ ├── image.go
│ ├── link.go
│ ├── link_test.go
│ ├── parse.go
│ ├── parse_test.go
│ ├── style.go
│ ├── style_test.go
│ ├── testdata/
│ │ ├── README
│ │ ├── basic.md
│ │ ├── basic.p
│ │ ├── code.md
│ │ ├── code.p
│ │ ├── code.txt
│ │ ├── list.md
│ │ ├── list.p
│ │ ├── media.html
│ │ ├── media.md
│ │ ├── media.p
│ │ ├── pre.md
│ │ └── pre.p
│ └── video.go
├── refactor/
│ ├── README
│ ├── eg/
│ │ ├── eg.go
│ │ ├── eg_test.go
│ │ ├── match.go
│ │ ├── rewrite.go
│ │ └── testdata/
│ │ ├── a.txtar
│ │ ├── b.txtar
│ │ ├── bad_type.txtar
│ │ ├── c.txtar
│ │ ├── d.txtar
│ │ ├── e.txtar
│ │ ├── expr_type_mismatch.txtar
│ │ ├── f.txtar
│ │ ├── g.txtar
│ │ ├── h.txtar
│ │ ├── i.txtar
│ │ ├── j.txtar
│ │ ├── no_after_return.txtar
│ │ ├── no_before.txtar
│ │ └── type_mismatch.txtar
│ ├── importgraph/
│ │ ├── graph.go
│ │ └── graph_test.go
│ ├── rename/
│ │ ├── check.go
│ │ ├── mvpkg.go
│ │ ├── mvpkg_test.go
│ │ ├── rename.go
│ │ ├── rename_test.go
│ │ ├── spec.go
│ │ └── util.go
│ └── satisfy/
│ ├── find.go
│ └── find_test.go
└── txtar/
├── archive.go
├── archive_test.go
├── fs.go
└── fs_test.go
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
# Treat all files in this repo as binary, with no git magic updating
# line endings. Windows users contributing to Go will need to use a
# modern version of git and editors capable of LF line endings.
#
# We'll prevent accidental CRLF line endings from entering the repo
# via the git-review gofmt checks.
#
# See golang.org/issue/9281
* -text
================================================
FILE: .gitignore
================================================
# Add no patterns to .gitignore except for files generated by the build.
last-change
================================================
FILE: .prettierrc
================================================
{
"singleQuote": true,
"trailingComma": "es5"
}
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to Go
Go is an open source project.
It is the work of hundreds of contributors. We appreciate your help!
## Filing issues
When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions:
1. What version of Go are you using (`go version`)?
2. What operating system and processor architecture are you using?
3. What did you do?
4. What did you expect to see?
5. What did you see instead?
General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
The gophers there will answer or ask you to file an issue if you've tripped over a bug.
## Contributing code
Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
before sending patches.
Unless otherwise noted, the Go source files are distributed under
the BSD-style license found in the LICENSE file.
================================================
FILE: LICENSE
================================================
Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: PATENTS
================================================
Additional IP Rights Grant (Patents)
"This implementation" means the copyrightable works distributed by
Google as part of the Go project.
Google hereby grants to You a perpetual, worldwide, non-exclusive,
no-charge, royalty-free, irrevocable (except as stated in this section)
patent license to make, have made, use, offer to sell, sell, import,
transfer and otherwise run, modify and propagate the contents of this
implementation of Go, where such license applies only to those patent
claims, both currently owned or controlled by Google and acquired in
the future, licensable by Google that are necessarily infringed by this
implementation of Go. This grant does not include claims that would be
infringed only as a consequence of further modification of this
implementation. If you or your agent or exclusive licensee institute or
order or agree to the institution of patent litigation against any
entity (including a cross-claim or counterclaim in a lawsuit) alleging
that this implementation of Go or any code incorporated within this
implementation of Go constitutes direct or contributory patent
infringement, or inducement of patent infringement, then any patent
rights granted to you under this License for this implementation of Go
shall terminate as of the date such litigation is filed.
================================================
FILE: README.md
================================================
# Go Tools
[](https://pkg.go.dev/golang.org/x/tools)
This repository provides the `golang.org/x/tools` module, comprising
various tools and packages mostly for static analysis of Go programs,
some of which are listed below.
Use the "Go reference" link above for more information about any package.
It also contains the
[`golang.org/x/tools/gopls`](https://pkg.go.dev/golang.org/x/tools/gopls)
module, whose root package is a language-server protocol (LSP) server for Go.
An LSP server analyses the source code of a project and
responds to requests from a wide range of editors such as VSCode and
Vim, allowing them to support IDE-like functionality.
<!-- List only packages of general interest below. -->
Selected commands:
- `cmd/goimports` formats a Go program like `go fmt` and additionally
inserts import statements for any packages required by the file
after it is edited.
- `cmd/callgraph` prints the call graph of a Go program.
- `cmd/digraph` is a utility for manipulating directed graphs in textual notation.
- `cmd/stringer` generates declarations (including a `String` method) for "enum" types.
- `cmd/toolstash` is a utility to simplify working with multiple versions of the Go toolchain.
These commands may be fetched with a command such as
```
go install golang.org/x/tools/cmd/goimports@latest
```
Selected packages:
- `go/ssa` provides a static single-assignment form (SSA) intermediate
representation (IR) for Go programs, similar to a typical compiler,
for use by analysis tools.
- `go/packages` provides a simple interface for loading, parsing, and
type checking a complete Go program from source code.
- `go/analysis` provides a framework for modular static analysis of Go
programs.
- `go/callgraph` provides call graphs of Go programs using a variety
of algorithms with different trade-offs.
- `go/ast/inspector` provides an optimized means of traversing a Go
parse tree for use in analysis tools.
- `go/cfg` provides a simple control-flow graph (CFG) for a Go function.
- `go/gcexportdata` and `go/gccgoexportdata` read and write the binary
files containing type information used by the standard and `gccgo` compilers.
- `go/types/objectpath` provides a stable naming scheme for named
entities ("objects") in the `go/types` API.
Numerous other packages provide more esoteric functionality.
<!-- Some that didn't make the cut:
golang.org/x/tools/benchmark/parse
golang.org/x/tools/go/ast/astutil
golang.org/x/tools/go/types/typeutil
golang.org/x/tools/playground
golang.org/x/tools/present
golang.org/x/tools/refactor/importgraph
golang.org/x/tools/refactor/rename
golang.org/x/tools/refactor/satisfy
golang.org/x/tools/txtar
-->
## Contributing
This repository uses Gerrit for code changes.
To learn how to submit changes, see https://go.dev/doc/contribute.
The git repository is https://go.googlesource.com/tools.
The main issue tracker for the tools repository is located at
https://go.dev/issues. Prefix your issue with "x/tools/(your
subdir):" in the subject line, so it is easy to find.
### JavaScript and CSS Formatting
This repository uses [prettier](https://prettier.io/) to format JS and CSS files.
The version of `prettier` used is 1.18.2.
It is encouraged that all JS and CSS code be run through this before submitting
a change. However, it is not a strict requirement enforced by CI.
================================================
FILE: benchmark/parse/parse.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package parse provides support for parsing benchmark results as
// generated by 'go test -bench'.
package parse // import "golang.org/x/tools/benchmark/parse"
import (
"bufio"
"bytes"
"fmt"
"io"
"strconv"
"strings"
)
// Flags used by Benchmark.Measured to indicate
// which measurements a Benchmark contains.
const (
NsPerOp = 1 << iota
MBPerS
AllocedBytesPerOp
AllocsPerOp
)
// Benchmark is one run of a single benchmark.
type Benchmark struct {
Name string // benchmark name
N int // number of iterations
NsPerOp float64 // nanoseconds per iteration
AllocedBytesPerOp uint64 // bytes allocated per iteration
AllocsPerOp uint64 // allocs per iteration
MBPerS float64 // MB processed per second
Measured int // which measurements were recorded
Ord int // ordinal position within a benchmark run
}
// ParseLine extracts a Benchmark from a single line of testing.B
// output.
func ParseLine(line string) (*Benchmark, error) {
fields := strings.Fields(line)
// Two required, positional fields: Name and iterations.
if len(fields) < 2 {
return nil, fmt.Errorf("two fields required, have %d", len(fields))
}
if !strings.HasPrefix(fields[0], "Benchmark") {
return nil, fmt.Errorf(`first field does not start with "Benchmark"`)
}
n, err := strconv.Atoi(fields[1])
if err != nil {
return nil, err
}
b := &Benchmark{Name: fields[0], N: n}
// Parse any remaining pairs of fields; we've parsed one pair already.
for i := 1; i < len(fields)/2; i++ {
b.parseMeasurement(fields[i*2], fields[i*2+1])
}
return b, nil
}
func (b *Benchmark) parseMeasurement(quant string, unit string) {
switch unit {
case "ns/op":
if f, err := strconv.ParseFloat(quant, 64); err == nil {
b.NsPerOp = f
b.Measured |= NsPerOp
}
case "MB/s":
if f, err := strconv.ParseFloat(quant, 64); err == nil {
b.MBPerS = f
b.Measured |= MBPerS
}
case "B/op":
if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
b.AllocedBytesPerOp = i
b.Measured |= AllocedBytesPerOp
}
case "allocs/op":
if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
b.AllocsPerOp = i
b.Measured |= AllocsPerOp
}
}
}
func (b *Benchmark) String() string {
buf := new(bytes.Buffer)
fmt.Fprintf(buf, "%s %d", b.Name, b.N)
if (b.Measured & NsPerOp) != 0 {
fmt.Fprintf(buf, " %.2f ns/op", b.NsPerOp)
}
if (b.Measured & MBPerS) != 0 {
fmt.Fprintf(buf, " %.2f MB/s", b.MBPerS)
}
if (b.Measured & AllocedBytesPerOp) != 0 {
fmt.Fprintf(buf, " %d B/op", b.AllocedBytesPerOp)
}
if (b.Measured & AllocsPerOp) != 0 {
fmt.Fprintf(buf, " %d allocs/op", b.AllocsPerOp)
}
return buf.String()
}
// Set is a collection of benchmarks from one
// testing.B run, keyed by name to facilitate comparison.
type Set map[string][]*Benchmark
// ParseSet extracts a Set from testing.B output.
// ParseSet preserves the order of benchmarks that have identical
// names.
func ParseSet(r io.Reader) (Set, error) {
bb := make(Set)
scan := bufio.NewScanner(r)
ord := 0
for scan.Scan() {
if b, err := ParseLine(scan.Text()); err == nil {
b.Ord = ord
ord++
bb[b.Name] = append(bb[b.Name], b)
}
}
if err := scan.Err(); err != nil {
return nil, err
}
return bb, nil
}
================================================
FILE: benchmark/parse/parse_test.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package parse
import (
"reflect"
"strings"
"testing"
)
func TestParseLine(t *testing.T) {
cases := []struct {
line string
want *Benchmark
err bool // expect an error
}{
{
line: "BenchmarkEncrypt 100000000 19.6 ns/op",
want: &Benchmark{
Name: "BenchmarkEncrypt",
N: 100000000, NsPerOp: 19.6,
Measured: NsPerOp,
},
},
{
line: "BenchmarkEncrypt 100000000 19.6 ns/op 817.77 MB/s",
want: &Benchmark{
Name: "BenchmarkEncrypt",
N: 100000000, NsPerOp: 19.6, MBPerS: 817.77,
Measured: NsPerOp | MBPerS,
},
},
{
line: "BenchmarkEncrypt 100000000 19.6 ns/op 817.77",
want: &Benchmark{
Name: "BenchmarkEncrypt",
N: 100000000, NsPerOp: 19.6,
Measured: NsPerOp,
},
},
{
line: "BenchmarkEncrypt 100000000 19.6 ns/op 817.77 MB/s 5 allocs/op",
want: &Benchmark{
Name: "BenchmarkEncrypt",
N: 100000000, NsPerOp: 19.6, MBPerS: 817.77, AllocsPerOp: 5,
Measured: NsPerOp | MBPerS | AllocsPerOp,
},
},
{
line: "BenchmarkEncrypt 100000000 19.6 ns/op 817.77 MB/s 3 B/op 5 allocs/op",
want: &Benchmark{
Name: "BenchmarkEncrypt",
N: 100000000, NsPerOp: 19.6, MBPerS: 817.77, AllocedBytesPerOp: 3, AllocsPerOp: 5,
Measured: NsPerOp | MBPerS | AllocedBytesPerOp | AllocsPerOp,
},
},
// error handling cases
{
line: "BenchPress 100 19.6 ns/op", // non-benchmark
err: true,
},
{
line: "BenchmarkEncrypt lots 19.6 ns/op", // non-int iterations
err: true,
},
{
line: "BenchmarkBridge 100000000 19.6 smoots", // unknown unit
want: &Benchmark{
Name: "BenchmarkBridge",
N: 100000000,
},
},
{
line: "PASS",
err: true,
},
}
for _, tt := range cases {
have, err := ParseLine(tt.line)
if tt.err && err == nil {
t.Errorf("parsing line %q should have failed", tt.line)
continue
}
if !reflect.DeepEqual(have, tt.want) {
t.Errorf("parsed line %q incorrectly, want %v have %v", tt.line, tt.want, have)
}
}
}
func TestParseSet(t *testing.T) {
// Test two things:
// 1. The noise that can accompany testing.B output gets ignored.
// 2. Benchmarks with the same name have their order preserved.
in := `
? crypto [no test files]
PASS
pem_decrypt_test.go:17: test 4. %!s(x509.PEMCipher=5)
... [output truncated]
BenchmarkEncrypt 100000000 19.6 ns/op
BenchmarkEncrypt 5000000 517 ns/op
=== RUN TestChunk
--- PASS: TestChunk (0.00 seconds)
--- SKIP: TestLinuxSendfile (0.00 seconds)
fs_test.go:716: skipping; linux-only test
BenchmarkReadRequestApachebench 1000000 2960 ns/op 27.70 MB/s 839 B/op 9 allocs/op
BenchmarkClientServerParallel64 50000 59192 ns/op 7028 B/op 60 allocs/op
ok net/http 95.783s
`
want := Set{
"BenchmarkReadRequestApachebench": []*Benchmark{
{
Name: "BenchmarkReadRequestApachebench",
N: 1000000, NsPerOp: 2960, MBPerS: 27.70, AllocedBytesPerOp: 839, AllocsPerOp: 9,
Measured: NsPerOp | MBPerS | AllocedBytesPerOp | AllocsPerOp,
Ord: 2,
},
},
"BenchmarkClientServerParallel64": []*Benchmark{
{
Name: "BenchmarkClientServerParallel64",
N: 50000, NsPerOp: 59192, AllocedBytesPerOp: 7028, AllocsPerOp: 60,
Measured: NsPerOp | AllocedBytesPerOp | AllocsPerOp,
Ord: 3,
},
},
"BenchmarkEncrypt": []*Benchmark{
{
Name: "BenchmarkEncrypt",
N: 100000000, NsPerOp: 19.6,
Measured: NsPerOp,
Ord: 0,
},
{
Name: "BenchmarkEncrypt",
N: 5000000, NsPerOp: 517,
Measured: NsPerOp,
Ord: 1,
},
},
}
have, err := ParseSet(strings.NewReader(in))
if err != nil {
t.Fatalf("unexpected err during ParseSet: %v", err)
}
if !reflect.DeepEqual(want, have) {
t.Errorf("parsed bench set incorrectly, want %v have %v", want, have)
}
}
func TestString(t *testing.T) {
tests := []struct {
name string
input *Benchmark
wanted string
}{
{
name: "nsTest",
input: &Benchmark{
Name: "BenchmarkTest",
N: 100000000, NsPerOp: 19.6,
Measured: NsPerOp,
},
wanted: "BenchmarkTest 100000000 19.60 ns/op",
},
{
name: "mbTest",
input: &Benchmark{
Name: "BenchmarkTest",
N: 100000000, MBPerS: 19.6,
Measured: MBPerS,
},
wanted: "BenchmarkTest 100000000 19.60 MB/s",
},
{
name: "allocatedBytesTest",
input: &Benchmark{
Name: "BenchmarkTest",
N: 100000000, AllocedBytesPerOp: 5,
Measured: AllocedBytesPerOp,
},
wanted: "BenchmarkTest 100000000 5 B/op",
},
{
name: "allocsTest",
input: &Benchmark{
Name: "BenchmarkTest",
N: 100000000, AllocsPerOp: 5,
Measured: AllocsPerOp,
},
wanted: "BenchmarkTest 100000000 5 allocs/op",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := tt.input.String()
if result != tt.wanted {
t.Errorf("String() is called, want %q, have %q", tt.wanted, result)
}
})
}
}
================================================
FILE: blog/atom/atom.go
================================================
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Adapted from encoding/xml/read_test.go.
// Package atom defines XML data structures for an Atom feed.
package atom // import "golang.org/x/tools/blog/atom"
import (
"encoding/xml"
"time"
)
type Feed struct {
XMLName xml.Name `xml:"http://www.w3.org/2005/Atom feed"`
Title string `xml:"title"`
ID string `xml:"id"`
Link []Link `xml:"link"`
Updated TimeStr `xml:"updated"`
Author *Person `xml:"author"`
Entry []*Entry `xml:"entry"`
}
type Entry struct {
Title string `xml:"title"`
ID string `xml:"id"`
Link []Link `xml:"link"`
Published TimeStr `xml:"published"`
Updated TimeStr `xml:"updated"`
Author *Person `xml:"author"`
Summary *Text `xml:"summary"`
Content *Text `xml:"content"`
}
type Link struct {
Rel string `xml:"rel,attr,omitempty"`
Href string `xml:"href,attr"`
Type string `xml:"type,attr,omitempty"`
HrefLang string `xml:"hreflang,attr,omitempty"`
Title string `xml:"title,attr,omitempty"`
Length uint `xml:"length,attr,omitempty"`
}
type Person struct {
Name string `xml:"name"`
URI string `xml:"uri,omitempty"`
Email string `xml:"email,omitempty"`
InnerXML string `xml:",innerxml"`
}
type Text struct {
Type string `xml:"type,attr"`
Body string `xml:",chardata"`
}
type TimeStr string
func Time(t time.Time) TimeStr {
return TimeStr(t.Format("2006-01-02T15:04:05-07:00"))
}
================================================
FILE: blog/blog.go
================================================
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package blog implements a web server for articles written in present format.
package blog // import "golang.org/x/tools/blog"
import (
"bytes"
"encoding/json"
"encoding/xml"
"fmt"
"html/template"
"log"
"net/http"
"os"
"path/filepath"
"regexp"
"sort"
"strings"
"time"
"golang.org/x/tools/blog/atom"
"golang.org/x/tools/present"
)
var (
validJSONPFunc = regexp.MustCompile(`(?i)^[a-z_][a-z0-9_.]*$`)
// used to serve relative paths when ServeLocalLinks is enabled.
golangOrgAbsLinkReplacer = strings.NewReplacer(
`href="https://golang.org/pkg`, `href="/pkg`,
`href="https://golang.org/cmd`, `href="/cmd`,
)
)
// Config specifies Server configuration values.
type Config struct {
ContentPath string // Relative or absolute location of article files and related content.
TemplatePath string // Relative or absolute location of template files.
BaseURL string // Absolute base URL (for permalinks; no trailing slash).
BasePath string // Base URL path relative to server root (no trailing slash).
GodocURL string // The base URL of godoc (for menu bar; no trailing slash).
Hostname string // Server host name, used for rendering ATOM feeds.
AnalyticsHTML template.HTML // Optional analytics HTML to insert at the beginning of <head>.
HomeArticles int // Articles to display on the home page.
FeedArticles int // Articles to include in Atom and JSON feeds.
FeedTitle string // The title of the Atom XML feed
PlayEnabled bool
ServeLocalLinks bool // rewrite golang.org/{pkg,cmd} links to host-less, relative paths.
}
// Doc represents an article adorned with presentation data.
type Doc struct {
*present.Doc
Permalink string // Canonical URL for this document.
Path string // Path relative to server root (including base).
HTML template.HTML // rendered article
Related []*Doc
Newer, Older *Doc
}
// Server implements an http.Handler that serves blog articles.
type Server struct {
cfg Config
docs []*Doc
redirects map[string]string
tags []string
docPaths map[string]*Doc // key is path without BasePath.
docTags map[string][]*Doc
template struct {
home, index, article, doc *template.Template
}
atomFeed []byte // pre-rendered Atom feed
jsonFeed []byte // pre-rendered JSON feed
content http.Handler
}
// NewServer constructs a new Server using the specified config.
func NewServer(cfg Config) (*Server, error) {
present.PlayEnabled = cfg.PlayEnabled
if notExist(cfg.TemplatePath) {
return nil, fmt.Errorf("template directory not found: %s", cfg.TemplatePath)
}
root := filepath.Join(cfg.TemplatePath, "root.tmpl")
parse := func(name string) (*template.Template, error) {
path := filepath.Join(cfg.TemplatePath, name)
if notExist(path) {
return nil, fmt.Errorf("template %s was not found in %s", name, cfg.TemplatePath)
}
t := template.New("").Funcs(funcMap)
return t.ParseFiles(root, path)
}
s := &Server{cfg: cfg}
// Parse templates.
var err error
s.template.home, err = parse("home.tmpl")
if err != nil {
return nil, err
}
s.template.index, err = parse("index.tmpl")
if err != nil {
return nil, err
}
s.template.article, err = parse("article.tmpl")
if err != nil {
return nil, err
}
p := present.Template().Funcs(funcMap)
s.template.doc, err = p.ParseFiles(filepath.Join(cfg.TemplatePath, "doc.tmpl"))
if err != nil {
return nil, err
}
// Load content.
content := filepath.Clean(cfg.ContentPath)
err = s.loadDocs(content)
if err != nil {
return nil, err
}
err = s.renderAtomFeed()
if err != nil {
return nil, err
}
err = s.renderJSONFeed()
if err != nil {
return nil, err
}
// Set up content file server.
s.content = http.StripPrefix(s.cfg.BasePath, http.FileServer(http.Dir(cfg.ContentPath)))
return s, nil
}
var funcMap = template.FuncMap{
"sectioned": sectioned,
"authors": authors,
}
// sectioned returns true if the provided Doc contains more than one section.
// This is used to control whether to display the table of contents and headings.
func sectioned(d *present.Doc) bool {
return len(d.Sections) > 1
}
// authors returns a comma-separated list of author names.
func authors(authors []present.Author) string {
var b bytes.Buffer
last := len(authors) - 1
for i, a := range authors {
if i > 0 {
if i == last {
if len(authors) > 2 {
b.WriteString(",")
}
b.WriteString(" and ")
} else {
b.WriteString(", ")
}
}
b.WriteString(authorName(a))
}
return b.String()
}
// authorName returns the first line of the Author text: the author's name.
func authorName(a present.Author) string {
el := a.TextElem()
if len(el) == 0 {
return ""
}
text, ok := el[0].(present.Text)
if !ok || len(text.Lines) == 0 {
return ""
}
return text.Lines[0]
}
// loadDocs reads all content from the provided file system root, renders all
// the articles it finds, adds them to the Server's docs field, computes the
// denormalized docPaths, docTags, and tags fields, and populates the various
// helper fields (Next, Previous, Related) for each Doc.
func (s *Server) loadDocs(root string) error {
// Read content into docs field.
const ext = ".article"
fn := func(p string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if filepath.Ext(p) != ext {
return nil
}
f, err := os.Open(p)
if err != nil {
return err
}
defer f.Close()
d, err := present.Parse(f, p, 0)
if err != nil {
return err
}
var html bytes.Buffer
err = d.Render(&html, s.template.doc)
if err != nil {
return err
}
p = p[len(root) : len(p)-len(ext)] // trim root and extension
p = filepath.ToSlash(p)
s.docs = append(s.docs, &Doc{
Doc: d,
Path: s.cfg.BasePath + p,
Permalink: s.cfg.BaseURL + p,
HTML: template.HTML(html.String()),
})
return nil
}
err := filepath.Walk(root, fn)
if err != nil {
return err
}
sort.Sort(docsByTime(s.docs))
// Pull out doc paths and tags and put in reverse-associating maps.
s.docPaths = make(map[string]*Doc)
s.docTags = make(map[string][]*Doc)
s.redirects = make(map[string]string)
for _, d := range s.docs {
s.docPaths[strings.TrimPrefix(d.Path, s.cfg.BasePath)] = d
for _, t := range d.Tags {
s.docTags[t] = append(s.docTags[t], d)
}
}
for _, d := range s.docs {
for _, old := range d.OldURL {
if !strings.HasPrefix(old, "/") {
old = "/" + old
}
if _, ok := s.docPaths[old]; ok {
return fmt.Errorf("redirect %s -> %s conflicts with document %s", old, d.Path, old)
}
if new, ok := s.redirects[old]; ok {
return fmt.Errorf("redirect %s -> %s conflicts with redirect %s -> %s", old, d.Path, old, new)
}
s.redirects[old] = d.Path
}
}
// Pull out unique sorted list of tags.
for t := range s.docTags {
s.tags = append(s.tags, t)
}
sort.Strings(s.tags)
// Set up presentation-related fields, Newer, Older, and Related.
for _, doc := range s.docs {
// Newer, Older: docs adjacent to doc
for i := range s.docs {
if s.docs[i] != doc {
continue
}
if i > 0 {
doc.Newer = s.docs[i-1]
}
if i+1 < len(s.docs) {
doc.Older = s.docs[i+1]
}
break
}
// Related: all docs that share tags with doc.
related := make(map[*Doc]bool)
for _, t := range doc.Tags {
for _, d := range s.docTags[t] {
if d != doc {
related[d] = true
}
}
}
for d := range related {
doc.Related = append(doc.Related, d)
}
sort.Sort(docsByTime(doc.Related))
}
return nil
}
// renderAtomFeed generates an XML Atom feed and stores it in the Server's
// atomFeed field.
func (s *Server) renderAtomFeed() error {
var updated time.Time
if len(s.docs) > 0 {
updated = s.docs[0].Time
}
feed := atom.Feed{
Title: s.cfg.FeedTitle,
ID: "tag:" + s.cfg.Hostname + ",2013:" + s.cfg.Hostname,
Updated: atom.Time(updated),
Link: []atom.Link{{
Rel: "self",
Href: s.cfg.BaseURL + "/feed.atom",
}},
}
for i, doc := range s.docs {
if i >= s.cfg.FeedArticles {
break
}
// Use original article path as ID in atom feed
// to avoid articles being treated as new when renamed.
idPath := doc.Path
if len(doc.OldURL) > 0 {
old := doc.OldURL[0]
if !strings.HasPrefix(old, "/") {
old = "/" + old
}
idPath = old
}
e := &atom.Entry{
Title: doc.Title,
ID: feed.ID + idPath,
Link: []atom.Link{{
Rel: "alternate",
Href: doc.Permalink,
}},
Published: atom.Time(doc.Time),
Updated: atom.Time(doc.Time),
Summary: &atom.Text{
Type: "html",
Body: summary(doc),
},
Content: &atom.Text{
Type: "html",
Body: string(doc.HTML),
},
Author: &atom.Person{
Name: authors(doc.Authors),
},
}
feed.Entry = append(feed.Entry, e)
}
data, err := xml.Marshal(&feed)
if err != nil {
return err
}
s.atomFeed = data
return nil
}
type jsonItem struct {
Title string
Link string
Time time.Time
Summary string
Content string
Author string
}
// renderJSONFeed generates a JSON feed and stores it in the Server's jsonFeed
// field.
func (s *Server) renderJSONFeed() error {
var feed []jsonItem
for i, doc := range s.docs {
if i >= s.cfg.FeedArticles {
break
}
item := jsonItem{
Title: doc.Title,
Link: doc.Permalink,
Time: doc.Time,
Summary: summary(doc),
Content: string(doc.HTML),
Author: authors(doc.Authors),
}
feed = append(feed, item)
}
data, err := json.Marshal(feed)
if err != nil {
return err
}
s.jsonFeed = data
return nil
}
// summary returns the first paragraph of text from the provided Doc.
func summary(d *Doc) string {
if len(d.Sections) == 0 {
return ""
}
for _, elem := range d.Sections[0].Elem {
text, ok := elem.(present.Text)
if !ok || text.Pre {
// skip everything but non-text elements
continue
}
var buf bytes.Buffer
for _, s := range text.Lines {
buf.WriteString(string(present.Style(s)))
buf.WriteByte('\n')
}
return buf.String()
}
return ""
}
// rootData encapsulates data destined for the root template.
type rootData struct {
Doc *Doc
BasePath string
GodocURL string
AnalyticsHTML template.HTML
Data any
}
// ServeHTTP serves the front, index, and article pages
// as well as the ATOM and JSON feeds.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
var (
d = rootData{
BasePath: s.cfg.BasePath,
GodocURL: s.cfg.GodocURL,
AnalyticsHTML: s.cfg.AnalyticsHTML,
}
t *template.Template
)
switch p := strings.TrimPrefix(r.URL.Path, s.cfg.BasePath); p {
case "/":
d.Data = s.docs
if len(s.docs) > s.cfg.HomeArticles {
d.Data = s.docs[:s.cfg.HomeArticles]
}
t = s.template.home
case "/index":
d.Data = s.docs
t = s.template.index
case "/feed.atom", "/feeds/posts/default":
w.Header().Set("Content-type", "application/atom+xml; charset=utf-8")
w.Write(s.atomFeed)
return
case "/.json":
if p := r.FormValue("jsonp"); validJSONPFunc.MatchString(p) {
w.Header().Set("Content-type", "application/javascript; charset=utf-8")
fmt.Fprintf(w, "%v(%s)", p, s.jsonFeed)
return
}
w.Header().Set("Content-type", "application/json; charset=utf-8")
w.Write(s.jsonFeed)
return
default:
if redir, ok := s.redirects[p]; ok {
http.Redirect(w, r, redir, http.StatusMovedPermanently)
return
}
doc, ok := s.docPaths[p]
if !ok {
// Not a doc; try to just serve static content.
s.content.ServeHTTP(w, r)
return
}
d.Doc = doc
t = s.template.article
}
var err error
if s.cfg.ServeLocalLinks {
var buf bytes.Buffer
err = t.ExecuteTemplate(&buf, "root", d)
if err != nil {
log.Println(err)
return
}
_, err = golangOrgAbsLinkReplacer.WriteString(w, buf.String())
} else {
err = t.ExecuteTemplate(w, "root", d)
}
if err != nil {
log.Println(err)
}
}
// docsByTime implements sort.Interface, sorting Docs by their Time field.
type docsByTime []*Doc
func (s docsByTime) Len() int { return len(s) }
func (s docsByTime) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s docsByTime) Less(i, j int) bool { return s[i].Time.After(s[j].Time) }
// notExist reports whether the path exists or not.
func notExist(path string) bool {
_, err := os.Stat(path)
return os.IsNotExist(err)
}
================================================
FILE: blog/blog_test.go
================================================
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package blog
import (
"bytes"
"testing"
)
func TestLinkRewrite(t *testing.T) {
tests := []struct {
input string
output string
}{
{
`For instance, the <a href="https://golang.org/pkg/bytes/" target="_blank">bytes package</a> from the standard library exports the <code>Buffer</code> type.`,
`For instance, the <a href="/pkg/bytes/" target="_blank">bytes package</a> from the standard library exports the <code>Buffer</code> type.`},
{
`(The <a href="https://golang.org/cmd/gofmt/" target="_blank">gofmt command</a> has a <code>-r</code> flag that provides a syntax-aware search and replace, making large-scale refactoring easier.)`,
`(The <a href="/cmd/gofmt/" target="_blank">gofmt command</a> has a <code>-r</code> flag that provides a syntax-aware search and replace, making large-scale refactoring easier.)`,
},
{
`<a href="//golang.org/LICENSE">BSD license</a>.<br> <a href="//golang.org/doc/tos.html">Terms of Service</a> `,
`<a href="//golang.org/LICENSE">BSD license</a>.<br> <a href="//golang.org/doc/tos.html">Terms of Service</a> `,
},
{
`For instance, the <code>websocket</code> package from the <code>go.net</code> sub-repository has an import path of <code>"golang.org/x/net/websocket"</code>.`,
`For instance, the <code>websocket</code> package from the <code>go.net</code> sub-repository has an import path of <code>"golang.org/x/net/websocket"</code>.`,
},
}
for _, test := range tests {
var buf bytes.Buffer
_, err := golangOrgAbsLinkReplacer.WriteString(&buf, test.input)
if err != nil {
t.Errorf("unexpected error during replacing links. Got: %#v, Want: nil.\n", err)
continue
}
if got, want := buf.String(), test.output; got != want {
t.Errorf("WriteString(%q) = %q. Expected: %q", test.input, got, want)
}
}
}
================================================
FILE: cmd/benchcmp/benchcmp.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"flag"
"fmt"
"os"
"sort"
"strconv"
"text/tabwriter"
"golang.org/x/tools/benchmark/parse"
)
var (
changedOnly = flag.Bool("changed", false, "show only benchmarks that have changed")
magSort = flag.Bool("mag", false, "sort benchmarks by magnitude of change")
best = flag.Bool("best", false, "compare best times from old and new")
)
const usageFooter = `
Each input file should be from:
go test -run=NONE -bench=. > [old,new].txt
Benchcmp compares old and new for each benchmark.
If -test.benchmem=true is added to the "go test" command
benchcmp will also compare memory allocations.
`
func main() {
fmt.Fprintf(os.Stderr, "benchcmp is deprecated in favor of benchstat: https://pkg.go.dev/golang.org/x/perf/cmd/benchstat\n")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s old.txt new.txt\n\n", os.Args[0])
flag.PrintDefaults()
fmt.Fprint(os.Stderr, usageFooter)
os.Exit(2)
}
flag.Parse()
if flag.NArg() != 2 {
flag.Usage()
}
before := parseFile(flag.Arg(0))
after := parseFile(flag.Arg(1))
cmps, warnings := Correlate(before, after)
for _, warn := range warnings {
fmt.Fprintln(os.Stderr, warn)
}
if len(cmps) == 0 {
fatal("benchcmp: no repeated benchmarks")
}
w := new(tabwriter.Writer)
w.Init(os.Stdout, 0, 0, 5, ' ', 0)
defer w.Flush()
var header bool // Has the header has been displayed yet for a given block?
if *magSort {
sort.Sort(ByDeltaNsPerOp(cmps))
} else {
sort.Sort(ByParseOrder(cmps))
}
for _, cmp := range cmps {
if !cmp.Measured(parse.NsPerOp) {
continue
}
if delta := cmp.DeltaNsPerOp(); !*changedOnly || delta.Changed() {
if !header {
fmt.Fprint(w, "benchmark\told ns/op\tnew ns/op\tdelta\n")
header = true
}
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", cmp.Name(), formatNs(cmp.Before.NsPerOp), formatNs(cmp.After.NsPerOp), delta.Percent())
}
}
header = false
if *magSort {
sort.Sort(ByDeltaMBPerS(cmps))
}
for _, cmp := range cmps {
if !cmp.Measured(parse.MBPerS) {
continue
}
if delta := cmp.DeltaMBPerS(); !*changedOnly || delta.Changed() {
if !header {
fmt.Fprint(w, "\nbenchmark\told MB/s\tnew MB/s\tspeedup\n")
header = true
}
fmt.Fprintf(w, "%s\t%.2f\t%.2f\t%s\n", cmp.Name(), cmp.Before.MBPerS, cmp.After.MBPerS, delta.Multiple())
}
}
header = false
if *magSort {
sort.Sort(ByDeltaAllocsPerOp(cmps))
}
for _, cmp := range cmps {
if !cmp.Measured(parse.AllocsPerOp) {
continue
}
if delta := cmp.DeltaAllocsPerOp(); !*changedOnly || delta.Changed() {
if !header {
fmt.Fprint(w, "\nbenchmark\told allocs\tnew allocs\tdelta\n")
header = true
}
fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocsPerOp, cmp.After.AllocsPerOp, delta.Percent())
}
}
header = false
if *magSort {
sort.Sort(ByDeltaAllocedBytesPerOp(cmps))
}
for _, cmp := range cmps {
if !cmp.Measured(parse.AllocedBytesPerOp) {
continue
}
if delta := cmp.DeltaAllocedBytesPerOp(); !*changedOnly || delta.Changed() {
if !header {
fmt.Fprint(w, "\nbenchmark\told bytes\tnew bytes\tdelta\n")
header = true
}
fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocedBytesPerOp, cmp.After.AllocedBytesPerOp, cmp.DeltaAllocedBytesPerOp().Percent())
}
}
}
func fatal(msg any) {
fmt.Fprintln(os.Stderr, msg)
os.Exit(1)
}
func parseFile(path string) parse.Set {
f, err := os.Open(path)
if err != nil {
fatal(err)
}
defer f.Close()
bb, err := parse.ParseSet(f)
if err != nil {
fatal(err)
}
if *best {
selectBest(bb)
}
return bb
}
func selectBest(bs parse.Set) {
for name, bb := range bs {
if len(bb) < 2 {
continue
}
ord := bb[0].Ord
best := bb[0]
for _, b := range bb {
if b.NsPerOp < best.NsPerOp {
b.Ord = ord
best = b
}
}
bs[name] = []*parse.Benchmark{best}
}
}
// formatNs formats ns measurements to expose a useful amount of
// precision. It mirrors the ns precision logic of testing.B.
func formatNs(ns float64) string {
prec := 0
switch {
case ns < 10:
prec = 2
case ns < 100:
prec = 1
}
return strconv.FormatFloat(ns, 'f', prec, 64)
}
================================================
FILE: cmd/benchcmp/benchcmp_test.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"reflect"
"testing"
"golang.org/x/tools/benchmark/parse"
)
func TestSelectBest(t *testing.T) {
have := parse.Set{
"Benchmark1": []*parse.Benchmark{
{
Name: "Benchmark1",
N: 10, NsPerOp: 100, Measured: parse.NsPerOp,
Ord: 0,
},
{
Name: "Benchmark1",
N: 10, NsPerOp: 50, Measured: parse.NsPerOp,
Ord: 3,
},
},
"Benchmark2": []*parse.Benchmark{
{
Name: "Benchmark2",
N: 10, NsPerOp: 60, Measured: parse.NsPerOp,
Ord: 1,
},
{
Name: "Benchmark2",
N: 10, NsPerOp: 500, Measured: parse.NsPerOp,
Ord: 2,
},
},
}
want := parse.Set{
"Benchmark1": []*parse.Benchmark{
{
Name: "Benchmark1",
N: 10, NsPerOp: 50, Measured: parse.NsPerOp,
Ord: 0,
},
},
"Benchmark2": []*parse.Benchmark{
{
Name: "Benchmark2",
N: 10, NsPerOp: 60, Measured: parse.NsPerOp,
Ord: 1,
},
},
}
selectBest(have)
if !reflect.DeepEqual(want, have) {
t.Errorf("filtered bench set incorrectly, want %v have %v", want, have)
}
}
func TestFormatNs(t *testing.T) {
tests := []struct {
input float64
expected string
}{
{input: 0, expected: "0.00"},
{input: 0.2, expected: "0.20"},
{input: 2, expected: "2.00"},
{input: 2.2, expected: "2.20"},
{input: 4, expected: "4.00"},
{input: 16, expected: "16.0"},
{input: 16.08, expected: "16.1"},
{input: 128, expected: "128"},
{input: 256.2, expected: "256"},
}
for _, tt := range tests {
actual := formatNs(tt.input)
if actual != tt.expected {
t.Fatalf("%f. got %q, want %q", tt.input, actual, tt.expected)
}
}
}
================================================
FILE: cmd/benchcmp/compare.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"fmt"
"math"
"golang.org/x/tools/benchmark/parse"
)
// BenchCmp is a pair of benchmarks.
type BenchCmp struct {
Before *parse.Benchmark
After *parse.Benchmark
}
// Correlate correlates benchmarks from two BenchSets.
func Correlate(before, after parse.Set) (cmps []BenchCmp, warnings []string) {
cmps = make([]BenchCmp, 0, len(after))
for name, beforebb := range before {
afterbb := after[name]
if len(beforebb) != len(afterbb) {
warnings = append(warnings, fmt.Sprintf("ignoring %s: before has %d instances, after has %d", name, len(beforebb), len(afterbb)))
continue
}
for i, beforeb := range beforebb {
afterb := afterbb[i]
cmps = append(cmps, BenchCmp{beforeb, afterb})
}
}
return
}
func (c BenchCmp) Name() string { return c.Before.Name }
func (c BenchCmp) String() string { return fmt.Sprintf("<%s, %s>", c.Before, c.After) }
func (c BenchCmp) Measured(flag int) bool { return (c.Before.Measured & c.After.Measured & flag) != 0 }
func (c BenchCmp) DeltaNsPerOp() Delta { return Delta{c.Before.NsPerOp, c.After.NsPerOp} }
func (c BenchCmp) DeltaMBPerS() Delta { return Delta{c.Before.MBPerS, c.After.MBPerS} }
func (c BenchCmp) DeltaAllocedBytesPerOp() Delta {
return Delta{float64(c.Before.AllocedBytesPerOp), float64(c.After.AllocedBytesPerOp)}
}
func (c BenchCmp) DeltaAllocsPerOp() Delta {
return Delta{float64(c.Before.AllocsPerOp), float64(c.After.AllocsPerOp)}
}
// Delta is the before and after value for a benchmark measurement.
// Both must be non-negative.
type Delta struct {
Before float64
After float64
}
// mag calculates the magnitude of a change, regardless of the direction of
// the change. mag is intended for sorting and has no independent meaning.
func (d Delta) mag() float64 {
switch {
case d.Before != 0 && d.After != 0 && d.Before >= d.After:
return d.After / d.Before
case d.Before != 0 && d.After != 0 && d.Before < d.After:
return d.Before / d.After
case d.Before == 0 && d.After == 0:
return 1
default:
// 0 -> 1 or 1 -> 0
// These are significant changes and worth surfacing.
return math.Inf(1)
}
}
// Changed reports whether the benchmark quantities are different.
func (d Delta) Changed() bool { return d.Before != d.After }
// Float64 returns After / Before. If Before is 0, Float64 returns
// 1 if After is also 0, and +Inf otherwise.
func (d Delta) Float64() float64 {
switch {
case d.Before != 0:
return d.After / d.Before
case d.After == 0:
return 1
default:
return math.Inf(1)
}
}
// Percent formats a Delta as a percent change, ranging from -100% up.
func (d Delta) Percent() string {
return fmt.Sprintf("%+.2f%%", 100*d.Float64()-100)
}
// Multiple formats a Delta as a multiplier, ranging from 0.00x up.
func (d Delta) Multiple() string {
return fmt.Sprintf("%.2fx", d.Float64())
}
func (d Delta) String() string {
return fmt.Sprintf("Δ(%f, %f)", d.Before, d.After)
}
// ByParseOrder sorts BenchCmps to match the order in
// which the Before benchmarks were presented to Parse.
type ByParseOrder []BenchCmp
func (x ByParseOrder) Len() int { return len(x) }
func (x ByParseOrder) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x ByParseOrder) Less(i, j int) bool { return x[i].Before.Ord < x[j].Before.Ord }
// lessByDelta provides lexicographic ordering:
// - largest delta by magnitude
// - alphabetic by name
func lessByDelta(i, j BenchCmp, calcDelta func(BenchCmp) Delta) bool {
iDelta, jDelta := calcDelta(i).mag(), calcDelta(j).mag()
if iDelta != jDelta {
return iDelta < jDelta
}
return i.Name() < j.Name()
}
// ByDeltaNsPerOp sorts BenchCmps lexicographically by change
// in ns/op, descending, then by benchmark name.
type ByDeltaNsPerOp []BenchCmp
func (x ByDeltaNsPerOp) Len() int { return len(x) }
func (x ByDeltaNsPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x ByDeltaNsPerOp) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaNsPerOp) }
// ByDeltaMBPerS sorts BenchCmps lexicographically by change
// in MB/s, descending, then by benchmark name.
type ByDeltaMBPerS []BenchCmp
func (x ByDeltaMBPerS) Len() int { return len(x) }
func (x ByDeltaMBPerS) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x ByDeltaMBPerS) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaMBPerS) }
// ByDeltaAllocedBytesPerOp sorts BenchCmps lexicographically by change
// in B/op, descending, then by benchmark name.
type ByDeltaAllocedBytesPerOp []BenchCmp
func (x ByDeltaAllocedBytesPerOp) Len() int { return len(x) }
func (x ByDeltaAllocedBytesPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x ByDeltaAllocedBytesPerOp) Less(i, j int) bool {
return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocedBytesPerOp)
}
// ByDeltaAllocsPerOp sorts BenchCmps lexicographically by change
// in allocs/op, descending, then by benchmark name.
type ByDeltaAllocsPerOp []BenchCmp
func (x ByDeltaAllocsPerOp) Len() int { return len(x) }
func (x ByDeltaAllocsPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x ByDeltaAllocsPerOp) Less(i, j int) bool {
return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocsPerOp)
}
================================================
FILE: cmd/benchcmp/compare_test.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"math"
"reflect"
"sort"
"testing"
"golang.org/x/tools/benchmark/parse"
)
func TestDelta(t *testing.T) {
cases := []struct {
before float64
after float64
mag float64
f float64
changed bool
pct string
mult string
}{
{before: 1, after: 1, mag: 1, f: 1, changed: false, pct: "+0.00%", mult: "1.00x"},
{before: 1, after: 2, mag: 0.5, f: 2, changed: true, pct: "+100.00%", mult: "2.00x"},
{before: 2, after: 1, mag: 0.5, f: 0.5, changed: true, pct: "-50.00%", mult: "0.50x"},
{before: 0, after: 0, mag: 1, f: 1, changed: false, pct: "+0.00%", mult: "1.00x"},
{before: 1, after: 0, mag: math.Inf(1), f: 0, changed: true, pct: "-100.00%", mult: "0.00x"},
{before: 0, after: 1, mag: math.Inf(1), f: math.Inf(1), changed: true, pct: "+Inf%", mult: "+Infx"},
}
for _, tt := range cases {
d := Delta{tt.before, tt.after}
if want, have := tt.mag, d.mag(); want != have {
t.Errorf("%s.mag(): want %f have %f", d, want, have)
}
if want, have := tt.f, d.Float64(); want != have {
t.Errorf("%s.Float64(): want %f have %f", d, want, have)
}
if want, have := tt.changed, d.Changed(); want != have {
t.Errorf("%s.Changed(): want %t have %t", d, want, have)
}
if want, have := tt.pct, d.Percent(); want != have {
t.Errorf("%s.Percent(): want %q have %q", d, want, have)
}
if want, have := tt.mult, d.Multiple(); want != have {
t.Errorf("%s.Multiple(): want %q have %q", d, want, have)
}
}
}
func TestCorrelate(t *testing.T) {
// Benches that are going to be successfully correlated get N thus:
// 0x<counter><num benches><b = before | a = after>
// Read this: "<counter> of <num benches>, from <before|after>".
before := parse.Set{
"BenchmarkOneEach": []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11b}},
"BenchmarkOneToNone": []*parse.Benchmark{{Name: "BenchmarkOneToNone"}},
"BenchmarkOneToTwo": []*parse.Benchmark{{Name: "BenchmarkOneToTwo"}},
"BenchmarkTwoToOne": []*parse.Benchmark{
{Name: "BenchmarkTwoToOne"},
{Name: "BenchmarkTwoToOne"},
},
"BenchmarkTwoEach": []*parse.Benchmark{
{Name: "BenchmarkTwoEach", N: 0x12b},
{Name: "BenchmarkTwoEach", N: 0x22b},
},
}
after := parse.Set{
"BenchmarkOneEach": []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11a}},
"BenchmarkNoneToOne": []*parse.Benchmark{{Name: "BenchmarkNoneToOne"}},
"BenchmarkTwoToOne": []*parse.Benchmark{{Name: "BenchmarkTwoToOne"}},
"BenchmarkOneToTwo": []*parse.Benchmark{
{Name: "BenchmarkOneToTwo"},
{Name: "BenchmarkOneToTwo"},
},
"BenchmarkTwoEach": []*parse.Benchmark{
{Name: "BenchmarkTwoEach", N: 0x12a},
{Name: "BenchmarkTwoEach", N: 0x22a},
},
}
pairs, errs := Correlate(before, after)
// Fail to match: BenchmarkOneToNone, BenchmarkOneToTwo, BenchmarkTwoToOne.
// Correlate does not notice BenchmarkNoneToOne.
if len(errs) != 3 {
t.Errorf("Correlated expected 4 errors, got %d: %v", len(errs), errs)
}
// Want three correlated pairs: one BenchmarkOneEach, two BenchmarkTwoEach.
if len(pairs) != 3 {
t.Fatalf("Correlated expected 3 pairs, got %v", pairs)
}
for _, pair := range pairs {
if pair.Before.N&0xF != 0xb {
t.Errorf("unexpected Before in pair %s", pair)
}
if pair.After.N&0xF != 0xa {
t.Errorf("unexpected After in pair %s", pair)
}
if pair.Before.N>>4 != pair.After.N>>4 {
t.Errorf("mismatched pair %s", pair)
}
}
}
func TestBenchCmpSorting(t *testing.T) {
c := []BenchCmp{
{&parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 10, Ord: 3}, &parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 1}},
{&parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5, Ord: 1}, &parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5}},
{&parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5, Ord: 2}, &parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5}},
{&parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 10, Ord: 0}, &parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 11}},
}
// Test just one magnitude-based sort order; they are symmetric.
sort.Sort(ByDeltaNsPerOp(c))
want := []string{"BenchmarkMuchFaster", "BenchmarkSlower", "BenchmarkSameA", "BenchmarkSameB"}
have := []string{c[0].Name(), c[1].Name(), c[2].Name(), c[3].Name()}
if !reflect.DeepEqual(want, have) {
t.Errorf("ByDeltaNsOp incorrect sorting: want %v have %v", want, have)
}
sort.Sort(ByParseOrder(c))
want = []string{"BenchmarkSlower", "BenchmarkSameB", "BenchmarkSameA", "BenchmarkMuchFaster"}
have = []string{c[0].Name(), c[1].Name(), c[2].Name(), c[3].Name()}
if !reflect.DeepEqual(want, have) {
t.Errorf("ByParseOrder incorrect sorting: want %v have %v", want, have)
}
}
================================================
FILE: cmd/benchcmp/doc.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
Deprecated: benchcmp is deprecated in favor of benchstat: golang.org/x/perf/cmd/benchstat
The benchcmp command displays performance changes between benchmarks.
Benchcmp parses the output of two 'go test' benchmark runs,
correlates the results per benchmark, and displays the deltas.
To measure the performance impact of a change, use 'go test'
to run benchmarks before and after the change:
go test -run=NONE -bench=. ./... > old.txt
# make changes
go test -run=NONE -bench=. ./... > new.txt
Then feed the benchmark results to benchcmp:
benchcmp old.txt new.txt
Benchcmp will summarize and display the performance changes,
in a format like this:
$ benchcmp old.txt new.txt
benchmark old ns/op new ns/op delta
BenchmarkConcat 523 68.6 -86.88%
benchmark old allocs new allocs delta
BenchmarkConcat 3 1 -66.67%
benchmark old bytes new bytes delta
BenchmarkConcat 80 48 -40.00%
*/
package main // import "golang.org/x/tools/cmd/benchcmp"
================================================
FILE: cmd/bisect/go120.go
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"os"
"os/exec"
"time"
)
func cmdInterrupt(cmd *exec.Cmd) {
cmd.Cancel = func() error {
// On timeout, send interrupt,
// in hopes of shutting down process tree.
// Ignore errors sending signal; it's all best effort
// and not even implemented on Windows.
// TODO(rsc): Maybe use a new process group and kill the whole group?
cmd.Process.Signal(os.Interrupt)
return nil
}
cmd.WaitDelay = 2 * time.Second
}
================================================
FILE: cmd/bisect/main.go
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Bisect finds changes responsible for causing a failure.
// A typical use is to identify the source locations in a program
// that are miscompiled by a given compiler optimization.
//
// Usage:
//
// bisect [flags] [var=value...] command [arguments...]
//
// Bisect operates on a target command line – the target – that can be
// run with various changes individually enabled or disabled. With none
// of the changes enabled, the target is known to succeed (exit with exit
// code zero). With all the changes enabled, the target is known to fail
// (exit any other way). Bisect repeats the target with different sets of
// changes enabled, using binary search to find (non-overlapping) minimal
// change sets that provoke the failure.
//
// The target must cooperate with bisect by accepting a change pattern
// and then enabling and reporting the changes that match that pattern.
// The change pattern is passed to the target by substituting it anywhere
// the string PATTERN appears in the environment values or the command
// arguments. For each change that matches the pattern, the target must
// enable that change and also print one or more “match lines”
// (to standard output or standard error) describing the change.
// The [golang.org/x/tools/internal/bisect] package provides functions to help
// targets implement this protocol. We plan to publish that package
// in a non-internal location after finalizing its API.
//
// Bisect starts by running the target with no changes enabled and then
// with all changes enabled. It expects the former to succeed and the latter to fail,
// and then it will search for the minimal set of changes that must be enabled
// to provoke the failure. If the situation is reversed – the target fails with no
// changes enabled and succeeds with all changes enabled – then bisect
// automatically runs in reverse as well, searching for the minimal set of changes
// that must be disabled to provoke the failure.
//
// Bisect prints tracing logs to standard error and the minimal change sets
// to standard output.
//
// # Command Line Flags
//
// Bisect supports the following command-line flags:
//
// -max=M
//
// Stop after finding M minimal change sets. The default is no maximum, meaning to run until
// all changes that provoke a failure have been identified.
//
// -maxset=S
//
// Disallow change sets larger than S elements. The default is no maximum.
//
// -timeout=D
//
// If the target runs for longer than duration D, stop the target and interpret that as a failure.
// The default is no timeout.
//
// -count=N
//
// Run each trial N times (default 2), checking for consistency.
//
// -v
//
// Print verbose output, showing each run and its match lines.
//
// In addition to these general flags,
// bisect supports a few “shortcut” flags that make it more convenient
// to use with specific targets.
//
// -compile=<rewrite>
//
// This flag is equivalent to adding an environment variable
// “GOCOMPILEDEBUG=<rewrite>hash=PATTERN”,
// which, as discussed in more detail in the example below,
// allows bisect to identify the specific source locations where the
// compiler rewrite causes the target to fail.
//
// -godebug=<name>=<value>
//
// This flag is equivalent to adding an environment variable
// “GODEBUG=<name>=<value>#PATTERN”,
// which allows bisect to identify the specific call stacks where
// the changed [GODEBUG setting] value causes the target to fail.
//
// # Example
//
// The Go compiler provides support for enabling or disabling certain rewrites
// and optimizations to allow bisect to identify specific source locations where
// the rewrite causes the program to fail. For example, to bisect a failure caused
// by the new loop variable semantics:
//
// bisect go test -gcflags=all=-d=loopvarhash=PATTERN
//
// The -gcflags=all= instructs the go command to pass the -d=... to the Go compiler
// when compiling all packages. Bisect varies PATTERN to determine the minimal set of changes
// needed to reproduce the failure.
//
// The go command also checks the GOCOMPILEDEBUG environment variable for flags
// to pass to the compiler, so the above command is equivalent to:
//
// bisect GOCOMPILEDEBUG=loopvarhash=PATTERN go test
//
// Finally, as mentioned earlier, the -compile flag allows shortening this command further:
//
// bisect -compile=loopvar go test
//
// # Defeating Build Caches
//
// Build systems cache build results, to avoid repeating the same compilations
// over and over. When using a cached build result, the go command (correctly)
// reprints the cached standard output and standard error associated with that
// command invocation. (This makes commands like 'go build -gcflags=-S' for
// printing an assembly listing work reliably.)
//
// Unfortunately, most build systems, including Bazel, are not as careful
// as the go command about reprinting compiler output. If the compiler is
// what prints match lines, a build system that suppresses compiler
// output when using cached compiler results will confuse bisect.
// To defeat such build caches, bisect replaces the literal text “RANDOM”
// in environment values and command arguments with a random 64-bit value
// during each invocation. The Go compiler conveniently accepts a
// -d=ignore=... debug flag that ignores its argument, so to run the
// previous example using Bazel, the invocation is:
//
// bazel test --define=gc_goopts=-d=loopvarhash=PATTERN,unused=RANDOM //path/to:test
//
// [GODEBUG setting]: https://tip.golang.org/doc/godebug
package main
import (
"context"
"flag"
"fmt"
"io"
"log"
"math/bits"
"math/rand"
"os"
"os/exec"
"sort"
"strconv"
"strings"
"time"
"golang.org/x/tools/internal/bisect"
)
// Preserve import of bisect, to allow [bisect.Match] in the doc comment.
var _ bisect.Matcher
func usage() {
fmt.Fprintf(os.Stderr, "usage: bisect [flags] [var=value...] command [arguments...]\n")
flag.PrintDefaults()
os.Exit(2)
}
func main() {
log.SetFlags(0)
log.SetPrefix("bisect: ")
var b Bisect
b.Stdout = os.Stdout
b.Stderr = os.Stderr
flag.IntVar(&b.Max, "max", 0, "stop after finding `m` failing change sets")
flag.IntVar(&b.MaxSet, "maxset", 0, "do not search for change sets larger than `s` elements")
flag.DurationVar(&b.Timeout, "timeout", 0, "stop target and consider failed after duration `d`")
flag.IntVar(&b.Count, "count", 2, "run target `n` times for each trial")
flag.BoolVar(&b.Verbose, "v", false, "enable verbose output")
env := ""
envFlag := ""
flag.Func("compile", "bisect source locations affected by Go compiler `rewrite` (fma, loopvar, ...)", func(value string) error {
if envFlag != "" {
return fmt.Errorf("cannot use -%s and -compile", envFlag)
}
envFlag = "compile"
env = "GOCOMPILEDEBUG=" + value + "hash=PATTERN"
return nil
})
flag.Func("godebug", "bisect call stacks affected by GODEBUG setting `name=value`", func(value string) error {
if envFlag != "" {
return fmt.Errorf("cannot use -%s and -godebug", envFlag)
}
envFlag = "godebug"
env = "GODEBUG=" + value + "#PATTERN"
return nil
})
flag.Usage = usage
flag.Parse()
args := flag.Args()
// Split command line into env settings, command name, args.
i := 0
for i < len(args) && strings.Contains(args[i], "=") {
i++
}
if i == len(args) {
usage()
}
b.Env, b.Cmd, b.Args = args[:i], args[i], args[i+1:]
if env != "" {
b.Env = append([]string{env}, b.Env...)
}
// Check that PATTERN is available for us to vary.
found := false
for _, e := range b.Env {
if _, v, _ := strings.Cut(e, "="); strings.Contains(v, "PATTERN") {
found = true
}
}
for _, a := range b.Args {
if strings.Contains(a, "PATTERN") {
found = true
}
}
if !found {
log.Fatalf("no PATTERN in target environment or args")
}
if !b.Search() {
os.Exit(1)
}
}
// A Bisect holds the state for a bisect invocation.
type Bisect struct {
// Env is the additional environment variables for the command.
// PATTERN and RANDOM are substituted in the values, but not the names.
Env []string
// Cmd is the command (program name) to run.
// PATTERN and RANDOM are not substituted.
Cmd string
// Args is the command arguments.
// PATTERN and RANDOM are substituted anywhere they appear.
Args []string
// Command-line flags controlling bisect behavior.
Max int // maximum number of sets to report (0 = unlimited)
MaxSet int // maximum number of elements in a set (0 = unlimited)
Timeout time.Duration // kill target and assume failed after this duration (0 = unlimited)
Count int // run target this many times for each trial and give up if flaky (min 1 assumed; default 2 on command line set in main)
Verbose bool // print long output about each trial (only useful for debugging bisect itself)
// State for running bisect, replaced during testing.
// Failing change sets are printed to Stdout; all other output goes to Stderr.
Stdout io.Writer // where to write standard output (usually os.Stdout)
Stderr io.Writer // where to write standard error (usually os.Stderr)
TestRun func(env []string, cmd string, args []string) (out []byte, err error) // if non-nil, used instead of exec.Command
// State maintained by Search.
// By default, Search looks for a minimal set of changes that cause a failure when enabled.
// If Disable is true, the search is inverted and seeks a minimal set of changes that
// cause a failure when disabled. In this case, the search proceeds as normal except that
// each pattern starts with a !.
Disable bool
// SkipHexDigits is the number of hex digits to use in skip messages.
// If the set of available changes is the same in each run, as it should be,
// then this doesn't matter: we'll only exclude suffixes that uniquely identify
// a given change. But for some programs, especially bisecting runtime
// behaviors, sometimes enabling one change unlocks questions about other
// changes. Strictly speaking this is a misuse of bisect, but just to make
// bisect more robust, we use the y and n runs to create an estimate of the
// number of bits needed for a unique suffix, and then we round it up to
// a number of hex digits, with one extra digit for good measure, and then
// we always use that many hex digits for skips.
SkipHexDigits int
// Add is a list of suffixes to add to every trial, because they
// contain changes that are necessary for a group we are assembling.
Add []string
// Skip is a list of suffixes that uniquely identify changes to exclude from every trial,
// because they have already been used in failing change sets.
// Suffixes later in the list may only be unique after removing
// the ones earlier in the list.
// Skip applies after Add.
Skip []string
}
// A Result holds the result of a single target trial.
type Result struct {
Success bool // whether the target succeeded (exited with zero status)
Cmd string // full target command line
Out string // full target output (stdout and stderr combined)
Suffix string // the suffix used for collecting MatchIDs, MatchText, and MatchFull
MatchIDs []uint64 // match IDs enabled during this trial
MatchText []string // match reports for the IDs, with match markers removed
MatchFull []string // full match lines for the IDs, with match markers kept
}
// &searchFatal is a special panic value to signal that Search failed.
// This lets us unwind the search recursion on a fatal error
// but have Search return normally.
var searchFatal int
// Search runs a bisect search according to the configuration in b.
// It reports whether any failing change sets were found.
func (b *Bisect) Search() bool {
defer func() {
// Recover from panic(&searchFatal), implicitly returning false from Search.
// Re-panic on any other panic.
if e := recover(); e != nil && e != &searchFatal {
panic(e)
}
}()
// Run with no changes and all changes, to figure out which direction we're searching.
// The goal is to find the minimal set of changes to toggle
// starting with the state where everything works.
// If "no changes" succeeds and "all changes" fails,
// we're looking for a minimal set of changes to enable to provoke the failure
// (broken = runY, b.Negate = false)
// If "no changes" fails and "all changes" succeeds,
// we're looking for a minimal set of changes to disable to provoke the failure
// (broken = runN, b.Negate = true).
b.Logf("checking target with all changes disabled")
runN := b.Run("n")
b.Logf("checking target with all changes enabled")
runY := b.Run("y")
var broken *Result
switch {
case runN.Success && !runY.Success:
b.Logf("target succeeds with no changes, fails with all changes")
b.Logf("searching for minimal set of enabled changes causing failure")
broken = runY
b.Disable = false
case !runN.Success && runY.Success:
b.Logf("target fails with no changes, succeeds with all changes")
b.Logf("searching for minimal set of disabled changes causing failure")
broken = runN
b.Disable = true
case runN.Success && runY.Success:
b.Fatalf("target succeeds with no changes and all changes")
case !runN.Success && !runY.Success:
b.Fatalf("target fails with no changes and all changes")
}
// Compute minimum number of bits needed to distinguish
// all the changes we saw during N and all the changes we saw during Y.
b.SkipHexDigits = skipHexDigits(runN.MatchIDs, runY.MatchIDs)
// Loop finding and printing change sets, until none remain.
found := 0
for {
// Find set.
bad := b.search(broken)
if bad == nil {
if found == 0 {
b.Fatalf("cannot find any failing change sets of size ≤ %d", b.MaxSet)
}
break
}
// Confirm that set really does fail, to avoid false accusations.
// Also asking for user-visible output; earlier runs did not.
b.Logf("confirming failing change set")
b.Add = append(b.Add[:0], bad...)
broken = b.Run("v")
if broken.Success {
b.Logf("confirmation run succeeded unexpectedly")
}
b.Add = b.Add[:0]
// Print confirmed change set.
found++
b.Logf("FOUND failing change set")
desc := "(enabling changes causes failure)"
if b.Disable {
desc = "(disabling changes causes failure)"
}
fmt.Fprintf(b.Stdout, "--- change set #%d %s\n%s\n---\n", found, desc, strings.Join(broken.MatchText, "\n"))
// Stop if we've found enough change sets.
if b.Max > 0 && found >= b.Max {
break
}
// If running bisect target | tee bad.txt, prints to stdout and stderr
// both appear on the terminal, but the ones to stdout go through tee
// and can take a little bit of extra time. Sleep 1 millisecond to give
// tee time to catch up, so that its stdout print does not get interlaced
// with the stderr print from the next b.Log message.
time.Sleep(1 * time.Millisecond)
// Disable the now-known-bad changes and see if any failures remain.
b.Logf("checking for more failures")
b.Skip = append(bad, b.Skip...)
broken = b.Run("")
if broken.Success {
what := "enabled"
if b.Disable {
what = "disabled"
}
b.Logf("target succeeds with all remaining changes %s", what)
break
}
b.Logf("target still fails; searching for more bad changes")
}
return true
}
// Fatalf prints a message to standard error and then panics,
// causing Search to return false.
func (b *Bisect) Fatalf(format string, args ...any) {
s := fmt.Sprintf("bisect: fatal error: "+format, args...)
if !strings.HasSuffix(s, "\n") {
s += "\n"
}
b.Stderr.Write([]byte(s))
panic(&searchFatal)
}
// Logf prints a message to standard error.
func (b *Bisect) Logf(format string, args ...any) {
s := fmt.Sprintf("bisect: "+format, args...)
if !strings.HasSuffix(s, "\n") {
s += "\n"
}
b.Stderr.Write([]byte(s))
}
func skipHexDigits(idY, idN []uint64) int {
var all []uint64
seen := make(map[uint64]bool)
for _, x := range idY {
seen[x] = true
all = append(all, x)
}
for _, x := range idN {
if !seen[x] {
seen[x] = true
all = append(all, x)
}
}
sort.Slice(all, func(i, j int) bool { return bits.Reverse64(all[i]) < bits.Reverse64(all[j]) })
digits := sort.Search(64/4, func(digits int) bool {
mask := uint64(1)<<(4*digits) - 1
for i := 0; i+1 < len(all); i++ {
if all[i]&mask == all[i+1]&mask {
return false
}
}
return true
})
if digits < 64/4 {
digits++
}
return digits
}
// search searches for a single locally minimal change set.
//
// Invariant: r describes the result of r.Suffix + b.Add, which failed.
// (There's an implicit -b.Skip everywhere here. b.Skip does not change.)
// We want to extend r.Suffix to preserve the failure, working toward
// a suffix that identifies a single change.
func (b *Bisect) search(r *Result) []string {
// The caller should be passing in a failure result that we diagnose.
if r.Success {
b.Fatalf("internal error: unexpected success") // mistake by caller
}
// If the failure reported no changes, the target is misbehaving.
if len(r.MatchIDs) == 0 {
b.Fatalf("failure with no reported changes:\n\n$ %s\n%s\n", r.Cmd, r.Out)
}
// If there's one matching change, that's the one we're looking for.
if len(r.MatchIDs) == 1 {
return []string{fmt.Sprintf("x%0*x", b.SkipHexDigits, r.MatchIDs[0]&(1<<(4*b.SkipHexDigits)-1))}
}
// If the suffix we were tracking in the trial is already 64 bits,
// either the target is bad or bisect itself is buggy.
if len(r.Suffix) >= 64 {
b.Fatalf("failed to isolate a single change with very long suffix")
}
// We want to split the current matchIDs by left-extending the suffix with 0 and 1.
// If all the matches have the same next bit, that won't cause a split, which doesn't
// break the algorithm but does waste time. Avoid wasting time by left-extending
// the suffix to the longest suffix shared by all the current match IDs
// before adding 0 or 1.
suffix := commonSuffix(r.MatchIDs)
if !strings.HasSuffix(suffix, r.Suffix) {
b.Fatalf("internal error: invalid common suffix") // bug in commonSuffix
}
// Run 0suffix and 1suffix. If one fails, chase down the failure in that half.
r0 := b.Run("0" + suffix)
if !r0.Success {
return b.search(r0)
}
r1 := b.Run("1" + suffix)
if !r1.Success {
return b.search(r1)
}
// suffix failed, but 0suffix and 1suffix succeeded.
// Assuming the target isn't flaky, this means we need
// at least one change from 0suffix AND at least one from 1suffix.
// We are already tracking N = len(b.Add) other changes and are
// allowed to build sets of size at least 1+N (or we shouldn't be here at all).
// If we aren't allowed to build sets of size 2+N, give up this branch.
if b.MaxSet > 0 && 2+len(b.Add) > b.MaxSet {
return nil
}
// Adding all matches for 1suffix, recurse to narrow down 0suffix.
old := len(b.Add)
b.Add = append(b.Add, "1"+suffix)
r0 = b.Run("0" + suffix)
if r0.Success {
// 0suffix + b.Add + 1suffix = suffix + b.Add is what r describes, and it failed.
b.Fatalf("target fails inconsistently")
}
bad0 := b.search(r0)
if bad0 == nil {
// Search failed due to MaxSet limit.
return nil
}
b.Add = b.Add[:old]
// Adding the specific match we found in 0suffix, recurse to narrow down 1suffix.
b.Add = append(b.Add[:old], bad0...)
r1 = b.Run("1" + suffix)
if r1.Success {
// 1suffix + b.Add + bad0 = bad0 + b.Add + 1suffix is what b.search(r0) reported as a failure.
b.Fatalf("target fails inconsistently")
}
bad1 := b.search(r1)
if bad1 == nil {
// Search failed due to MaxSet limit.
return nil
}
b.Add = b.Add[:old]
// bad0 and bad1 together provoke the failure.
return append(bad0, bad1...)
}
// Run runs a set of trials selecting changes with the given suffix,
// plus the ones in b.Add and not the ones in b.Skip.
// The returned result's MatchIDs, MatchText, and MatchFull
// only list the changes that match suffix.
// When b.Count > 1, Run runs b.Count trials and requires
// that they all succeed or they all fail. If not, it calls b.Fatalf.
func (b *Bisect) Run(suffix string) *Result {
out := b.run(suffix)
for i := 1; i < b.Count; i++ {
r := b.run(suffix)
if r.Success != out.Success {
b.Fatalf("target fails inconsistently")
}
}
return out
}
// run runs a single trial for Run.
func (b *Bisect) run(suffix string) *Result {
random := fmt.Sprint(rand.Uint64())
// Accept suffix == "v" to mean we need user-visible output.
visible := ""
if suffix == "v" {
visible = "v"
suffix = ""
}
// Construct change ID pattern.
var pattern string
if suffix == "y" || suffix == "n" {
pattern = suffix
suffix = ""
} else {
var elem []string
if suffix != "" {
elem = append(elem, "+", suffix)
}
for _, x := range b.Add {
elem = append(elem, "+", x)
}
for _, x := range b.Skip {
elem = append(elem, "-", x)
}
pattern = strings.Join(elem, "")
if pattern == "" {
pattern = "y"
}
}
if b.Disable {
pattern = "!" + pattern
}
pattern = visible + pattern
// Construct substituted env and args.
env := make([]string, len(b.Env))
for i, x := range b.Env {
k, v, _ := strings.Cut(x, "=")
env[i] = k + "=" + replace(v, pattern, random)
}
args := make([]string, len(b.Args))
for i, x := range b.Args {
args[i] = replace(x, pattern, random)
}
// Construct and log command line.
// There is no newline in the log print.
// The line will be completed when the command finishes.
cmdText := strings.Join(append(append(env, b.Cmd), args...), " ")
fmt.Fprintf(b.Stderr, "bisect: run: %s...", cmdText)
// Run command with args and env.
var out []byte
var err error
if b.TestRun != nil {
out, err = b.TestRun(env, b.Cmd, args)
} else {
ctx := context.Background()
if b.Timeout != 0 {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, b.Timeout)
defer cancel()
}
cmd := exec.CommandContext(ctx, b.Cmd, args...)
cmd.Env = append(os.Environ(), env...)
// Set up cmd.Cancel, cmd.WaitDelay on Go 1.20 and later
// TODO(rsc): Inline go120.go's cmdInterrupt once we stop supporting Go 1.19.
cmdInterrupt(cmd)
out, err = cmd.CombinedOutput()
}
// Parse output to construct result.
r := &Result{
Suffix: suffix,
Success: err == nil,
Cmd: cmdText,
Out: string(out),
}
// Calculate bits, mask to identify suffix matches.
var bits, mask uint64
if suffix != "" && suffix != "y" && suffix != "n" && suffix != "v" {
var err error
bits, err = strconv.ParseUint(suffix, 2, 64)
if err != nil {
b.Fatalf("internal error: bad suffix")
}
mask = uint64(1<<len(suffix)) - 1
}
// Process output, collecting match reports for suffix.
have := make(map[uint64]bool)
all := r.Out
for all != "" {
var line string
line, all, _ = strings.Cut(all, "\n")
short, id, ok := bisect.CutMarker(line)
if !ok || (id&mask) != bits {
continue
}
if !have[id] {
have[id] = true
r.MatchIDs = append(r.MatchIDs, id)
}
r.MatchText = append(r.MatchText, short)
r.MatchFull = append(r.MatchFull, line)
}
// Finish log print from above, describing the command's completion.
if err == nil {
fmt.Fprintf(b.Stderr, " ok (%d matches)\n", len(r.MatchIDs))
} else {
fmt.Fprintf(b.Stderr, " FAIL (%d matches)\n", len(r.MatchIDs))
}
if err != nil && len(r.MatchIDs) == 0 {
b.Fatalf("target failed without printing any matches\n%s", r.Out)
}
// In verbose mode, print extra debugging: all the lines with match markers.
if b.Verbose {
b.Logf("matches:\n%s", strings.Join(r.MatchFull, "\n\t"))
}
return r
}
// replace returns x with literal text PATTERN and RANDOM replaced by pattern and random.
func replace(x, pattern, random string) string {
x = strings.ReplaceAll(x, "PATTERN", pattern)
x = strings.ReplaceAll(x, "RANDOM", random)
return x
}
// commonSuffix returns the longest common binary suffix shared by all uint64s in list.
// If list is empty, commonSuffix returns an empty string.
func commonSuffix(list []uint64) string {
if len(list) == 0 {
return ""
}
b := list[0]
n := 64
for _, x := range list {
for x&((1<<n)-1) != b {
n--
b &= (1 << n) - 1
}
}
s := make([]byte, n)
for i := n - 1; i >= 0; i-- {
s[i] = '0' + byte(b&1)
b >>= 1
}
return string(s[:])
}
================================================
FILE: cmd/bisect/main_test.go
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"go/build/constraint"
"math/rand"
"os"
"path/filepath"
"strings"
"testing"
"golang.org/x/tools/internal/bisect"
"golang.org/x/tools/internal/diffp"
"golang.org/x/tools/txtar"
)
var update = flag.Bool("update", false, "update testdata with new stdout/stderr")
func Test(t *testing.T) {
files, err := filepath.Glob("testdata/*.txt")
if err != nil {
t.Fatal(err)
}
for _, file := range files {
t.Run(strings.TrimSuffix(filepath.Base(file), ".txt"), func(t *testing.T) {
data, err := os.ReadFile(file)
if err != nil {
t.Fatal(err)
}
a := txtar.Parse(data)
var wantStdout, wantStderr []byte
files := a.Files
if len(files) > 0 && files[0].Name == "stdout" {
wantStdout = files[0].Data
files = files[1:]
}
if len(files) > 0 && files[0].Name == "stderr" {
wantStderr = files[0].Data
files = files[1:]
}
if len(files) > 0 {
t.Fatalf("unexpected txtar entry: %s", files[0].Name)
}
var tt struct {
Fail string
Bisect Bisect
}
if err := json.Unmarshal(a.Comment, &tt); err != nil {
t.Fatal(err)
}
expr, err := constraint.Parse("//go:build " + tt.Fail)
if err != nil {
t.Fatalf("invalid Cmd: %v", err)
}
rnd := rand.New(rand.NewSource(1))
b := &tt.Bisect
b.Cmd = "test"
b.Args = []string{"PATTERN"}
var stdout, stderr bytes.Buffer
b.Stdout = &stdout
b.Stderr = &stderr
b.TestRun = func(env []string, cmd string, args []string) (out []byte, err error) {
pattern := args[0]
m, err := bisect.New(pattern)
if err != nil {
t.Fatal(err)
}
have := make(map[string]bool)
for i, color := range colors {
if m.ShouldEnable(uint64(i)) {
have[color] = true
}
if m.ShouldReport(uint64(i)) {
out = fmt.Appendf(out, "%s %s\n", color, bisect.Marker(uint64(i)))
}
}
err = nil
if eval(rnd, expr, have) {
err = fmt.Errorf("failed")
}
return out, err
}
if !b.Search() {
stderr.WriteString("<bisect failed>\n")
}
rewrite := false
if !bytes.Equal(stdout.Bytes(), wantStdout) {
if *update {
rewrite = true
} else {
t.Errorf("incorrect stdout: %s", diffp.Diff("have", stdout.Bytes(), "want", wantStdout))
}
}
if !bytes.Equal(stderr.Bytes(), wantStderr) {
if *update {
rewrite = true
} else {
t.Errorf("incorrect stderr: %s", diffp.Diff("have", stderr.Bytes(), "want", wantStderr))
}
}
if rewrite {
a.Files = []txtar.File{{Name: "stdout", Data: stdout.Bytes()}, {Name: "stderr", Data: stderr.Bytes()}}
err := os.WriteFile(file, txtar.Format(a), 0666)
if err != nil {
t.Fatal(err)
}
t.Logf("updated %s", file)
}
})
}
}
func eval(rnd *rand.Rand, z constraint.Expr, have map[string]bool) bool {
switch z := z.(type) {
default:
panic(fmt.Sprintf("unexpected type %T", z))
case *constraint.NotExpr:
return !eval(rnd, z.X, have)
case *constraint.AndExpr:
return eval(rnd, z.X, have) && eval(rnd, z.Y, have)
case *constraint.OrExpr:
return eval(rnd, z.X, have) || eval(rnd, z.Y, have)
case *constraint.TagExpr:
if z.Tag == "random" {
return rnd.Intn(2) == 1
}
return have[z.Tag]
}
}
var colors = strings.Fields(`
aliceblue
amaranth
amber
amethyst
applegreen
applered
apricot
aquamarine
azure
babyblue
beige
brickred
black
blue
bluegreen
blueviolet
blush
bronze
brown
burgundy
byzantium
carmine
cerise
cerulean
champagne
chartreusegreen
chocolate
cobaltblue
coffee
copper
coral
crimson
cyan
desertsand
electricblue
emerald
erin
gold
gray
green
harlequin
indigo
ivory
jade
junglegreen
lavender
lemon
lilac
lime
magenta
magentarose
maroon
mauve
navyblue
ochre
olive
orange
orangered
orchid
peach
pear
periwinkle
persianblue
pink
plum
prussianblue
puce
purple
raspberry
red
redviolet
rose
ruby
salmon
sangria
sapphire
scarlet
silver
slategray
springbud
springgreen
tan
taupe
teal
turquoise
ultramarine
violet
viridian
white
yellow
`)
================================================
FILE: cmd/bisect/testdata/README.md
================================================
This directory contains test inputs for the bisect command.
Each text file is a txtar archive (see <https://pkg.go.dev/golang.org/x/tools/txtar>
or `go doc txtar`).
The comment at the top of the archive is a JSON object describing a
target behavior. Specifically, the Fail key gives a boolean expression
that should provoke a failure. Bisect's job is to discover this
condition.
The Bisect key describes settings in the Bisect struct that we want to
change, to simulate the use of various command-line options.
The txtar archive files should be "stdout" and "stderr", giving the
expected standard output and standard error. If the bisect command
should exit with a non-zero status, the stderr in the archive will end
with the line "<bisect failed>".
Running `go test -update` will rewrite the stdout and stderr files in
each testdata archive to match the current state of the tool. This is
a useful command when the logging prints from bisect change or when
writing a new test.
To use `go test -update` to write a new test:
- Create a new .txt file with just a JSON object at the top,
specifying what you want to test.
- Run `go test -update`.
- Reload the .txt file and read the stdout and stderr to see if you agree.
================================================
FILE: cmd/bisect/testdata/basic.txt
================================================
{"Fail": "amber || apricot"}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
--- change set #2 (enabling changes causes failure)
apricot
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x002... FAIL (44 matches)
bisect: run: test +00-x002... ok (23 matches)
bisect: run: test +10-x002... FAIL (21 matches)
bisect: run: test +010-x002... ok (10 matches)
bisect: run: test +110-x002... FAIL (11 matches)
bisect: run: test +0110-x002... FAIL (6 matches)
bisect: run: test +00110-x002... FAIL (3 matches)
bisect: run: test +000110-x002... FAIL (2 matches)
bisect: run: test +0000110-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x006-x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x006-x002... ok (88 matches)
bisect: target succeeds with all remaining changes enabled
================================================
FILE: cmd/bisect/testdata/count2.txt
================================================
{"Fail": "amber || apricot", "Bisect": {"Count": 2}}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
--- change set #2 (enabling changes causes failure)
apricot
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x002... FAIL (89 matches)
bisect: run: test -x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x002... FAIL (44 matches)
bisect: run: test +0-x002... FAIL (44 matches)
bisect: run: test +00-x002... ok (23 matches)
bisect: run: test +00-x002... ok (23 matches)
bisect: run: test +10-x002... FAIL (21 matches)
bisect: run: test +10-x002... FAIL (21 matches)
bisect: run: test +010-x002... ok (10 matches)
bisect: run: test +010-x002... ok (10 matches)
bisect: run: test +110-x002... FAIL (11 matches)
bisect: run: test +110-x002... FAIL (11 matches)
bisect: run: test +0110-x002... FAIL (6 matches)
bisect: run: test +0110-x002... FAIL (6 matches)
bisect: run: test +00110-x002... FAIL (3 matches)
bisect: run: test +00110-x002... FAIL (3 matches)
bisect: run: test +000110-x002... FAIL (2 matches)
bisect: run: test +000110-x002... FAIL (2 matches)
bisect: run: test +0000110-x002... FAIL (1 matches)
bisect: run: test +0000110-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x006-x002... FAIL (1 matches)
bisect: run: test v+x006-x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x006-x002... ok (88 matches)
bisect: run: test -x006-x002... ok (88 matches)
bisect: target succeeds with all remaining changes enabled
================================================
FILE: cmd/bisect/testdata/double.txt
================================================
{"Fail": "amber || apricot && peach"}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
--- change set #2 (enabling changes causes failure)
apricot
peach
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x002... ok (44 matches)
bisect: run: test +1-x002... ok (45 matches)
bisect: run: test +0+1-x002... FAIL (44 matches)
bisect: run: test +00+1-x002... ok (23 matches)
bisect: run: test +10+1-x002... FAIL (21 matches)
bisect: run: test +010+1-x002... ok (10 matches)
bisect: run: test +110+1-x002... FAIL (11 matches)
bisect: run: test +0110+1-x002... FAIL (6 matches)
bisect: run: test +00110+1-x002... FAIL (3 matches)
bisect: run: test +000110+1-x002... FAIL (2 matches)
bisect: run: test +0000110+1-x002... FAIL (1 matches)
bisect: run: test +1+x006-x002... FAIL (45 matches)
bisect: run: test +01+x006-x002... ok (23 matches)
bisect: run: test +11+x006-x002... FAIL (22 matches)
bisect: run: test +011+x006-x002... FAIL (11 matches)
bisect: run: test +0011+x006-x002... ok (6 matches)
bisect: run: test +1011+x006-x002... FAIL (5 matches)
bisect: run: test +01011+x006-x002... ok (3 matches)
bisect: run: test +11011+x006-x002... FAIL (2 matches)
bisect: run: test +011011+x006-x002... ok (1 matches)
bisect: run: test +111011+x006-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x006+x03b-x002... FAIL (2 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x006-x03b-x002... ok (87 matches)
bisect: target succeeds with all remaining changes enabled
================================================
FILE: cmd/bisect/testdata/max1.txt
================================================
{"Fail": "amber || apricot && peach", "Bisect": {"Max": 1}}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
================================================
FILE: cmd/bisect/testdata/max2.txt
================================================
{"Fail": "amber || apricot && peach || red && green && blue || cyan && magenta && yellow && black", "Bisect": {"Max": 2}}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
--- change set #2 (enabling changes causes failure)
blue
green
red
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x002... ok (44 matches)
bisect: run: test +1-x002... FAIL (45 matches)
bisect: run: test +01-x002... ok (23 matches)
bisect: run: test +11-x002... ok (22 matches)
bisect: run: test +01+11-x002... FAIL (23 matches)
bisect: run: test +001+11-x002... ok (12 matches)
bisect: run: test +101+11-x002... FAIL (11 matches)
bisect: run: test +0101+11-x002... ok (6 matches)
bisect: run: test +1101+11-x002... ok (5 matches)
bisect: run: test +0101+11+1101-x002... FAIL (6 matches)
bisect: run: test +00101+11+1101-x002... FAIL (3 matches)
bisect: run: test +000101+11+1101-x002... FAIL (2 matches)
bisect: run: test +0000101+11+1101-x002... ok (1 matches)
bisect: run: test +1000101+11+1101-x002... FAIL (1 matches)
bisect: run: test +1101+11+x045-x002... FAIL (5 matches)
bisect: run: test +01101+11+x045-x002... FAIL (3 matches)
bisect: run: test +001101+11+x045-x002... FAIL (2 matches)
bisect: run: test +0001101+11+x045-x002... FAIL (1 matches)
bisect: run: test +11+x045+x00d-x002... FAIL (22 matches)
bisect: run: test +011+x045+x00d-x002... ok (11 matches)
bisect: run: test +111+x045+x00d-x002... FAIL (11 matches)
bisect: run: test +0111+x045+x00d-x002... FAIL (6 matches)
bisect: run: test +00111+x045+x00d-x002... FAIL (3 matches)
bisect: run: test +000111+x045+x00d-x002... ok (2 matches)
bisect: run: test +100111+x045+x00d-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x045+x00d+x027-x002... FAIL (3 matches)
bisect: FOUND failing change set
================================================
FILE: cmd/bisect/testdata/maxset.txt
================================================
{"Fail": "amber || apricot && peach || red && green && blue || cyan && magenta && yellow && black", "Bisect": {"MaxSet": 3}}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
--- change set #2 (enabling changes causes failure)
blue
green
red
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x002... ok (44 matches)
bisect: run: test +1-x002... FAIL (45 matches)
bisect: run: test +01-x002... ok (23 matches)
bisect: run: test +11-x002... ok (22 matches)
bisect: run: test +01+11-x002... FAIL (23 matches)
bisect: run: test +001+11-x002... ok (12 matches)
bisect: run: test +101+11-x002... FAIL (11 matches)
bisect: run: test +0101+11-x002... ok (6 matches)
bisect: run: test +1101+11-x002... ok (5 matches)
bisect: run: test +0101+11+1101-x002... FAIL (6 matches)
bisect: run: test +00101+11+1101-x002... FAIL (3 matches)
bisect: run: test +000101+11+1101-x002... FAIL (2 matches)
bisect: run: test +0000101+11+1101-x002... ok (1 matches)
bisect: run: test +1000101+11+1101-x002... FAIL (1 matches)
bisect: run: test +1101+11+x045-x002... FAIL (5 matches)
bisect: run: test +01101+11+x045-x002... FAIL (3 matches)
bisect: run: test +001101+11+x045-x002... FAIL (2 matches)
bisect: run: test +0001101+11+x045-x002... FAIL (1 matches)
bisect: run: test +11+x045+x00d-x002... FAIL (22 matches)
bisect: run: test +011+x045+x00d-x002... ok (11 matches)
bisect: run: test +111+x045+x00d-x002... FAIL (11 matches)
bisect: run: test +0111+x045+x00d-x002... FAIL (6 matches)
bisect: run: test +00111+x045+x00d-x002... FAIL (3 matches)
bisect: run: test +000111+x045+x00d-x002... ok (2 matches)
bisect: run: test +100111+x045+x00d-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x045+x00d+x027-x002... FAIL (3 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x045-x00d-x027-x002... FAIL (86 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x045-x00d-x027-x002... ok (44 matches)
bisect: run: test +1-x045-x00d-x027-x002... ok (42 matches)
bisect: run: test +0+1-x045-x00d-x027-x002... FAIL (44 matches)
bisect: run: test +00+1-x045-x00d-x027-x002... FAIL (23 matches)
bisect: run: test +000+1-x045-x00d-x027-x002... ok (12 matches)
bisect: run: test +100+1-x045-x00d-x027-x002... ok (11 matches)
bisect: run: test +000+1+100-x045-x00d-x027-x002... FAIL (12 matches)
bisect: run: test +0000+1+100-x045-x00d-x027-x002... FAIL (6 matches)
bisect: run: test +00000+1+100-x045-x00d-x027-x002... FAIL (3 matches)
bisect: run: test +000000+1+100-x045-x00d-x027-x002... ok (2 matches)
bisect: run: test +100000+1+100-x045-x00d-x027-x002... FAIL (1 matches)
bisect: run: test +100+1+x020-x045-x00d-x027-x002... FAIL (11 matches)
bisect: run: test +0100+1+x020-x045-x00d-x027-x002... ok (6 matches)
bisect: run: test +1100+1+x020-x045-x00d-x027-x002... FAIL (5 matches)
bisect: run: test +01100+1+x020-x045-x00d-x027-x002... FAIL (3 matches)
bisect: run: test +001100+1+x020-x045-x00d-x027-x002... FAIL (2 matches)
bisect: run: test +0001100+1+x020-x045-x00d-x027-x002... FAIL (1 matches)
bisect: run: test +1+x020+x00c-x045-x00d-x027-x002... FAIL (42 matches)
bisect: run: test +01+x020+x00c-x045-x00d-x027-x002... FAIL (21 matches)
bisect: run: test +001+x020+x00c-x045-x00d-x027-x002... FAIL (12 matches)
bisect: run: test +0001+x020+x00c-x045-x00d-x027-x002... ok (6 matches)
bisect: run: test +1001+x020+x00c-x045-x00d-x027-x002... ok (6 matches)
================================================
FILE: cmd/bisect/testdata/maxset1.txt
================================================
{"Fail": "apricot && peach", "Bisect": {"MaxSet": 1}}
-- stdout --
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... ok (45 matches)
bisect: run: test +1... ok (45 matches)
bisect: fatal error: cannot find any failing change sets of size ≤ 1
<bisect failed>
================================================
FILE: cmd/bisect/testdata/maxset4.txt
================================================
{"Fail": "amber || apricot && peach || red && green && blue || cyan && magenta && yellow && black", "Bisect": {"MaxSet": 4}}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
--- change set #2 (enabling changes causes failure)
blue
green
red
---
--- change set #3 (enabling changes causes failure)
black
cyan
magenta
yellow
---
--- change set #4 (enabling changes causes failure)
apricot
peach
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x002... ok (44 matches)
bisect: run: test +1-x002... FAIL (45 matches)
bisect: run: test +01-x002... ok (23 matches)
bisect: run: test +11-x002... ok (22 matches)
bisect: run: test +01+11-x002... FAIL (23 matches)
bisect: run: test +001+11-x002... ok (12 matches)
bisect: run: test +101+11-x002... FAIL (11 matches)
bisect: run: test +0101+11-x002... ok (6 matches)
bisect: run: test +1101+11-x002... ok (5 matches)
bisect: run: test +0101+11+1101-x002... FAIL (6 matches)
bisect: run: test +00101+11+1101-x002... FAIL (3 matches)
bisect: run: test +000101+11+1101-x002... FAIL (2 matches)
bisect: run: test +0000101+11+1101-x002... ok (1 matches)
bisect: run: test +1000101+11+1101-x002... FAIL (1 matches)
bisect: run: test +1101+11+x045-x002... FAIL (5 matches)
bisect: run: test +01101+11+x045-x002... FAIL (3 matches)
bisect: run: test +001101+11+x045-x002... FAIL (2 matches)
bisect: run: test +0001101+11+x045-x002... FAIL (1 matches)
bisect: run: test +11+x045+x00d-x002... FAIL (22 matches)
bisect: run: test +011+x045+x00d-x002... ok (11 matches)
bisect: run: test +111+x045+x00d-x002... FAIL (11 matches)
bisect: run: test +0111+x045+x00d-x002... FAIL (6 matches)
bisect: run: test +00111+x045+x00d-x002... FAIL (3 matches)
bisect: run: test +000111+x045+x00d-x002... ok (2 matches)
bisect: run: test +100111+x045+x00d-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x045+x00d+x027-x002... FAIL (3 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x045-x00d-x027-x002... FAIL (86 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x045-x00d-x027-x002... ok (44 matches)
bisect: run: test +1-x045-x00d-x027-x002... ok (42 matches)
bisect: run: test +0+1-x045-x00d-x027-x002... FAIL (44 matches)
bisect: run: test +00+1-x045-x00d-x027-x002... FAIL (23 matches)
bisect: run: test +000+1-x045-x00d-x027-x002... ok (12 matches)
bisect: run: test +100+1-x045-x00d-x027-x002... ok (11 matches)
bisect: run: test +000+1+100-x045-x00d-x027-x002... FAIL (12 matches)
bisect: run: test +0000+1+100-x045-x00d-x027-x002... FAIL (6 matches)
bisect: run: test +00000+1+100-x045-x00d-x027-x002... FAIL (3 matches)
bisect: run: test +000000+1+100-x045-x00d-x027-x002... ok (2 matches)
bisect: run: test +100000+1+100-x045-x00d-x027-x002... FAIL (1 matches)
bisect: run: test +100+1+x020-x045-x00d-x027-x002... FAIL (11 matches)
bisect: run: test +0100+1+x020-x045-x00d-x027-x002... ok (6 matches)
bisect: run: test +1100+1+x020-x045-x00d-x027-x002... FAIL (5 matches)
bisect: run: test +01100+1+x020-x045-x00d-x027-x002... FAIL (3 matches)
bisect: run: test +001100+1+x020-x045-x00d-x027-x002... FAIL (2 matches)
bisect: run: test +0001100+1+x020-x045-x00d-x027-x002... FAIL (1 matches)
bisect: run: test +1+x020+x00c-x045-x00d-x027-x002... FAIL (42 matches)
bisect: run: test +01+x020+x00c-x045-x00d-x027-x002... FAIL (21 matches)
bisect: run: test +001+x020+x00c-x045-x00d-x027-x002... FAIL (12 matches)
bisect: run: test +0001+x020+x00c-x045-x00d-x027-x002... ok (6 matches)
bisect: run: test +1001+x020+x00c-x045-x00d-x027-x002... ok (6 matches)
bisect: run: test +0001+x020+x00c+1001-x045-x00d-x027-x002... FAIL (6 matches)
bisect: run: test +00001+x020+x00c+1001-x045-x00d-x027-x002... ok (3 matches)
bisect: run: test +10001+x020+x00c+1001-x045-x00d-x027-x002... FAIL (3 matches)
bisect: run: test +010001+x020+x00c+1001-x045-x00d-x027-x002... ok (2 matches)
bisect: run: test +110001+x020+x00c+1001-x045-x00d-x027-x002... FAIL (1 matches)
bisect: run: test +1001+x020+x00c+x031-x045-x00d-x027-x002... FAIL (6 matches)
bisect: run: test +01001+x020+x00c+x031-x045-x00d-x027-x002... ok (3 matches)
bisect: run: test +11001+x020+x00c+x031-x045-x00d-x027-x002... FAIL (3 matches)
bisect: run: test +011001+x020+x00c+x031-x045-x00d-x027-x002... FAIL (2 matches)
bisect: run: test +0011001+x020+x00c+x031-x045-x00d-x027-x002... ok (1 matches)
bisect: run: test +1011001+x020+x00c+x031-x045-x00d-x027-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x020+x00c+x031+x059-x045-x00d-x027-x002... FAIL (4 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (82 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (42 matches)
bisect: run: test +1-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (40 matches)
bisect: run: test +0+1-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (42 matches)
bisect: run: test +00+1-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (21 matches)
bisect: run: test +10+1-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (21 matches)
bisect: run: test +010+1-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (10 matches)
bisect: run: test +110+1-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (11 matches)
bisect: run: test +0110+1-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (6 matches)
bisect: run: test +00110+1-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (3 matches)
bisect: run: test +000110+1-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (2 matches)
bisect: run: test +0000110+1-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (1 matches)
bisect: run: test +1+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (40 matches)
bisect: run: test +01+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (19 matches)
bisect: run: test +11+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (21 matches)
bisect: run: test +011+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (11 matches)
bisect: run: test +0011+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (6 matches)
bisect: run: test +1011+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (5 matches)
bisect: run: test +01011+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (3 matches)
bisect: run: test +11011+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (2 matches)
bisect: run: test +011011+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (1 matches)
bisect: run: test +111011+x006-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x006+x03b-x020-x00c-x031-x059-x045-x00d-x027-x002... FAIL (2 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x006-x03b-x020-x00c-x031-x059-x045-x00d-x027-x002... ok (80 matches)
bisect: target succeeds with all remaining changes enabled
================================================
FILE: cmd/bisect/testdata/negate.txt
================================================
{"Fail": "!amber || !apricot && !peach"}
-- stdout --
--- change set #1 (disabling changes causes failure)
amber
---
--- change set #2 (disabling changes causes failure)
apricot
peach
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... FAIL (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... ok (90 matches)
bisect: target fails with no changes, succeeds with all changes
bisect: searching for minimal set of disabled changes causing failure
bisect: run: test !+0... FAIL (45 matches)
bisect: run: test !+00... ok (23 matches)
bisect: run: test !+10... FAIL (22 matches)
bisect: run: test !+010... FAIL (11 matches)
bisect: run: test !+0010... FAIL (6 matches)
bisect: run: test !+00010... FAIL (3 matches)
bisect: run: test !+000010... FAIL (2 matches)
bisect: run: test !+0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v!+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test !-x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test !+0-x002... ok (44 matches)
bisect: run: test !+1-x002... ok (45 matches)
bisect: run: test !+0+1-x002... FAIL (44 matches)
bisect: run: test !+00+1-x002... ok (23 matches)
bisect: run: test !+10+1-x002... FAIL (21 matches)
bisect: run: test !+010+1-x002... ok (10 matches)
bisect: run: test !+110+1-x002... FAIL (11 matches)
bisect: run: test !+0110+1-x002... FAIL (6 matches)
bisect: run: test !+00110+1-x002... FAIL (3 matches)
bisect: run: test !+000110+1-x002... FAIL (2 matches)
bisect: run: test !+0000110+1-x002... FAIL (1 matches)
bisect: run: test !+1+x006-x002... FAIL (45 matches)
bisect: run: test !+01+x006-x002... ok (23 matches)
bisect: run: test !+11+x006-x002... FAIL (22 matches)
bisect: run: test !+011+x006-x002... FAIL (11 matches)
bisect: run: test !+0011+x006-x002... ok (6 matches)
bisect: run: test !+1011+x006-x002... FAIL (5 matches)
bisect: run: test !+01011+x006-x002... ok (3 matches)
bisect: run: test !+11011+x006-x002... FAIL (2 matches)
bisect: run: test !+011011+x006-x002... ok (1 matches)
bisect: run: test !+111011+x006-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v!+x006+x03b-x002... FAIL (2 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test !-x006-x03b-x002... ok (87 matches)
bisect: target succeeds with all remaining changes disabled
================================================
FILE: cmd/bisect/testdata/rand.txt
================================================
{"Fail": "amber || apricot || blue && random"}
-- stdout --
--- change set #1 (enabling changes causes failure)
amber
---
--- change set #2 (enabling changes causes failure)
apricot
---
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... FAIL (45 matches)
bisect: run: test +00... ok (23 matches)
bisect: run: test +10... FAIL (22 matches)
bisect: run: test +010... FAIL (11 matches)
bisect: run: test +0010... FAIL (6 matches)
bisect: run: test +00010... FAIL (3 matches)
bisect: run: test +000010... FAIL (2 matches)
bisect: run: test +0000010... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x002... FAIL (89 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x002... FAIL (44 matches)
bisect: run: test +00-x002... ok (23 matches)
bisect: run: test +10-x002... FAIL (21 matches)
bisect: run: test +010-x002... ok (10 matches)
bisect: run: test +110-x002... FAIL (11 matches)
bisect: run: test +0110-x002... FAIL (6 matches)
bisect: run: test +00110-x002... FAIL (3 matches)
bisect: run: test +000110-x002... FAIL (2 matches)
bisect: run: test +0000110-x002... FAIL (1 matches)
bisect: confirming failing change set
bisect: run: test v+x006-x002... FAIL (1 matches)
bisect: FOUND failing change set
bisect: checking for more failures
bisect: run: test -x006-x002... FAIL (88 matches)
bisect: target still fails; searching for more bad changes
bisect: run: test +0-x006-x002... ok (43 matches)
bisect: run: test +1-x006-x002... FAIL (45 matches)
bisect: run: test +01-x006-x002... FAIL (23 matches)
bisect: run: test +001-x006-x002... ok (12 matches)
bisect: run: test +101-x006-x002... FAIL (11 matches)
bisect: run: test +0101-x006-x002... ok (6 matches)
bisect: run: test +1101-x006-x002... FAIL (5 matches)
bisect: run: test +01101-x006-x002... ok (3 matches)
bisect: run: test +11101-x006-x002... ok (2 matches)
bisect: run: test +01101+11101-x006-x002... FAIL (3 matches)
bisect: run: test +001101+11101-x006-x002... ok (2 matches)
bisect: run: test +101101+11101-x006-x002... ok (1 matches)
bisect: run: test +001101+11101+101101-x006-x002... ok (2 matches)
bisect: fatal error: target fails inconsistently
<bisect failed>
================================================
FILE: cmd/bisect/testdata/rand1.txt
================================================
{"Fail": "blue && random"}
-- stdout --
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... ok (45 matches)
bisect: run: test +1... FAIL (45 matches)
bisect: run: test +01... FAIL (23 matches)
bisect: run: test +001... ok (12 matches)
bisect: run: test +101... FAIL (11 matches)
bisect: run: test +0101... ok (6 matches)
bisect: run: test +1101... FAIL (5 matches)
bisect: run: test +01101... ok (3 matches)
bisect: run: test +11101... ok (2 matches)
bisect: run: test +01101+11101... FAIL (3 matches)
bisect: run: test +001101+11101... ok (2 matches)
bisect: run: test +101101+11101... ok (1 matches)
bisect: run: test +001101+11101+101101... ok (2 matches)
bisect: fatal error: target fails inconsistently
<bisect failed>
================================================
FILE: cmd/bisect/testdata/rand2.txt
================================================
{"Fail": "blue && random", "Bisect": {"Count": 2}}
-- stdout --
-- stderr --
bisect: checking target with all changes disabled
bisect: run: test n... ok (90 matches)
bisect: run: test n... ok (90 matches)
bisect: checking target with all changes enabled
bisect: run: test y... FAIL (90 matches)
bisect: run: test y... FAIL (90 matches)
bisect: target succeeds with no changes, fails with all changes
bisect: searching for minimal set of enabled changes causing failure
bisect: run: test +0... ok (45 matches)
bisect: run: test +0... ok (45 matches)
bisect: run: test +1... FAIL (45 matches)
bisect: run: test +1... FAIL (45 matches)
bisect: run: test +01... FAIL (23 matches)
bisect: run: test +01... ok (23 matches)
bisect: fatal error: target fails inconsistently
<bisect failed>
================================================
FILE: cmd/bundle/.gitignore
================================================
testdata/out.got
================================================
FILE: cmd/bundle/main.go
================================================
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Bundle creates a single-source-file version of a source package
// suitable for inclusion in a particular target package.
//
// Usage:
//
// bundle [-o file] [-dst path] [-pkg name] [-prefix p] [-import old=new] [-tags build_constraints] <src>
//
// The src argument specifies the import path of the package to bundle.
// The bundling of a directory of source files into a single source file
// necessarily imposes a number of constraints.
// The package being bundled must not use cgo; must not use conditional
// file compilation, whether with build tags or system-specific file names
// like code_amd64.go; must not depend on any special comments, which
// may not be preserved; must not use any assembly sources;
// must not use renaming imports; and must not use reflection-based APIs
// that depend on the specific names of types or struct fields.
//
// By default, bundle writes the bundled code to standard output.
// If the -o argument is given, bundle writes to the named file
// and also includes a “//go:generate” comment giving the exact
// command line used, for regenerating the file with “go generate.”
//
// Bundle customizes its output for inclusion in a particular package, the destination package.
// By default bundle assumes the destination is the package in the current directory,
// but the destination package can be specified explicitly using the -dst option,
// which takes an import path as its argument.
// If the source package imports the destination package, bundle will remove
// those imports and rewrite any references to use direct references to the
// corresponding symbols.
// Bundle also must write a package declaration in the output and must
// choose a name to use in that declaration.
// If the -pkg option is given, bundle uses that name.
// Otherwise, the name of the destination package is used.
// Build constraints for the generated file can be specified using the -tags option.
//
// To avoid collisions, bundle inserts a prefix at the beginning of
// every package-level const, func, type, and var identifier in src's code,
// updating references accordingly. The default prefix is the package name
// of the source package followed by an underscore. The -prefix option
// specifies an alternate prefix.
//
// Occasionally it is necessary to rewrite imports during the bundling
// process. The -import option, which may be repeated, specifies that
// an import of "old" should be rewritten to import "new" instead.
//
// # Example
//
// Bundle archive/zip for inclusion in cmd/dist:
//
// cd $GOROOT/src/cmd/dist
// bundle -o zip.go archive/zip
//
// Bundle golang.org/x/net/http2 for inclusion in net/http,
// prefixing all identifiers by "http2" instead of "http2_", and
// including a "!nethttpomithttp2" build constraint:
//
// cd $GOROOT/src/net/http
// bundle -o h2_bundle.go -prefix http2 -tags '!nethttpomithttp2' golang.org/x/net/http2
//
// Update the http2 bundle in net/http:
//
// go generate net/http
//
// Update all bundles in the standard library:
//
// go generate -run bundle std
package main
import (
"bytes"
"flag"
"fmt"
"go/ast"
"go/format"
"go/printer"
"go/token"
"go/types"
"log"
"os"
"strconv"
"strings"
"unicode"
"golang.org/x/tools/go/packages"
)
var (
outputFile = flag.String("o", "", "write output to `file` (default standard output)")
dstPath = flag.String("dst", ".", "set destination import `path`")
pkgName = flag.String("pkg", "", "set destination package `name`")
prefix = flag.String("prefix", "&_", "set bundled identifier prefix to `p` (default is \"&_\", where & stands for the original name)")
buildTags = flag.String("tags", "", "the build constraints to be inserted into the generated file")
importMap = map[string]string{}
)
func init() {
flag.Var(flagFunc(addImportMap), "import", "rewrite import using `map`, of form old=new (can be repeated)")
}
func addImportMap(s string) {
if strings.Count(s, "=") != 1 {
log.Fatal("-import argument must be of the form old=new")
}
i := strings.Index(s, "=")
old, new := s[:i], s[i+1:]
if old == "" || new == "" {
log.Fatal("-import argument must be of the form old=new; old and new must be non-empty")
}
importMap[old] = new
}
func usage() {
fmt.Fprintf(os.Stderr, "Usage: bundle [options] <src>\n")
flag.PrintDefaults()
}
func main() {
log.SetPrefix("bundle: ")
log.SetFlags(0)
flag.Usage = usage
flag.Parse()
args := flag.Args()
if len(args) != 1 {
usage()
os.Exit(2)
}
cfg := &packages.Config{Mode: packages.NeedName}
pkgs, err := packages.Load(cfg, *dstPath)
if err != nil {
log.Fatalf("cannot load destination package: %v", err)
}
if packages.PrintErrors(pkgs) > 0 || len(pkgs) != 1 {
log.Fatalf("failed to load destination package")
}
if *pkgName == "" {
*pkgName = pkgs[0].Name
}
code, err := bundle(args[0], pkgs[0].PkgPath, *pkgName, *prefix, *buildTags)
if err != nil {
log.Fatal(err)
}
if *outputFile != "" {
err := os.WriteFile(*outputFile, code, 0666)
if err != nil {
log.Fatal(err)
}
} else {
_, err := os.Stdout.Write(code)
if err != nil {
log.Fatal(err)
}
}
}
// isStandardImportPath is copied from cmd/go in the standard library.
func isStandardImportPath(path string) bool {
i := strings.Index(path, "/")
if i < 0 {
i = len(path)
}
elem := path[:i]
return !strings.Contains(elem, ".")
}
var testingOnlyPackagesConfig *packages.Config
func bundle(src, dst, dstpkg, prefix, buildTags string) ([]byte, error) {
// Load the initial package.
cfg := &packages.Config{}
if testingOnlyPackagesConfig != nil {
*cfg = *testingOnlyPackagesConfig
} else {
// Bypass default vendor mode, as we need a package not available in the
// std module vendor folder.
cfg.Env = append(os.Environ(), "GOFLAGS=-mod=mod")
}
cfg.Mode = packages.NeedTypes | packages.NeedSyntax | packages.NeedTypesInfo
pkgs, err := packages.Load(cfg, src)
if err != nil {
return nil, err
}
if packages.PrintErrors(pkgs) > 0 || len(pkgs) != 1 {
return nil, fmt.Errorf("failed to load source package")
}
pkg := pkgs[0]
if strings.Contains(prefix, "&") {
prefix = strings.Replace(prefix, "&", pkg.Syntax[0].Name.Name, -1)
}
objsToUpdate := make(map[types.Object]bool)
var rename func(from types.Object)
rename = func(from types.Object) {
if !objsToUpdate[from] {
objsToUpdate[from] = true
// Renaming a type that is used as an embedded field
// requires renaming the field too. e.g.
// type T int // if we rename this to U..
// var s struct {T}
// print(s.T) // ...this must change too
if _, ok := from.(*types.TypeName); ok {
for id, obj := range pkg.TypesInfo.Uses {
if obj == from {
if field := pkg.TypesInfo.Defs[id]; field != nil {
rename(field)
}
}
}
}
}
}
// Rename each package-level object.
scope := pkg.Types.Scope()
for _, name := range scope.Names() {
rename(scope.Lookup(name))
}
var out bytes.Buffer
if buildTags != "" {
fmt.Fprintf(&out, "//go:build %s\n", buildTags)
}
fmt.Fprintf(&out, "// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.\n")
if *outputFile != "" && buildTags == "" {
fmt.Fprintf(&out, "//go:generate bundle %s\n", strings.Join(quoteArgs(os.Args[1:]), " "))
} else {
fmt.Fprintf(&out, "// $ bundle %s\n", strings.Join(os.Args[1:], " "))
}
fmt.Fprintf(&out, "\n")
// Concatenate package comments from all files...
for _, f := range pkg.Syntax {
if doc := f.Doc.Text(); strings.TrimSpace(doc) != "" {
for line := range strings.SplitSeq(doc, "\n") {
fmt.Fprintf(&out, "// %s\n", line)
}
}
}
// ...but don't let them become the actual package comment.
fmt.Fprintln(&out)
fmt.Fprintf(&out, "package %s\n\n", dstpkg)
// BUG(adonovan,shurcooL): bundle may generate incorrect code
// due to shadowing between identifiers and imported package names.
//
// The generated code will either fail to compile or
// (unlikely) compile successfully but have different behavior
// than the original package. The risk of this happening is higher
// when the original package has renamed imports (they're typically
// renamed in order to resolve a shadow inside that particular .go file).
// TODO(adonovan,shurcooL):
// - detect shadowing issues, and either return error or resolve them
// - preserve comments from the original import declarations.
// pkgStd and pkgExt are sets of printed import specs. This is done
// to deduplicate instances of the same import name and path.
var pkgStd = make(map[string]bool)
var pkgExt = make(map[string]bool)
for _, f := range pkg.Syntax {
for _, imp := range f.Imports {
path, err := strconv.Unquote(imp.Path.Value)
if err != nil {
log.Fatalf("invalid import path string: %v", err) // Shouldn't happen here since packages.Load succeeded.
}
if path == dst {
continue
}
if newPath, ok := importMap[path]; ok {
path = newPath
}
var name string
if imp.Name != nil {
name = imp.Name.Name
}
spec := fmt.Sprintf("%s %q", name, path)
if isStandardImportPath(path) {
pkgStd[spec] = true
} else {
pkgExt[spec] = true
}
}
}
// Print a single declaration that imports all necessary packages.
fmt.Fprintln(&out, "import (")
for p := range pkgStd {
fmt.Fprintf(&out, "\t%s\n", p)
}
if len(pkgExt) > 0 {
fmt.Fprintln(&out)
}
for p := range pkgExt {
fmt.Fprintf(&out, "\t%s\n", p)
}
fmt.Fprint(&out, ")\n\n")
// Modify and print each file.
for _, f := range pkg.Syntax {
// Update renamed identifiers.
for id, obj := range pkg.TypesInfo.Defs {
if objsToUpdate[obj] {
id.Name = prefix + obj.Name()
}
}
for id, obj := range pkg.TypesInfo.Uses {
if objsToUpdate[obj] {
id.Name = prefix + obj.Name()
}
}
// For each qualified identifier that refers to the
// destination package, remove the qualifier.
// The "@@@." strings are removed in postprocessing.
ast.Inspect(f, func(n ast.Node) bool {
if sel, ok := n.(*ast.SelectorExpr); ok {
if id, ok := sel.X.(*ast.Ident); ok {
if obj, ok := pkg.TypesInfo.Uses[id].(*types.PkgName); ok {
if obj.Imported().Path() == dst {
id.Name = "@@@"
}
}
}
}
return true
})
last := f.Package
if len(f.Imports) > 0 {
imp := f.Imports[len(f.Imports)-1]
last = imp.End()
if imp.Comment != nil {
if e := imp.Comment.End(); e > last {
last = e
}
}
}
// Pretty-print package-level declarations.
// but no package or import declarations.
var buf bytes.Buffer
for _, decl := range f.Decls {
if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT {
continue
}
beg, end := sourceRange(decl)
printComments(&out, f.Comments, last, beg)
buf.Reset()
format.Node(&buf, pkg.Fset, &printer.CommentedNode{Node: decl, Comments: f.Comments})
// Remove each "@@@." in the output.
// TODO(adonovan): not hygienic.
out.Write(bytes.Replace(buf.Bytes(), []byte("@@@."), nil, -1))
last = printSameLineComment(&out, f.Comments, pkg.Fset, end)
out.WriteString("\n\n")
}
printLastComments(&out, f.Comments, last)
}
// Now format the entire thing.
result, err := format.Source(out.Bytes())
if err != nil {
log.Fatalf("formatting failed: %v", err)
}
return result, nil
}
// sourceRange returns the [beg, end) interval of source code
// belonging to decl (incl. associated comments).
func sourceRange(decl ast.Decl) (beg, end token.Pos) {
beg = decl.Pos()
end = decl.End()
var doc, com *ast.CommentGroup
switch d := decl.(type) {
case *ast.GenDecl:
doc = d.Doc
if len(d.Specs) > 0 {
switch spec := d.Specs[len(d.Specs)-1].(type) {
case *ast.ValueSpec:
com = spec.Comment
case *ast.TypeSpec:
com = spec.Comment
}
}
case *ast.FuncDecl:
doc = d.Doc
}
if doc != nil {
beg = doc.Pos()
}
if com != nil && com.End() > end {
end = com.End()
}
return beg, end
}
func printComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos, end token.Pos) {
for _, cg := range comments {
if pos <= cg.Pos() && cg.Pos() < end {
for _, c := range cg.List {
fmt.Fprintln(out, c.Text)
}
fmt.Fprintln(out)
}
}
}
const infinity = 1 << 30
func printLastComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos token.Pos) {
printComments(out, comments, pos, infinity)
}
func printSameLineComment(out *bytes.Buffer, comments []*ast.CommentGroup, fset *token.FileSet, pos token.Pos) token.Pos {
tf := fset.File(pos)
for _, cg := range comments {
if pos <= cg.Pos() && tf.Line(cg.Pos()) == tf.Line(pos) {
for _, c := range cg.List {
fmt.Fprintln(out, c.Text)
}
return cg.End()
}
}
return pos
}
func quoteArgs(ss []string) []string {
// From go help generate:
//
// > The arguments to the directive are space-separated tokens or
// > double-quoted strings passed to the generator as individual
// > arguments when it is run.
//
// > Quoted strings use Go syntax and are evaluated before execution; a
// > quoted string appears as a single argument to the generator.
//
var qs []string
for _, s := range ss {
if s == "" || containsSpace(s) {
s = strconv.Quote(s)
}
qs = append(qs, s)
}
return qs
}
func containsSpace(s string) bool {
for _, r := range s {
if unicode.IsSpace(r) {
return true
}
}
return false
}
type flagFunc func(string)
func (f flagFunc) Set(s string) error {
f(s)
return nil
}
func (f flagFunc) String() string { return "" }
================================================
FILE: cmd/bundle/main_test.go
================================================
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"bytes"
"os"
"os/exec"
"runtime"
"testing"
"golang.org/x/tools/internal/packagestest"
)
func TestBundle(t *testing.T) { packagestest.TestAll(t, testBundle) }
func testBundle(t *testing.T, x packagestest.Exporter) {
load := func(name string) string {
data, err := os.ReadFile(name)
if err != nil {
t.Fatal(err)
}
return string(data)
}
e := packagestest.Export(t, x, []packagestest.Module{
{
Name: "initial",
Files: map[string]any{
"a.go": load("testdata/src/initial/a.go"),
"b.go": load("testdata/src/initial/b.go"),
"c.go": load("testdata/src/initial/c.go"),
},
},
{
Name: "domain.name/importdecl",
Files: map[string]any{
"p.go": load("testdata/src/domain.name/importdecl/p.go"),
},
},
})
defer e.Cleanup()
testingOnlyPackagesConfig = e.Config
os.Args = os.Args[:1] // avoid e.g. -test=short in the output
out, err := bundle("initial", "github.com/dest", "dest", "prefix", "tag")
if err != nil {
t.Fatal(err)
}
if got, want := string(out), load("testdata/out.golden"); got != want {
t.Errorf("-- got --\n%s\n-- want --\n%s\n-- diff --", got, want)
if err := os.WriteFile("testdata/out.got", out, 0644); err != nil {
t.Fatal(err)
}
t.Log(diff("testdata/out.golden", "testdata/out.got"))
}
}
func diff(a, b string) string {
var cmd *exec.Cmd
switch runtime.GOOS {
case "plan9":
cmd = exec.Command("/bin/diff", "-c", a, b)
default:
cmd = exec.Command("/usr/bin/diff", "-u", a, b)
}
var out bytes.Buffer
cmd.Stdout = &out
cmd.Stderr = &out
cmd.Run() // nonzero exit is expected
if out.Len() == 0 {
return "(failed to compute diff)"
}
return out.String()
}
================================================
FILE: cmd/bundle/testdata/out.golden
================================================
//go:build tag
// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.
// $ bundle
// The package doc comment
//
package dest
import (
"fmt"
. "fmt"
_ "fmt"
renamedfmt "fmt"
renamedfmt2 "fmt"
"domain.name/importdecl"
)
// init functions are not renamed
func init() { prefixfoo() }
// Type S.
type prefixS struct {
prefixt
u int
} /* multi-line
comment
*/
// non-associated comment
/*
non-associated comment2
*/
// Function bar.
func prefixbar(s *prefixS) {
fmt.Println(s.prefixt, s.u) // comment inside function
}
// file-end comment
type prefixt int // type1
// const1
const prefixc = 1 // const2
func prefixfoo() {
fmt.Println(importdecl.F())
}
// zinit
const (
prefixz1 = iota // z1
prefixz2 // z2
) // zend
func prefixbaz() {
renamedfmt.Println()
renamedfmt2.Println()
Println()
}
================================================
FILE: cmd/bundle/testdata/src/domain.name/importdecl/p.go
================================================
package importdecl
func F() int { return 1 }
================================================
FILE: cmd/bundle/testdata/src/initial/a.go
================================================
package initial
import "fmt" // this comment should not be visible
// init functions are not renamed
func init() { foo() }
// Type S.
type S struct {
t
u int
} /* multi-line
comment
*/
// non-associated comment
/*
non-associated comment2
*/
// Function bar.
func bar(s *S) {
fmt.Println(s.t, s.u) // comment inside function
}
// file-end comment
================================================
FILE: cmd/bundle/testdata/src/initial/b.go
================================================
// The package doc comment
package initial
import (
"fmt"
"domain.name/importdecl"
)
type t int // type1
// const1
const c = 1 // const2
func foo() {
fmt.Println(importdecl.F())
}
// zinit
const (
z1 = iota // z1
z2 // z2
) // zend
================================================
FILE: cmd/bundle/testdata/src/initial/c.go
================================================
package initial
import _ "fmt"
import renamedfmt "fmt"
import renamedfmt2 "fmt"
import . "fmt"
func baz() {
renamedfmt.Println()
renamedfmt2.Println()
Println()
}
================================================
FILE: cmd/callgraph/main.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// callgraph: a tool for reporting the call graph of a Go program.
// See Usage for details, or run with -help.
package main // import "golang.org/x/tools/cmd/callgraph"
// TODO(adonovan):
//
// Features:
// - restrict graph to a single package
// - output
// - functions reachable from root (use digraph tool?)
// - unreachable functions (use digraph tool?)
// - dynamic (runtime) types
// - indexed output (numbered nodes)
// - JSON output
// - additional template fields:
// callee file/line/col
import (
"bytes"
"flag"
"fmt"
"go/token"
"io"
"os"
"runtime"
"text/template"
"golang.org/x/tools/go/callgraph"
"golang.org/x/tools/go/callgraph/cha"
"golang.org/x/tools/go/callgraph/rta"
"golang.org/x/tools/go/callgraph/static"
"golang.org/x/tools/go/callgraph/vta"
"golang.org/x/tools/go/packages"
"golang.org/x/tools/go/ssa"
"golang.org/x/tools/go/ssa/ssautil"
)
// flags
var (
algoFlag = flag.String("algo", "rta",
`Call graph construction algorithm (static, cha, rta, vta)`)
testFlag = flag.Bool("test", false,
"Loads test code (*_test.go) for imported packages")
formatFlag = flag.String("format",
"{{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}",
"A template expression specifying how to format an edge")
tagsFlag = flag.String("tags", "", "comma-separated list of extra build tags (see: go help buildconstraint)")
)
const Usage = `callgraph: display the call graph of a Go program.
Usage:
callgraph [-algo=static|cha|rta|vta] [-test] [-format=...] package...
Flags:
-algo Specifies the call-graph construction algorithm, one of:
static static calls only (unsound)
cha Class Hierarchy Analysis
rta Rapid Type Analysis
vta Variable Type Analysis
The algorithms are ordered by increasing precision in their
treatment of dynamic calls (and thus also computational cost).
RTA requires a whole program (main or test), and
include only functions reachable from main.
-test Include the package's tests in the analysis.
-format Specifies the format in which each call graph edge is displayed.
One of:
digraph output suitable for input to
golang.org/x/tools/cmd/digraph.
graphviz output in AT&T GraphViz (.dot) format.
All other values are interpreted using text/template syntax.
The default value is:
{{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}
The structure passed to the template is (effectively):
type Edge struct {
Caller *ssa.Function // calling function
Callee *ssa.Function // called function
// Call site:
Filename string // containing file
Offset int // offset within file of '('
Line int // line number
Column int // column number of call
Dynamic string // "static" or "dynamic"
Description string // e.g. "static method call"
}
Caller and Callee are *ssa.Function values, which print as
"(*sync/atomic.Mutex).Lock", but other attributes may be
derived from them. For example:
- {{.Caller.Pkg.Pkg.Path}} yields the import path of the
enclosing package; and
- {{(.Caller.Prog.Fset.Position .Caller.Pos).Filename}}
yields the name of the file that declares the caller.
- The 'posn' template function returns the token.Position
of an ssa.Function, so the previous example can be
reduced to {{(posn .Caller).Filename}}.
Consult the documentation for go/token, text/template, and
golang.org/x/tools/go/ssa for more detail.
Examples:
Show the call graph of the trivial web server application:
callgraph -format digraph $GOROOT/src/net/http/triv.go
Same, but show only the packages of each function:
callgraph -format '{{.Caller.Pkg.Pkg.Path}} -> {{.Callee.Pkg.Pkg.Path}}' \
$GOROOT/src/net/http/triv.go | sort | uniq
Show functions that make dynamic calls into the 'fmt' test package,
using the Rapid Type Analysis algorithm:
callgraph -format='{{.Caller}} -{{.Dynamic}}-> {{.Callee}}' -test -algo=rta fmt |
sed -ne 's/-dynamic-/--/p' |
sed -ne 's/-->.*fmt_test.*$//p' | sort | uniq
Show all functions directly called by the callgraph tool's main function:
callgraph -format=digraph golang.org/x/tools/cmd/callgraph |
digraph succs golang.org/x/tools/cmd/callgraph.main
`
func init() {
// If $GOMAXPROCS isn't set, use the full capacity of the machine.
// For small machines, use at least 4 threads.
if os.Getenv("GOMAXPROCS") == "" {
n := max(runtime.NumCPU(), 4)
runtime.GOMAXPROCS(n)
}
}
func main() {
flag.Parse()
if err := doCallgraph("", "", *algoFlag, *formatFlag, *testFlag, flag.Args()); err != nil {
fmt.Fprintf(os.Stderr, "callgraph: %s\n", err)
os.Exit(1)
}
}
var stdout io.Writer = os.Stdout
func doCallgraph(dir, gopath, algo, format string, tests bool, args []string) error {
if len(args) == 0 {
fmt.Fprint(os.Stderr, Usage)
return nil
}
cfg := &packages.Config{
Mode: packages.LoadAllSyntax,
BuildFlags: []string{"-tags=" + *tagsFlag},
Tests: tests,
Dir: dir,
}
if gopath != "" {
cfg.Env = append(os.Environ(), "GOPATH="+gopath) // to enable testing
}
initial, err := packages.Load(cfg, args...)
if err != nil {
return err
}
if packages.PrintErrors(initial) > 0 {
return fmt.Errorf("packages contain errors")
}
// Create and build SSA-form program representation.
mode := ssa.InstantiateGenerics // instantiate generics by default for soundness
prog, pkgs := ssautil.AllPackages(initial, mode)
prog.Build()
// -- call graph construction ------------------------------------------
var cg *callgraph.Graph
switch algo {
case "static":
cg = static.CallGraph(prog)
case "cha":
cg = cha.CallGraph(prog)
case "pta":
return fmt.Errorf("pointer analysis is no longer supported (see Go issue #59676)")
case "rta":
mains, err := mainPackages(pkgs)
if err != nil {
return err
}
var roots []*ssa.Function
for _, main := range mains {
roots = append(roots, main.Func("init"), main.Func("main"))
}
rtares := rta.Analyze(roots, true)
cg = rtares.CallGraph
// NB: RTA gives us Reachable and RuntimeTypes too.
case "vta":
cg = vta.CallGraph(ssautil.AllFunctions(prog), nil)
default:
return fmt.Errorf("unknown algorithm: %s", algo)
}
cg.DeleteSyntheticNodes()
// -- output------------------------------------------------------------
var before, after string
// Pre-canned formats.
switch format {
case "digraph":
format = `{{printf "%q %q" .Caller .Callee}}`
case "graphviz":
before = "digraph callgraph {\n"
after = "}\n"
format = ` {{printf "%q" .Caller}} -> {{printf "%q" .Callee}}`
}
funcMap := template.FuncMap{
"posn": func(f *ssa.Function) token.Position {
return f.Prog.Fset.Position(f.Pos())
},
}
tmpl, err := template.New("-format").Funcs(funcMap).Parse(format)
if err != nil {
return fmt.Errorf("invalid -format template: %v", err)
}
// Allocate these once, outside the traversal.
var buf bytes.Buffer
data := Edge{fset: prog.Fset}
fmt.Fprint(stdout, before)
if err := callgraph.GraphVisitEdges(cg, func(edge *callgraph.Edge) error {
data.position.Offset = -1
data.edge = edge
data.Caller = edge.Caller.Func
data.Callee = edge.Callee.Func
buf.Reset()
if err := tmpl.Execute(&buf, &data); err != nil {
return err
}
stdout.Write(buf.Bytes())
if len := buf.Len(); len == 0 || buf.Bytes()[len-1] != '\n' {
fmt.Fprintln(stdout)
}
return nil
}); err != nil {
return err
}
fmt.Fprint(stdout, after)
return nil
}
// mainPackages returns the main packages to analyze.
// Each resulting package is named "main" and has a main function.
func mainPackages(pkgs []*ssa.Package) ([]*ssa.Package, error) {
var mains []*ssa.Package
for _, p := range pkgs {
if p != nil && p.Pkg.Name() == "main" && p.Func("main") != nil {
mains = append(mains, p)
}
}
if len(mains) == 0 {
return nil, fmt.Errorf("no main packages")
}
return mains, nil
}
type Edge struct {
Caller *ssa.Function
Callee *ssa.Function
edge *callgraph.Edge
fset *token.FileSet
position token.Position // initialized lazily
}
func (e *Edge) pos() *token.Position {
if e.position.Offset == -1 {
e.position = e.fset.Position(e.edge.Pos()) // called lazily
}
return &e.position
}
func (e *Edge) Filename() string { return e.pos().Filename }
func (e *Edge) Column() int { return e.pos().Column }
func (e *Edge) Line() int { return e.pos().Line }
func (e *Edge) Offset() int { return e.pos().Offset }
func (e *Edge) Dynamic() string {
if e.edge.Site != nil && e.edge.Site.Common().StaticCallee() == nil {
return "dynamic"
}
return "static"
}
func (e *Edge) Description() string { return e.edge.Description() }
================================================
FILE: cmd/callgraph/main_test.go
================================================
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// No testdata on Android.
//go:build !android && go1.11
package main
import (
"bytes"
"fmt"
"log"
"os"
"path/filepath"
"strings"
"testing"
"golang.org/x/tools/internal/testenv"
)
func init() {
// This test currently requires GOPATH mode.
// Explicitly disabling module mode should suffix, but
// we'll also turn off GOPROXY just for good measure.
if err := os.Setenv("GO111MODULE", "off"); err != nil {
log.Fatal(err)
}
if err := os.Setenv("GOPROXY", "off"); err != nil {
log.Fatal(err)
}
}
func TestCallgraph(t *testing.T) {
testenv.NeedsTool(t, "go")
gopath, err := filepath.Abs("testdata")
if err != nil {
t.Fatal(err)
}
for _, test := range []struct {
algo string
tests bool
want []string
}{
{"rta", false, []string{
// rta imprecisely shows cross product of {main,main2} x {C,D}
`pkg.main --> (pkg.C).f`,
`pkg.main --> (pkg.D).f`,
`pkg.main --> pkg.main2`,
`pkg.main2 --> (pkg.C).f`,
`pkg.main2 --> (pkg.D).f`,
}},
{"vta", false, []string{
// vta distinguishes main->C, main2->D.
"pkg.main --> (pkg.C).f",
"pkg.main --> pkg.main2",
"pkg.main2 --> (pkg.D).f",
}},
// tests: both the package's main and the test's main are called.
// The callgraph includes all the guts of the "testing" package.
{"rta", true, []string{
`pkg.test.main --> testing.MainStart`,
`testing.runExample --> pkg.Example`,
`pkg.Example --> (pkg.C).f`,
`pkg.main --> (pkg.C).f`,
}},
{"vta", true, []string{
`pkg.test.main --> testing.MainStart`,
`testing.runExample --> pkg.Example`,
`pkg.Example --> (pkg.C).f`,
`pkg.main --> (pkg.C).f`,
}},
} {
const format = "{{.Caller}} --> {{.Callee}}"
stdout = new(bytes.Buffer)
if err := doCallgraph("testdata/src", gopath, test.algo, format, test.tests, []string{"pkg"}); err != nil {
t.Error(err)
continue
}
edges := make(map[string]bool)
for _, line := range strings.Split(fmt.Sprint(stdout), "\n") {
edges[line] = true
}
ok := true
for _, edge := range test.want {
if !edges[edge] {
ok = false
t.Errorf("callgraph(%q, %t): missing edge: %s",
test.algo, test.tests, edge)
}
}
if !ok {
t.Log("got:\n", stdout)
}
}
}
================================================
FILE: cmd/callgraph/testdata/src/pkg/pkg.go
================================================
package main
type I interface {
f()
}
type C int
func (C) f() {}
type D int
func (D) f() {}
func main() {
var i I = C(0)
i.f() // dynamic call
main2()
}
func main2() {
var i I = D(0)
i.f() // dynamic call
}
================================================
FILE: cmd/callgraph/testdata/src/pkg/pkg_test.go
================================================
package main
// An Example function must have an "Output:" comment for the go build
// system to generate a call to it from the test main package.
func Example() {
C(0).f()
// Output:
}
================================================
FILE: cmd/compilebench/main.go
================================================
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Compilebench benchmarks the speed of the Go compiler.
//
// Usage:
//
// compilebench [options]
//
// It times the compilation of various packages and prints results in
// the format used by package testing (and expected by golang.org/x/perf/cmd/benchstat).
//
// The options are:
//
// -alloc
// Report allocations.
//
// -compile exe
// Use exe as the path to the cmd/compile binary.
//
// -compileflags 'list'
// Pass the space-separated list of flags to the compilation.
//
// -link exe
// Use exe as the path to the cmd/link binary.
//
// -linkflags 'list'
// Pass the space-separated list of flags to the linker.
//
// -count n
// Run each benchmark n times (default 1).
//
// -cpuprofile file
// Write a CPU profile of the compiler to file.
//
// -go path
// Path to "go" command (default "go").
//
// -memprofile file
// Write a memory profile of the compiler to file.
//
// -memprofilerate rate
// Set runtime.MemProfileRate during compilation.
//
// -obj
// Report object file statistics.
//
// -pkg pkg
// Benchmark compiling a single package.
//
// -run regexp
// Only run benchmarks with names matching regexp.
//
// -short
// Skip long-running benchmarks.
//
// Although -cpuprofile and -memprofile are intended to write a
// combined profile for all the executed benchmarks to file,
// today they write only the profile for the last benchmark executed.
//
// The default memory profiling rate is one profile sample per 512 kB
// allocated (see “go doc runtime.MemProfileRate”).
// Lowering the rate (for example, -memprofilerate 64000) produces
// a more fine-grained and therefore accurate profile, but it also incurs
// execution cost. For benchmark comparisons, never use timings
// obtained with a low -memprofilerate option.
//
// # Example
//
// Assuming the base version of the compiler has been saved with
// “toolstash save,” this sequence compares the old and new compiler:
//
// compilebench -count 10 -compile $(toolstash -n compile) >old.txt
// compilebench -count 10 >new.txt
// benchstat old.txt new.txt
package main
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"log"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"strconv"
"strings"
"time"
)
var (
goroot string
compiler string
assembler string
linker string
runRE *regexp.Regexp
is6g bool
needCompilingRuntimeFlag bool
)
var (
flagGoCmd = flag.String("go", "go", "path to \"go\" command")
flagAlloc = flag.Bool("alloc", false, "report allocations")
flagObj = flag.Bool("obj", false, "report object file stats")
flagCompiler = flag.String("compile", "", "use `exe` as the cmd/compile binary")
flagAssembler = flag.String("asm", "", "use `exe` as the cmd/asm binary")
flagCompilerFlags = flag.String("compileflags", "", "additional `flags` to pass to compile")
flagLinker = flag.String("link", "", "use `exe` as the cmd/link binary")
flagLinkerFlags = flag.String("linkflags", "", "additional `flags` to pass to link")
flagRun = flag.String("run", "", "run benchmarks matching `regexp`")
flagCount = flag.Int("count", 1, "run benchmarks `n` times")
flagCpuprofile = flag.String("cpuprofile", "", "write CPU profile to `file`")
flagMemprofile = flag.String("memprofile", "", "write memory profile to `file`")
flagMemprofilerate = flag.Int64("memprofilerate", -1, "set memory profile `rate`")
flagPackage = flag.String("pkg", "", "if set, benchmark the package at path `pkg`")
flagShort = flag.Bool("short", false, "skip long-running benchmarks")
flagTrace = flag.Bool("trace", false, "debug tracing of builds")
)
type test struct {
name string
r runner
}
type runner interface {
long() bool
run(name string, count int) error
}
var tests = []test{
{"BenchmarkTemplate", compile{"html/template"}},
{"BenchmarkUnicode", compile{"unicode"}},
{"BenchmarkGoTypes", compile{"go/types"}},
{"BenchmarkCompiler", compile{"cmd/compile/internal/gc"}},
{"BenchmarkSSA", compile{"cmd/compile/internal/ssa"}},
{"BenchmarkFlate", compile{"compress/flate"}},
{"BenchmarkGoParser", compile{"go/parser"}},
{"BenchmarkReflect", compile{"reflect"}},
{"BenchmarkTar", compile{"archive/tar"}},
{"BenchmarkXML", compile{"encoding/xml"}},
{"BenchmarkLinkCompiler", link{"cmd/compile", ""}},
{"BenchmarkExternalLinkCompiler", link{"cmd/compile", "-linkmode=external"}},
{"BenchmarkLinkWithoutDebugCompiler", link{"cmd/compile", "-w"}},
{"BenchmarkStdCmd", goBuild{[]string{"std", "cmd"}}},
{"BenchmarkHelloSize", size{"$GOROOT/test/helloworld.go", false}},
{"BenchmarkCmdGoSize", size{"cmd/go", true}},
}
func usage() {
fmt.Fprintf(os.Stderr, "usage: compilebench [options]\n")
fmt.Fprintf(os.Stderr, "options:\n")
flag.PrintDefaults()
os.Exit(2)
}
func main() {
log.SetFlags(0)
log.SetPrefix("compilebench: ")
flag.Usage = usage
flag.Parse()
if flag.NArg() != 0 {
usage()
}
s, err := exec.Command(*flagGoCmd, "env", "GOROOT").CombinedOutput()
if err != nil {
log.Fatalf("%s env GOROOT: %v", *flagGoCmd, err)
}
goroot = strings.TrimSpace(string(s))
os.Setenv("GOROOT", goroot) // for any subcommands
compiler = *flagCompiler
if compiler == "" {
var foundTool string
foundTool, compiler = toolPath("compile", "6g")
if foundTool == "6g" {
is6g = true
}
}
assembler = *flagAssembler
if assembler == "" {
_, assembler = toolPath("asm")
}
if err := checkCompilingRuntimeFlag(assembler); err != nil {
log.Fatalf("checkCompilingRuntimeFlag: %v", err)
}
linker = *flagLinker
if linker == "" && !is6g { // TODO: Support 6l
_, linker = toolPath("link")
}
if is6g {
*flagMemprofilerate = -1
*flagAlloc = false
*flagCpuprofile = ""
*flagMemprofile = ""
}
if *flagRun != "" {
r, err := regexp.Compile(*flagRun)
if err != nil {
log.Fatalf("invalid -run argument: %v", err)
}
runRE = r
}
if *flagPackage != "" {
tests = []test{
{"BenchmarkPkg", compile{*flagPackage}},
{"BenchmarkPkgLink", link{*flagPackage, ""}},
}
runRE = nil
}
for i := 0; i < *flagCount; i++ {
for _, tt := range tests {
if tt.r.long() && *flagShort {
continue
}
if runRE == nil || runRE.MatchString(tt.name) {
if err := tt.r.run(tt.name, i); err != nil {
log.Printf("%s: %v", tt.name, err)
}
}
}
}
}
func toolPath(names ...string) (found, path string) {
var out1 []byte
var err1 error
for i, name := range names {
out, err := exec.Command(*flagGoCmd, "tool", "-n", name).CombinedOutput()
if err == nil {
return name, strings.TrimSpace(string(out))
}
if i == 0 {
out1, err1 = out, err
}
}
log.Fatalf("go tool -n %s: %v\n%s", names[0], err1, out1)
return "", ""
}
type Pkg struct {
ImportPath string
Dir string
GoFiles []string
SFiles []string
}
func goList(dir string) (*Pkg, error) {
var pkg Pkg
out, err := exec.Command(*flagGoCmd, "list", "-json", dir).Output()
if err != nil {
return nil, fmt.Errorf("go list -json %s: %v", dir, err)
}
if err := json.Unmarshal(out, &pkg); err != nil {
return nil, fmt.Errorf("go list -json %s: unmarshal: %v", dir, err)
}
return &pkg, nil
}
func runCmd(name string, cmd *exec.Cmd) error {
start := time.Now()
out, err := cmd.CombinedOutput()
if err != nil {
return fmt.Errorf("%v\n%s", err, out)
}
fmt.Printf("%s 1 %d ns/op\n", name, time.Since(start).Nanoseconds())
return nil
}
type goBuild struct{ pkgs []string }
func (goBuild) long() bool { return true }
func (r goBuild) run(name string, count int) error {
args := []string{"build", "-a"}
if *flagCompilerFlags != "" {
args = append(args, "-gcflags", *flagCompilerFlags)
}
args = append(args, r.pkgs...)
cmd := exec.Command(*flagGoCmd, args...)
cmd.Dir = filepath.Join(goroot, "src")
return runCmd(name, cmd)
}
type size struct {
// path is either a path to a file ("$GOROOT/test/helloworld.go") or a package path ("cmd/go").
path string
isLong bool
}
func (r size) long() bool { return r.isLong }
func (r size) run(name string, count int) error {
if strings.HasPrefix(r.path, "$GOROOT/") {
r.path = goroot + "/" + r.path[len("$GOROOT/"):]
}
cmd := exec.Command(*flagGoCmd, "build", "-o", "_compilebenchout_", r.path)
cmd.Stdout = os.Stderr
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
return err
}
defer os.Remove("_compilebenchout_")
info, err := os.Stat("_compilebenchout_")
if err != nil {
return err
}
out, err := exec.Command("size", "_compilebenchout_").CombinedOutput()
if err != nil {
return fmt.Errorf("size: %v\n%s", err, out)
}
lines := strings.Split(string(out), "\n")
if len(lines) < 2 {
return fmt.Errorf("not enough output from size: %s", out)
}
f := strings.Fields(lines[1])
if strings.HasPrefix(lines[0], "__TEXT") && len(f) >= 2 { // OS X
fmt.Printf("%s 1 %s text-bytes %s data-bytes %v exe-bytes\n", name, f[0], f[1], info.Size())
} else if strings.Contains(lines[0], "bss") && len(f) >= 3 {
fmt.Printf("%s 1 %s text-bytes %s data-bytes %s bss-bytes %v exe-bytes\n", name, f[0], f[1], f[2], info.Size())
}
return nil
}
type compile struct{ dir string }
func (compile) long() bool { return false }
func (c compile) run(name string, count int) error {
// Make sure dependencies needed by go tool compile are built.
out, err := exec.Command(*flagGoCmd, "build", c.dir).CombinedOutput()
if err != nil {
return fmt.Errorf("go build %s: %v\n%s", c.dir, err, out)
}
// Find dir and source file list.
pkg, err := goList(c.dir)
if err != nil {
return err
}
importcfg, err := genImportcfgFile(c.dir, "", false) // TODO: pass compiler flags?
if err != nil {
return err
}
// If this package has assembly files, we'll need to pass a symabis
// file to the compiler; call a helper to invoke the assembler
// to do that.
var symAbisFile string
var asmIncFile string
if len(pkg.SFiles) != 0 {
symAbisFile = filepath.Join(pkg.Dir, "symabis")
asmIncFile = filepath.Join(pkg.Dir, "go_asm.h")
content := "\n"
if err := os.WriteFile(asmIncFile, []byte(content), 0666); err != nil {
return fmt.Errorf("os.WriteFile(%s) failed: %v", asmIncFile, err)
}
defer os.Remove(symAbisFile)
defer os.Remove(asmIncFile)
if err := genSymAbisFile(pkg, symAbisFile, pkg.Dir); err != nil {
return err
}
}
args := []string{"-o", "_compilebench_.o", "-p", pkg.ImportPath}
args = append(args, strings.Fields(*flagCompilerFlags)...)
if symAbisFile != "" {
args = append(args, "-symabis", symAbisFile)
}
if importcfg != "" {
args = append(args, "-importcfg", importcfg)
defer os.Remove(importcfg)
}
args = append(args, pkg.GoFiles...)
if err := runBuildCmd(name, count, pkg.Dir, compiler, args); err != nil {
return err
}
opath := pkg.Dir + "/_compilebench_.o"
if *flagObj {
// TODO(josharian): object files are big; just read enough to find what we seek.
data, err := os.ReadFile(opath)
if err != nil {
log.Print(err)
}
// Find start of export data.
i := bytes.Index(data, []byte("\n$$B\n")) + len("\n$$B\n")
// Count bytes to end of export data.
nexport := bytes.Index(data[i:], []byte("\n$$\n"))
fmt.Printf(" %d object-bytes %d export-bytes", len(data), nexport)
}
fmt.Println()
os.Remove(opath)
return nil
}
type link struct{ dir, flags string }
func (link) long() bool { return false }
func (r link) run(name string, count int) error {
if linker == "" {
// No linker. Skip the test.
return nil
}
// Build dependencies.
ldflags := *flagLinkerFlags
if r.flags != "" {
if ldflags != "" {
ldflags += " "
}
ldflags += r.flags
}
out, err := exec.Command(*flagGoCmd, "build", "-o", "/dev/null", "-ldflags="+ldflags, r.dir).CombinedOutput()
if err != nil {
return fmt.Errorf("go build -a %s: %v\n%s", r.dir, err, out)
}
importcfg, err := genImportcfgFile(r.dir, "-ldflags="+ldflags, true)
if err != nil {
return err
}
defer os.Remove(importcfg)
// Build the main package.
pkg, err := goList(r.dir)
if err != nil {
return err
}
args := []string{"-o", "_compilebench_.o", "-importcfg", importcfg}
args = append(args, pkg.GoFiles...)
if *flagTrace {
fmt.Fprintf(os.Stderr, "running: %s %+v\n",
compiler, args)
}
cmd := exec.Command(compiler, args...)
cmd.Dir = pkg.Dir
cmd.Stdout = os.Stderr
cmd.Stderr = os.Stderr
err = cmd.Run()
if err != nil {
return fmt.Errorf("compiling: %v", err)
}
defer os.Remove(pkg.Dir + "/_compilebench_.o")
// Link the main package.
args = []string{"-o", "_compilebench_.exe", "-importcfg", importcfg}
args = append(args, strings.Fields(*flagLinkerFlags)...)
args = append(args, strings.Fields(r.flags)...)
args = append(args, "_compilebench_.o")
if err := runBuildCmd(name, count, pkg.Dir, linker, args); err != nil {
return err
}
fmt.Println()
defer os.Remove(pkg.Dir + "/_compilebench_.exe")
return err
}
// runBuildCmd runs "tool args..." in dir, measures standard build
// tool metrics, and prints a benchmark line. The caller may print
// additional metrics and then must print a newline.
//
// This assumes tool accepts standard build tool flags like
// -memprofilerate, -memprofile, and -cpuprofile.
func runBuildCmd(name string, count int, dir, tool string, args []string) error {
var preArgs []string
if *flagMemprofilerate >= 0 {
preArgs = append(preArgs, "-memprofilerate", fmt.Sprint(*flagMemprofilerate))
}
if *flagAlloc || *flagCpuprofile != "" || *flagMemprofile != "" {
if *flagAlloc || *flagMemprofile != "" {
preArgs = append(preArgs, "-memprofile", "_compilebench_.memprof")
}
if *flagCpuprofile != "" {
preArgs = append(preArgs, "-cpuprofile", "_compilebench_.cpuprof")
}
}
if *flagTrace {
fmt.Fprintf(os.Stderr, "running: %s %+v\n",
tool, append(preArgs, args...))
}
cmd := exec.Command(tool, append(preArgs, args...)...)
cmd.Dir = dir
cmd.Stdout = os.Stderr
cmd.Stderr = os.Stderr
start := time.Now()
err := cmd.Run()
if err != nil {
return err
}
end := time.Now()
haveAllocs, haveRSS := false, false
var allocs, allocbytes, rssbytes int64
if *flagAlloc || *flagMemprofile != "" {
out, err := os.ReadFile(dir + "/_compilebench_.memprof")
if err != nil {
log.Print("cannot find memory profile after compilation")
}
for line := range strings.SplitSeq(string(out), "\n") {
f := strings.Fields(line)
if len(f) < 4 || f[0] != "#" || f[2] != "=" {
continue
}
val, err := strconv.ParseInt(f[3], 0, 64)
if err != nil {
continue
}
haveAllocs = true
switch f[1] {
case "TotalAlloc":
allocbytes = val
case "Mallocs":
allocs = val
case "MaxRSS":
haveRSS = true
rssbytes = val
}
}
if !haveAllocs {
log.Println("missing stats in memprof (golang.org/issue/18641)")
}
if *flagMemprofile != "" {
outpath := *flagMemprofile
if *flagCount != 1 {
outpath = fmt.Sprintf("%s_%d", outpath, count)
}
if err := os.WriteFile(outpath, out, 0666); err != nil {
log.Print(err)
}
}
os.Remove(dir + "/_compilebench_.memprof")
}
if *flagCpuprofile != "" {
out, err := os.ReadFile(dir + "/_compilebench_.cpuprof")
if err != nil {
log.Print(err)
}
outpath := *flagCpuprofile
if *flagCount != 1 {
outpath = fmt.Sprintf("%s_%d", outpath, count)
}
if err := os.WriteFile(outpath, out, 0666); err != nil {
log.Print(err)
}
os.Remove(dir + "/_compilebench_.cpuprof")
}
wallns := end.Sub(start).Nanoseconds()
userns := cmd.ProcessState.UserTime().Nanoseconds()
fmt.Printf("%s 1 %d ns/op %d user-ns/op", name, wallns, userns)
if haveAllocs {
fmt.Printf(" %d B/op %d allocs/op", allocbytes, allocs)
}
if haveRSS {
fmt.Printf(" %d maxRSS/op", rssbytes)
}
return nil
}
func checkCompilingRuntimeFlag(assembler string) error {
td, err := os.MkdirTemp("", "asmsrcd")
if err != nil {
return fmt.Errorf("MkdirTemp failed: %v", err)
}
defer os.RemoveAll(td)
src := filepath.Join(td, "asm.s")
obj := filepath.Join(td, "asm.o")
const code = `
TEXT ·foo(SB),$0-0
RET
`
if err := os.WriteFile(src, []byte(code), 0644); err != nil {
return fmt.Errorf("writing %s failed: %v", src, err)
}
// Try compiling the assembly source file passing
// -compiling-runtime; if it succeeds, then we'll need it
// when doing assembly of the reflect package later on.
// If it does not succeed, the assumption is that it's not
// needed.
args := []string{"-o", obj, "-p", "reflect", "-compiling-runtime", src}
cmd := exec.Command(assembler, args...)
cmd.Dir = td
out, aerr := cmd.CombinedOutput()
if aerr != nil {
if strings.Contains(string(out), "flag provided but not defined: -compiling-runtime") {
// flag not defined: assume we're using a recent assembler, so
// don't use -compiling-runtime.
return nil
}
// error is not flag-related; report it.
return fmt.Errorf("problems invoking assembler with args %+v: error %v\n%s\n", args, aerr, out)
}
// asm invocation succeeded -- assume we need the flag.
needCompilingRuntimeFlag = true
return nil
}
// genSymAbisFile runs the assembler on the target package asm files
// with "-gensymabis" to produce a symabis file that will feed into
// the Go source compilation. This is fairly hacky in that if the
// asm invocation convention changes it will need to be updated
// (hopefully that will not be needed too frequently).
func genSymAbisFile(pkg *Pkg, symAbisFile, incdir string) error {
args := []string{"-gensymabis", "-o", symAbisFile,
"-p", pkg.ImportPath,
"-I", filepath.Join(goroot, "pkg", "include"),
"-I", incdir,
"-D", "GOOS_" + runtime.GOOS,
"-D", "GOARCH_" + runtime.GOARCH}
if pkg.ImportPath == "reflect" && needCompilingRuntimeFlag {
args = append(args, "-compiling-runtime")
}
args = append(args, pkg.SFiles...)
if *flagTrace {
fmt.Fprintf(os.Stderr, "running: %s %+v\n",
assembler, args)
}
cmd := exec.Command(assembler, args...)
cmd.Dir = pkg.Dir
cmd.Stdout = os.Stderr
cmd.Stderr = os.Stderr
err := cmd.Run()
if err != nil {
return fmt.Errorf("assembling to produce symabis file: %v", err)
}
return nil
}
// genImportcfgFile generates an importcfg file for building package
// dir. Returns the generated importcfg file path (or empty string
// if the package has no dependency).
func genImportcfgFile(dir string, flags string, full bool) (string, error) {
need := "{{.Imports}}"
if full {
// for linking, we need transitive dependencies
need = "{{.Deps}}"
}
if flags == "" {
flags = "--" // passing "" to go list, it will match to the current directory
}
// find imported/dependent packages
cmd := exec.Command(*flagGoCmd, "list", "-f", need, flags, dir)
cmd.Stderr = os.Stderr
out, err := cmd.Output()
if err != nil {
return "", fmt.Errorf("go list -f %s %s: %v", need, dir, err)
}
// trim [ ]\n
if len(out) < 3 || out[0] != '[' || out[len(out)-2] != ']' || out[len(out)-1] != '\n' {
return "", fmt.Errorf("unexpected output from go list -f %s %s: %s", need, dir, out)
}
out = out[1 : len(out)-2]
if len(out) == 0 {
return "", nil
}
// build importcfg for imported packages
cmd = exec.Command(*flagGoCmd, "list", "-export", "-f", "{{if .Export}}packagefile {{.ImportPath}}={{.Export}}{{end}}", flags)
cmd.Args = append(cmd.Args, strings.Fields(string(out))...)
cmd.Stderr = os.Stderr
out, err = cmd.Output()
if err != nil {
return "", fmt.Errorf("generating importcfg for %s: %s: %v", dir, cmd, err)
}
f, err := os.CreateTemp("", "importcfg")
if err != nil {
return "", fmt.Errorf("creating tmp importcfg file failed: %v", err)
}
defer f.Close()
if _, err := f.Write(out); err != nil {
return "", fmt.Errorf("writing importcfg file %s failed: %v", f.Name(), err)
}
return f.Name(), nil
}
================================================
FILE: cmd/deadcode/deadcode.go
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"bytes"
_ "embed"
"encoding/json"
"flag"
"fmt"
"go/ast"
"go/token"
"go/types"
"io"
"log"
"maps"
"os"
"path/filepath"
"regexp"
"runtime"
"runtime/pprof"
"slices"
"sort"
"strings"
"text/template"
"golang.org/x/telemetry"
"golang.org/x/tools/go/callgraph"
"golang.org/x/tools/go/callgraph/rta"
"golang.org/x/tools/go/packages"
"golang.org/x/tools/go/ssa"
"golang.org/x/tools/go/ssa/ssautil"
"golang.org/x/tools/internal/typesinternal"
)
//go:embed doc.go
var doc string
// flags
var (
testFlag = flag.Bool("test", false, "include implicit test packages and executables")
tagsFlag = flag.String("tags", "", "comma-separated list of extra build tags (see: go help buildconstraint)")
filterFlag = flag.String("filter", "<module>", "report only packages matching this regular expression (default: module of first package)")
generatedFlag = flag.Bool("generated", false, "include dead functions in generated Go files")
whyLiveFlag = flag.String("whylive", "", "show a path from main to the named function")
formatFlag = flag.String("f", "", "format output records using template")
jsonFlag = flag.Bool("json", false, "output JSON records")
cpuProfile = flag.String("cpuprofile", "", "write CPU profile to this file")
memProfile = flag.String("memprofile", "", "write memory profile to this file")
)
func usage() {
// Extract the content of the /* ... */ comment in doc.go.
_, after, _ := strings.Cut(doc, "/*\n")
doc, _, _ := strings.Cut(after, "*/")
io.WriteString(flag.CommandLine.Output(), doc+`
Flags:
`)
flag.PrintDefaults()
}
func main() {
telemetry.Start(telemetry.Config{ReportCrashes: true})
log.SetPrefix("deadcode: ")
log.SetFlags(0) // no time prefix
flag.Usage = usage
flag.Parse()
if len(flag.Args()) == 0 {
usage()
os.Exit(2)
}
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
log.Fatal(err)
}
if err := pprof.StartCPUProfile(f); err != nil {
log.Fatal(err)
}
// NB: profile won't be written in case of error.
defer pprof.StopCPUProfile()
}
if *memProfile != "" {
f, err := os.Create(*memProfile)
if err != nil {
log.Fatal(err)
}
// NB: profile won't be written in case of error.
defer func() {
runtime.GC() // get up-to-date statistics
if err := pprof.WriteHeapProfile(f); err != nil {
log.Fatalf("Writing memory profile: %v", err)
}
f.Close()
}()
}
// Reject bad output options early.
if *formatFlag != "" {
if *jsonFlag {
log.Fatalf("you cannot specify both -f=template and -json")
}
if _, err := template.New("deadcode").Parse(*formatFlag); err != nil {
log.Fatalf("invalid -f: %v", err)
}
}
// Load, parse, and type-check the complete program(s).
cfg := &packages.Config{
BuildFlags: []string{"-tags=" + *tagsFlag},
Mode: packages.LoadAllSyntax | packages.NeedModule,
Tests: *testFlag,
}
initial, err := packages.Load(cfg, flag.Args()...)
if err != nil {
log.Fatalf("Load: %v", err)
}
if len(initial) == 0 {
log.Fatalf("no packages")
}
if packages.PrintErrors(initial) > 0 {
log.Fatalf("packages contain errors")
}
// If -filter is unset, use first module (if available).
if *filterFlag == "<module>" {
seen := make(map[string]bool)
var patterns []string
for _, pkg := range initial {
if pkg.Module != nil && pkg.Module.Path != "" && !seen[pkg.Module.Path] {
seen[pkg.Module.Path] = true
patterns = append(patterns, regexp.QuoteMeta(pkg.Module.Path))
}
}
if patterns != nil {
*filterFlag = "^(" + strings.Join(patterns, "|") + ")\\b"
} else {
*filterFlag = "" // match any
}
}
filter, err := regexp.Compile(*filterFlag)
if err != nil {
log.Fatalf("-filter: %v", err)
}
// Create SSA-form program representation
// and find main packages.
prog, pkgs := ssautil.AllPackages(initial, ssa.InstantiateGenerics)
prog.Build()
mains := ssautil.MainPackages(pkgs)
if len(mains) == 0 {
log.Fatalf("no main packages")
}
var roots []*ssa.Function
for _, main := range mains {
roots = append(roots, main.Func("init"), main.Func("main"))
}
// Gather all source-level functions,
// as the user interface is expressed in terms of them.
//
// We ignore synthetic wrappers, and nested functions. Literal
// functions passed as arguments to other functions are of
// course address-taken and there exists a dynamic call of
// that signature, so when they are unreachable, it is
// invariably because the parent is unreachable.
var (
sourceFuncs []*ssa.Function
generated = make(map[string]bool)
interfaceTypes = make(map[*types.Package][]*types.Interface)
)
packages.Visit(initial, nil, func(p *packages.Package) {
// Collect interfaces by package for marker method identification.
var interfaces []*types.Interface
scope := p.Types.Scope()
for _, name := range scope.Names() {
if typeName, ok := scope.Lookup(name).(*types.TypeName); ok &&
types.IsInterface(typeName.Type()) {
interfaces = append(interfaces, typeName.Type().Underlying().(*types.Interface))
}
}
interfaceTypes[p.Types] = interfaces
for _, file := range p.Syntax {
for _, decl := range file.Decls {
if decl, ok := decl.(*ast.FuncDecl); ok {
obj := p.TypesInfo.Defs[decl.Name].(*types.Func)
fn := prog.FuncValue(obj)
sourceFuncs = append(sourceFuncs, fn)
}
}
if ast.IsGenerated(file) {
generated[p.Fset.File(file.Pos()).Name()] = true
}
}
})
// Compute the reachabilty from main.
// (Build a call graph only for -whylive.)
res := rta.Analyze(roots, *whyLiveFlag != "")
// Subtle: the -test flag causes us to analyze test variants
// such as "package p as compiled for p.test" or even "for q.test".
// This leads to multiple distinct ssa.Function instances that
// represent the same source declaration, and it is essentially
// impossible to discover this from the SSA representation
// (since it has lost the connection to go/packages.Package.ID).
//
// So, we de-duplicate such variants by position:
// if any one of them is live, we consider all of them live.
// (We use Position not Pos to avoid assuming that files common
// to packages "p" and "p [p.test]" were parsed only once.)
reachablePosn := make(map[token.Position]bool)
for fn := range res.Reachable {
if fn.Pos().IsValid() || fn.Name() == "init" {
reachablePosn[prog.Fset.Position(fn.Pos())] = true
}
}
// The -whylive=fn flag causes deadcode to explain why a function
// is not dead, by showing a path to it from some root.
if *whyLiveFlag != "" {
targets := make(map[*ssa.Function]bool)
for _, fn := range sourceFuncs {
if prettyName(fn, true) == *whyLiveFlag {
targets[fn] = true
}
}
if len(targets) == 0 {
// Function is not part of the program.
//
// TODO(adonovan): improve the UX here in case
// of spelling or syntax mistakes. Some ideas:
// - a cmd/callgraph command to enumerate
// available functions.
// - a deadcode -live flag to compute the complement.
// - a syntax hint: example.com/pkg.Func or (example.com/pkg.Type).Method
// - report the element of AllFunctions with the smallest
// Levenshtein distance from *whyLiveFlag.
// - permit -whylive=regexp. But beware of spurious
// matches (e.g. fmt.Print matches fmt.Println)
// and the annoyance of having to quote parens (*T).f.
log.Fatalf("function %q not found in program", *whyLiveFlag)
}
// Opt: remove the unreachable ones.
for fn := range targets {
if !reachablePosn[prog.Fset.Position(fn.Pos())] {
delete(targets, fn)
}
}
if len(targets) == 0 {
log.Fatalf("function %s is dead code", *whyLiveFlag)
}
res.CallGraph.DeleteSyntheticNodes() // inline synthetic wrappers (except inits)
root, path := pathSearch(roots, res, targets)
if root == nil {
// RTA doesn't add callgraph edges for reflective calls.
log.Fatalf("%s is reachable only through reflection", *whyLiveFlag)
}
if len(path) == 0 {
// No edges => one of the targets is a root.
// Rather than (confusingly) print nothing, make this an error.
log.Fatalf("%s is a root", root.Func)
}
// Build a list of jsonEdge records
// to print as -json or -f=template.
var edges []any
for _, edge := range path {
edges = append(edges, jsonEdge{
Initial: cond(len(edges) == 0, prettyName(edge.Caller.Func, true), ""),
Kind: cond(isStaticCall(edge), "static", "dynamic"),
Position: toJSONPosition(prog.Fset.Position(edge.Pos())),
Callee: prettyName(edge.Callee.Func, true),
})
}
format := `{{if .Initial}}{{printf "%19s%s\n" "" .Initial}}{{end}}{{printf "%8s@L%.4d --> %s" .Kind .Position.Line .Callee}}`
if *formatFlag != "" {
format = *formatFlag
}
printObjects(format, edges)
return
}
// Group unreachable functions by package path.
byPkgPath := make(map[string]map[*ssa.Function]bool)
for _, fn := range sourceFuncs {
posn := prog.Fset.Position(fn.Pos())
if !reachablePosn[posn] {
reachablePosn[posn] = true // suppress dups with same pos
pkgpath := fn.Pkg.Pkg.Path()
m, ok := byPkgPath[pkgpath]
if !ok {
m = make(map[*ssa.Function]bool)
byPkgPath[pkgpath] = m
}
m[fn] = true
}
}
// Build array of jsonPackage objects.
var packages []any
for _, pkgpath := range slices.Sorted(maps.Keys(byPkgPath)) {
if !filter.MatchString(pkgpath) {
continue
}
m := byPkgPath[pkgpath]
// Print functions that appear within the same file in
// declaration order. This tends to keep related
// methods such as (T).Marshal and (*T).Unmarshal
// together better than sorting.
fns := slices.Collect(maps.Keys(m))
sort.Slice(fns, func(i, j int) bool {
xposn := prog.Fset.Position(fns[i].Pos())
yposn := prog.Fset.Position(fns[j].Pos())
if xposn.Filename != yposn.Filename {
return xposn.Filename < yposn.Filename
}
return xposn.Line < yposn.Line
})
var functions []jsonFunction
for _, fn := range fns {
posn := prog.Fset.Position(fn.Pos())
// Without -generated, skip functions declared in
// generated Go files.
// (Functions called by them may still be reported.)
gen := generated[posn.Filename]
if gen && !*generatedFlag {
continue
}
// Marker methods should not be reported
marker := isMarkerMethod(fn, interfaceTypes[fn.Pkg.Pkg])
if marker {
continue
}
functions = append(functions, jsonFunction{
Name: prettyName(fn, false),
Position: toJSONPosition(posn),
Generated: gen,
Marker: marker,
})
}
if len(functions) > 0 {
packages = append(packages, jsonPackage{
Name: fns[0].Pkg.Pkg.Name(),
Path: pkgpath,
Funcs: functions,
})
}
}
// Default line-oriented format: "a/b/c.go:1:2: unreachable func: T.f"
format := `{{range .Funcs}}{{printf "%s: unreachable func: %s\n" .Position .Name}}{{end}}`
if *formatFlag != "" {
format = *formatFlag
}
printObjects(format, packages)
}
// prettyName is a fork of Function.String designed to reduce
// go/ssa's fussy punctuation symbols, e.g. "(*pkg.T).F" -> "pkg.T.F".
//
// It only works for functions that remain after
// callgraph.Graph.DeleteSyntheticNodes: source-level named functions
// and methods, their anonymous functions, and synthetic package
// initializers.
func prettyName(fn *ssa.Function, qualified bool) string {
var buf strings.Builder
// optional package qualifier
if qualified && fn.Pkg != nil {
fmt.Fprintf(&buf, "%s.", fn.Pkg.Pkg.Path())
}
var format func(*ssa.Function)
format = func(fn *ssa.Function) {
// anonymous?
if fn.Parent() != nil {
format(fn.Parent())
i := slices.Index(fn.Parent().AnonFuncs, fn)
fmt.Fprintf(&buf, "$%d", i+1)
return
}
// method receiver?
if recv := fn.Signature.Recv(); recv != nil {
_, named := typesinternal.ReceiverNamed(recv)
buf.WriteString(named.Obj().Name())
buf.WriteByte('.')
}
// function/method name
buf.WriteString(fn.Name())
}
format(fn)
return buf.String()
}
// printObjects formats an array of objects, either as JSON or using a
// template, following the manner of 'go list (-json|-f=template)'.
func printObjects(format string, objects []any) {
if *jsonFlag {
out, err := json.MarshalIndent(objects, "", "\t")
if err != nil {
log.Fatalf("internal error: %v", err)
}
os.Stdout.Write(out)
return
}
// -f=template. Parse can't fail: we checked it earlier.
tmpl := template.Must(template.New("deadcode").Parse(format))
for _, object := range objects {
var buf bytes.Buffer
if err := tmpl.Execute(&buf, object); err != nil {
log.Fatal(err)
}
if n := buf.Len(); n == 0 || buf.Bytes()[n-1] != '\n' {
buf.WriteByte('\n')
}
os.Stdout.Write(buf.Bytes())
}
}
// pathSearch returns the shortest path from one of the roots to one
// of the targets (along with the root itself), or zero if no path was found.
func pathSearch(roots []*ssa.Function, res *rta.Result, targets map[*ssa.Function]bool) (*callgraph.Node, []*callgraph.Edge) {
// Search breadth-first (for shortest path) from the root.
//
// We don't use the virtual CallGraph.Root node as we wish to
// choose the order in which we search entrypoints:
// non-test packages before test packages,
// main functions before init functions.
// Sort roots into preferred order.
importsTesting := func(fn *ssa.Function) bool {
isTesting := func(p *types.Package) bool { return p.Path() == "testing" }
return slices.ContainsFunc(fn.Pkg.Pkg.Imports(), isTesting)
}
sort.Slice(roots, func(i, j int) bool {
x, y := roots[i], roots[j]
xtest := importsTesting(x)
ytest := importsTesting(y)
if xtest != ytest {
return !xtest // non-tests before tests
}
xinit := x.Name() == "init"
yinit := y.Name() == "init"
if xinit != yinit {
return !xinit // mains before inits
}
return false
})
search := func(allowDynamic bool) (*callgraph.Node, []*callgraph.Edge) {
// seen maps each encountered node to its predecessor on the
// path to a root node, or to nil for root itself.
seen := make(map[*callgraph.Node]*callgraph.Edge)
bfs := func(root *callgraph.Node) []*callgraph.Edge {
queue := []*callgraph.Node{root}
seen[root] = nil
for len(queue) > 0 {
node := queue[0]
queue = queue[1:]
// found a path?
if targets[node.Func] {
path := []*callgraph.Edge{} // non-nil in case len(path)=0
for {
edge := seen[node]
if edge == nil {
slices.Reverse(path)
return path
}
path = append(path, edge)
node = edge.Caller
}
}
for _, edge := range node.Out {
if allowDynamic || isStaticCall(edge) {
if _, ok := seen[edge.Callee]; !ok {
seen[edge.Callee] = edge
queue = append(queue, edge.Callee)
}
}
}
}
return nil
}
for _, rootFn := range roots {
root := res.CallGraph.Nodes[rootFn]
if root == nil {
// Missing call graph node for root.
// TODO(adonovan): seems like a bug in rta.
continue
}
if path := bfs(root); path != nil {
return root, path
}
}
return nil, nil
}
for _, allowDynamic := range []bool{false, true} {
if root, path := search(allowDynamic); path != nil {
return root, path
}
}
return nil, nil
}
// -- utilities --
func isStaticCall(edge *callgraph.Edge) bool {
return edge.Site != nil && edge.Site.Common().StaticCallee() != nil
}
var cwd, _ = os.Getwd()
func toJSONPosition(posn token.Position) jsonPosition {
// Use cwd-relative filename if possible.
filename := posn.Filename
if rel, err := filepath.Rel(cwd, filename); err == nil && !strings.HasPrefix(rel, "..") {
filename = rel
}
return jsonPosition{filename, posn.Line, posn.Column}
}
func cond[T any](cond bool, t, f T) T {
if cond {
return t
} else {
return f
}
}
// isMarkerMethod reports whether fn is a marker method:
// an unexported, empty-bodied method with no parameters or results
// that implements some named interface type in the same package.
func isMarkerMethod(fn *ssa.Function, interfaceTypes []*types.Interface) bool {
// Is it an unexported method of no params/results?
if !(fn.Signature.Recv() != nil &&
!ast.IsExported(fn.Name()) &&
fn.Signature.Params() == nil &&
fn.Signature.Results() == nil) {
return false
}
// Does the method have an empty body?
body := fn.Syntax().(*ast.FuncDecl).Body
if body == nil || len(body.List) > 0 {
return false
}
// Does it implement some named interface type in this package?
return slices.ContainsFunc(interfaceTypes, func(iface *types.Interface) bool {
return types.Implements(fn.Signature.Recv().Type(), iface)
})
}
// -- output protocol (for JSON or text/template) --
// Keep in sync with doc comment!
type jsonFunction struct {
Name string // name (sans package qualifier)
Position jsonPosition // file/line/column of declaration
Generated bool // function is declared in a generated .go file
Marker bool // function is a marker interface method
}
func (f jsonFunction) String() string { return f.Name }
type jsonPackage struct {
Name string // declared name
Path string // full import path
Funcs []jsonFunction // non-empty list of package's dead functions
}
func (p jsonPackage) String() string { return p.Path }
// The Initial and Callee names are package-qualified.
type jsonEdge struct {
Initial string `json:",omitempty"` // initial entrypoint (main or init); first edge only
Kind string // = static | dynamic
Position jsonPosition
Callee string
}
type jsonPosition struct {
File string
Line, Col int
}
func (p jsonPosition) String() string {
return fmt.Sprintf("%s:%d:%d", p.File, p.Line, p.Col)
}
================================================
FILE: cmd/deadcode/deadcode_test.go
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main_test
import (
"bytes"
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv"
"strings"
"testing"
"golang.org/x/tools/internal/testenv"
"golang.org/x/tools/txtar"
)
// Test runs the deadcode command on each scenario
// described by a testdata/*.txtar file.
func Test(t *testing.T) {
testenv.NeedsTool(t, "go")
if runtime.GOOS == "android" {
t.Skipf("the dependencies are not available on android")
}
exe := buildDeadcode(t)
matches, err := filepath.Glob("testdata/*.txtar")
if err != nil {
t.Fatal(err)
}
for _, filename := range matches {
t.Run(filename, func(t *testing.T) {
t.Parallel()
ar, err := txtar.ParseFile(filename)
if err != nil {
t.Fatal(err)
}
// Write the archive files to the temp directory.
tmpdir := t.TempDir()
for _, f := range ar.Files {
filename := filepath.Join(tmpdir, f.Name)
if err := os.MkdirAll(filepath.Dir(filename), 0777); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filename, f.Data, 0666); err != nil {
t.Fatal(err)
}
}
// Parse archive comment as directives of these forms:
//
// [!]deadcode args... command-line arguments
// [!]want arg expected/unwanted string in output (or stderr)
//
// Args may be Go-quoted strings.
type testcase struct {
linenum int
args []string
wantErr bool
want map[string]bool // string -> sense
}
var cases []*testcase
var current *testcase
for i, line := range strings.Split(string(ar.Comment), "\n") {
line = strings.TrimSpace(line)
if line == "" || line[0] == '#' {
continue // skip blanks and comments
}
words, err := words(line)
if err != nil {
t.Fatalf("cannot break line into words: %v (%s)", err, line)
}
switch kind := words[0]; kind {
case "deadcode", "!deadcode":
current = &testcase{
linenum: i + 1,
want: make(map[string]bool),
args: words[1:],
wantErr: kind[0] == '!',
}
cases = append(cases, current)
case "want", "!want":
if current == nil {
t.Fatalf("'want' directive must be after 'deadcode'")
}
if len(words) != 2 {
t.Fatalf("'want' directive needs argument <<%s>>", line)
}
current.want[words[1]] = kind[0] != '!'
default:
t.Fatalf("%s: invalid directive %q", filename, kind)
}
}
for _, tc := range cases {
t.Run(fmt.Sprintf("L%d", tc.linenum), func(t *testing.T) {
// Run the command.
cmd := exec.Command(exe, tc.args...)
cmd.Stdout = new(bytes.Buffer)
cmd.Stderr = new(bytes.Buffer)
cmd.Dir = tmpdir
cmd.Env = append(os.Environ(), "GOPROXY=", "GO111MODULE=on")
var got string
if err := cmd.Run(); err != nil {
if !tc.wantErr {
t.Fatalf("deadcode failed: %v (stderr=%s)", err, cmd.Stderr)
}
got = fmt.Sprint(cmd.Stderr)
} else {
if tc.wantErr {
t.Fatalf("deadcode succeeded unexpectedly (stdout=%s)", cmd.Stdout)
}
got = fmt.Sprint(cmd.Stdout)
}
// Check each want directive.
for str, sense := range tc.want {
ok := true
if strings.Contains(got, str) != sense {
if sense {
t.Errorf("missing %q", str)
} else {
t.Errorf("unwanted %q", str)
}
ok = false
}
if !ok {
t.Errorf("got: <<%s>>", got)
}
}
})
}
})
}
}
// buildDeadcode builds the deadcode executable.
// It returns its path, and a cleanup function.
func buildDeadcode(t *testing.T) string {
bin := filepath.Join(t.TempDir(), "deadcode")
if runtime.GOOS == "windows" {
bin += ".exe"
}
cmd := exec.Command("go", "build", "-o", bin)
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("Building deadcode: %v\n%s", err, out)
}
return bin
}
// words breaks a string into words, respecting
// Go string quotations around words with spaces.
func words(s string) ([]string, error) {
var words []string
for s != "" {
s = strings.TrimSpace(s)
var word string
if s[0] == '"' || s[0] == '`' {
prefix, err := strconv.QuotedPrefix(s)
if err != nil {
return nil, err
}
s = s[len(prefix):]
word, _ = strconv.Unquote(prefix)
} else {
prefix, rest, _ := strings.Cut(s, " ")
s = rest
word = prefix
}
words = append(words, word)
}
return words, nil
}
================================================
FILE: cmd/deadcode/doc.go
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
The deadcode command reports unreachable functions in Go programs.
Usage: deadcode [flags] package...
The deadcode command loads a Go program from source then uses Rapid
Type Analysis (RTA) to build a call graph of all the functions
reachable from the program's main function. Any functions that are not
reachable are reported as dead code, grouped by package.
Packages are expressed in the notation of 'go list' (or other
underlying build system if you are using an alternative
golang.org/x/go/packages driver). Only executable (main) packages are
considered starting points for the analysis.
The -test flag causes it to analyze test executables too. Tests
sometimes make use of functions that would otherwise appear to be dead
code, and public API functions reported as dead with -test indicate
possible gaps in your test coverage. Bear in mind that an Example test
function without an "Output:" comment is merely documentation:
it is dead code, and does not contribute coverage.
The -filter flag restricts results to packages that match the provided
regular expression; its default value matches the listed packages and any other
packages belonging to the same modules. Use -filter= to display all results.
Example: show all dead code within the gopls module:
$ deadcode -test golang.org/x/tools/gopls/...
The analysis can soundly analyze dynamic calls though func values,
interface methods, and reflection. However, it does not currently
understand the aliasing created by //go:linkname directives, so it
will fail to recognize that calls to a linkname-annotated function
with no body in fact dispatch to the function named in the annotation.
This may result in the latter function being spuriously reported as dead.
By default, the tool does not report dead functions in generated files,
as determined by the special comment described in
https://go.dev/s/generatedcode. Use the -generated flag to include them.
The tool also does not report marker interface methods by default.
Marker interface methods are typically used to create compile-time constraints
to ensure that only specific types can implement a particular interface.
These methods have no other functionality (empty function body) and are never invoked.
Although marker interface methods are technically unreachable, removing them would break
the interface implementation. Hence, the tool excludes them from the report.
In any case, just because a function is reported as dead does not mean
it is unconditionally safe to delete it. For example, a dead function
may be referenced by another dead function, and a dead method may be
required to satisfy an interface that is never called.
Some judgement is required.
The analysis is valid only for a single GOOS/GOARCH/-tags configuration,
so a function reported as dead may be live in a different configuration.
Consider running the tool once for each configuration of interest.
Consider using a line-oriented output format (see below) to make it
easier to compute the intersection of results across all runs.
# Output
The command supports three output formats.
With no flags, the command prints the name and location of each dead
function in the form of a typical compiler diagnostic, for example:
$ deadcode -f='{{range .Funcs}}{{println .Position}}{{end}}' -test ./gopls/...
gopls/internal/protocol/command.go:1206:6: unreachable func: openClientEditor
gopls/internal/template/parse.go:414:18: unreachable func: Parsed.WriteNode
gopls/internal/template/parse.go:419:18: unreachable func: wrNode.writeNode
With the -json flag, the command prints an array of Package
objects, as defined by the JSON schema (see below).
With the -f=template flag, the command executes the specified template
on each Package record. So, this template shows dead functions grouped
by package:
$ deadcode -f='{{println .Path}}{{range .Funcs}}{{printf "\t%s\n" .Name}}{{end}}{{println}}' -test ./gopls/...
golang.org/x/tools/gopls/internal/lsp
openClientEditor
golang.org/x/tools/gopls/internal/template
Parsed.WriteNode
wrNode.writeNode
# Why is a function not dead?
The -whylive=function flag explain why the named function is not dead
by showing an arbitrary shortest path to it from one of the main functions.
(To enumerate the functions in a program, or for more sophisticated
call graph queries, use golang.org/x/tools/cmd/callgraph.)
Fully static call paths are preferred over paths involving dynamic
edges, even if longer. Paths starting from a non-test package are
preferred over those from tests. Paths from main functions are
preferred over paths from init functions.
The result is a list of Edge objects (see JSON schema below).
Again, the -json and -f=template flags may be used to control
the formatting of the list of Edge objects.
The default format shows, for each edge in the path, whether the call
is static or dynamic, and its source line number. For example:
$ deadcode -whylive=bytes.Buffer.String -test ./cmd/deadcode/...
golang.org/x/tools/cmd/deadcode.main
static@L0117 --> golang.org/x/tools/go/packages.Load
static@L0262 --> golang.org/x/tools/go/packages.defaultDriver
static@L0305 --> golang.org/x/tools/go/packages.goListDriver
static@L0153 --> golang.org/x/tools/go/packages.goListDriver$1
static@L0154 --> golang.org/x/tools/go/internal/packagesdriver.GetSizesForArgsGolist
static@L0044 --> bytes.Buffer.String
# JSON schema
type Package struct {
Name string // declared name
Path string // full import path
Funcs []Function // list of dead functions within it
}
type Function struct {
Name string // name (sans package qualifier)
Position Position // file/line/column of function declaration
Generated bool // function is declared in a generated .go file
Marker bool // function is a marker interface method
}
type Edge struct {
Initial string // initial entrypoint (main or init); first edge only
Kind string // = static | dynamic
Position Position // file/line/column of call site
Callee string // target of the call
}
type Position struct {
File string // name of file
Line, Col int // line and byte index, both 1-based
}
*/
package main
================================================
FILE: cmd/deadcode/testdata/basic.txtar
================================================
# Test of basic functionality.
deadcode -filter= example.com
want "T.Goodbye"
want "T.Goodbye2"
want "T.Goodbye3"
!want "T.Hello"
want "unreferenced"
want "Scanf"
want "Printf"
!want "Println"
-- go.mod --
module example.com
go 1.18
-- main.go --
package main
import "fmt"
type T int
func main() {
var x T
x.Hello()
}
func (T) Hello() { fmt.Println("hello") }
func (T) Goodbye() { fmt.Println("goodbye") }
func (*T) Goodbye2() { fmt.Println("goodbye2") }
func (*A) Goodbye3() { fmt.Println("goodbye3") }
type A = T
func unreferenced() {}
================================================
FILE: cmd/deadcode/testdata/filterflag.txtar
================================================
# Test of -filter flag.
deadcode -filter=other.net example.com
want `other.net`
want `Dead`
!want `Live`
!want `example.com`
!want `unreferenced`
-- go.work --
use example.com
use other.net
-- example.com/go.mod --
module example.com
go 1.18
-- example.com/main.go --
package main
import "other.net"
func main() {
other.Live()
}
func unreferenced() {}
-- other.net/go.mod --
module other.net
go 1.18
-- other.net/other.go --
package other
func Live() {}
func Dead() {}
================================================
FILE: cmd/deadcode/testdata/generated.txtar
================================================
# Test of -generated flag output.
deadcode "-f={{range .Funcs}}{{$.Name}}.{{.Name}}{{end}}" example.com
!want "main.main"
want "main.Dead1"
!want "main.Dead2"
deadcode "-f={{range .Funcs}}{{$.Name}}.{{.Name}}{{end}}" -generated example.com
!want "main.main"
want "main.Dead1"
want "main.Dead2"
-- go.mod --
module example.com
go 1.18
-- main.go --
package main
func main() {}
func Dead1() {}
-- gen.go --
// Code generated by hand. DO NOT EDIT.
package main
func Dead2() {}
================================================
FILE: cmd/deadcode/testdata/issue65915.txtar
================================================
# Regression test for issue 65915: the enumeration of source-level
# functions used the flawed ssautil.AllFunctions, causing it to
# miss some unexported ones.
deadcode -filter= example.com
want "unreachable func: example.UnUsed"
want "unreachable func: example.unUsed"
want "unreachable func: PublicExample.UnUsed"
want "unreachable func: PublicExample.unUsed"
-- go.mod --
module example.com
go 1.18
-- main.go --
package main
type example struct{}
func (e example) UnUsed() {}
func (e example) Used() {}
func (e example) unUsed() {}
func (e example) used() {}
type PublicExample struct{}
func (p PublicExample) UnUsed() {}
func (p PublicExample) Used() {}
func (p PublicExample) unUsed() {}
func (p PublicExample) used() {}
func main() {
example{}.Used()
example{}.used()
PublicExample{}.Used()
PublicExample{}.used()
}
================================================
FILE: cmd/deadcode/testdata/issue67915.txt
================================================
# Test of -whylive with reflective call
# (regression test for golang/go#67915).
# The live function is reached via reflection:
deadcode example.com
want "unreachable func: dead"
!want "unreachable func: live"
# Reflective calls have Edge.Site=nil, which formerly led to a crash
# when -whylive would compute its position. Now it has NoPos.
deadcode -whylive=example.com.live example.com
want " example.com.main"
want " static@L0006 --> reflect.Value.Call"
want "dynamic@L0000 --> example.com.live"
-- go.mod --
module example.com
go 1.18
-- main.go --
package main
import "reflect"
func main() {
reflect.ValueOf(live).Call(nil)
}
func live() {
println("hello")
}
func dead() {
println("goodbye")
}
================================================
FILE: cmd/deadcode/testdata/issue73652.txtar
================================================
# Test deadcode usage under go.work.
deadcode ./svc/... ./lib/...
want "unreachable func: A"
# different order of path under the same go.work should behave the same.
deadcode ./svc/... ./lib/...
want "unreachable func: A"
-- go.work --
go 1.18
use (
./lib
./svc
)
-- lib/go.mod --
module lib.com
go 1.18
-- lib/a/a.go --
package a
func A() {}
-- svc/go.mod --
module svc.com
go 1.18
-- svc/s/main.go --
package main
func main() { println("ma
gitextract_5udc9x7r/
├── .gitattributes
├── .gitignore
├── .prettierrc
├── CONTRIBUTING.md
├── LICENSE
├── PATENTS
├── README.md
├── benchmark/
│ └── parse/
│ ├── parse.go
│ └── parse_test.go
├── blog/
│ ├── atom/
│ │ └── atom.go
│ ├── blog.go
│ └── blog_test.go
├── cmd/
│ ├── benchcmp/
│ │ ├── benchcmp.go
│ │ ├── benchcmp_test.go
│ │ ├── compare.go
│ │ ├── compare_test.go
│ │ └── doc.go
│ ├── bisect/
│ │ ├── go120.go
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ ├── README.md
│ │ ├── basic.txt
│ │ ├── count2.txt
│ │ ├── double.txt
│ │ ├── max1.txt
│ │ ├── max2.txt
│ │ ├── maxset.txt
│ │ ├── maxset1.txt
│ │ ├── maxset4.txt
│ │ ├── negate.txt
│ │ ├── rand.txt
│ │ ├── rand1.txt
│ │ └── rand2.txt
│ ├── bundle/
│ │ ├── .gitignore
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ ├── out.golden
│ │ └── src/
│ │ ├── domain.name/
│ │ │ └── importdecl/
│ │ │ └── p.go
│ │ └── initial/
│ │ ├── a.go
│ │ ├── b.go
│ │ └── c.go
│ ├── callgraph/
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ └── src/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── pkg_test.go
│ ├── compilebench/
│ │ └── main.go
│ ├── deadcode/
│ │ ├── deadcode.go
│ │ ├── deadcode_test.go
│ │ ├── doc.go
│ │ └── testdata/
│ │ ├── basic.txtar
│ │ ├── filterflag.txtar
│ │ ├── generated.txtar
│ │ ├── issue65915.txtar
│ │ ├── issue67915.txt
│ │ ├── issue73652.txtar
│ │ ├── jsonflag.txtar
│ │ ├── lineflag.txtar
│ │ ├── marker.txtar
│ │ ├── testflag.txtar
│ │ └── whylive.txtar
│ ├── digraph/
│ │ ├── digraph.go
│ │ ├── digraph_test.go
│ │ └── doc.go
│ ├── eg/
│ │ └── eg.go
│ ├── file2fuzz/
│ │ ├── main.go
│ │ └── main_test.go
│ ├── fiximports/
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ └── src/
│ │ ├── fruit.io/
│ │ │ ├── banana/
│ │ │ │ └── banana.go
│ │ │ ├── orange/
│ │ │ │ └── orange.go
│ │ │ └── pear/
│ │ │ └── pear.go
│ │ ├── new.com/
│ │ │ └── one/
│ │ │ └── one.go
│ │ ├── old.com/
│ │ │ ├── bad/
│ │ │ │ └── bad.go
│ │ │ └── one/
│ │ │ └── one.go
│ │ └── titanic.biz/
│ │ ├── bar/
│ │ │ └── bar.go
│ │ └── foo/
│ │ └── foo.go
│ ├── go-contrib-init/
│ │ ├── contrib.go
│ │ └── contrib_test.go
│ ├── godex/
│ │ ├── doc.go
│ │ ├── gc.go
│ │ ├── gccgo.go
│ │ ├── godex.go
│ │ ├── isAlias18.go
│ │ ├── isAlias19.go
│ │ ├── print.go
│ │ ├── source.go
│ │ └── writetype.go
│ ├── goimports/
│ │ ├── doc.go
│ │ ├── goimports.go
│ │ ├── goimports_gc.go
│ │ └── goimports_not_gc.go
│ ├── gomvpkg/
│ │ └── main.go
│ ├── gonew/
│ │ ├── main.go
│ │ ├── main_test.go
│ │ └── testdata/
│ │ └── quote.txt
│ ├── gotype/
│ │ ├── gotype.go
│ │ ├── sizesFor18.go
│ │ └── sizesFor19.go
│ ├── goyacc/
│ │ ├── doc.go
│ │ ├── testdata/
│ │ │ └── expr/
│ │ │ ├── README
│ │ │ ├── expr.y
│ │ │ └── main.go
│ │ └── yacc.go
│ ├── html2article/
│ │ └── conv.go
│ ├── present/
│ │ ├── dir.go
│ │ ├── doc.go
│ │ ├── main.go
│ │ ├── play.go
│ │ ├── static/
│ │ │ ├── article.css
│ │ │ ├── dir.css
│ │ │ ├── dir.js
│ │ │ ├── jquery-ui.js
│ │ │ ├── jquery.js
│ │ │ ├── notes.css
│ │ │ ├── notes.js
│ │ │ ├── play.js
│ │ │ ├── playground.js
│ │ │ ├── slides.js
│ │ │ └── styles.css
│ │ └── templates/
│ │ ├── action.tmpl
│ │ ├── article.tmpl
│ │ ├── dir.tmpl
│ │ └── slides.tmpl
│ ├── present2md/
│ │ └── main.go
│ ├── signature-fuzzer/
│ │ ├── README.md
│ │ ├── fuzz-driver/
│ │ │ ├── driver.go
│ │ │ └── drv_test.go
│ │ ├── fuzz-runner/
│ │ │ ├── rnr_test.go
│ │ │ ├── runner.go
│ │ │ └── testdata/
│ │ │ └── himom.go
│ │ └── internal/
│ │ └── fuzz-generator/
│ │ ├── arrayparm.go
│ │ ├── gen_test.go
│ │ ├── generator.go
│ │ ├── mapparm.go
│ │ ├── numparm.go
│ │ ├── parm.go
│ │ ├── pointerparm.go
│ │ ├── stringparm.go
│ │ ├── structparm.go
│ │ ├── typedefparm.go
│ │ └── wraprand.go
│ ├── splitdwarf/
│ │ ├── internal/
│ │ │ └── macho/
│ │ │ ├── fat.go
│ │ │ ├── file.go
│ │ │ ├── file_test.go
│ │ │ ├── macho.go
│ │ │ ├── reloctype.go
│ │ │ ├── reloctype_string.go
│ │ │ └── testdata/
│ │ │ ├── clang-386-darwin-exec-with-rpath
│ │ │ ├── clang-386-darwin.obj
│ │ │ ├── clang-amd64-darwin-exec-with-rpath
│ │ │ ├── clang-amd64-darwin.obj
│ │ │ ├── fat-gcc-386-amd64-darwin-exec
│ │ │ ├── gcc-386-darwin-exec
│ │ │ ├── gcc-amd64-darwin-exec
│ │ │ ├── gcc-amd64-darwin-exec-debug
│ │ │ └── hello.c
│ │ └── splitdwarf.go
│ ├── ssadump/
│ │ └── main.go
│ ├── stress/
│ │ └── stress.go
│ ├── stringer/
│ │ ├── endtoend_test.go
│ │ ├── golden_test.go
│ │ ├── multifile_test.go
│ │ ├── stringer.go
│ │ ├── testdata/
│ │ │ ├── cgo.go
│ │ │ ├── conv.go
│ │ │ ├── conv2.go
│ │ │ ├── day.go
│ │ │ ├── gap.go
│ │ │ ├── int8overflow.go
│ │ │ ├── num.go
│ │ │ ├── number.go
│ │ │ ├── prime.go
│ │ │ ├── prime2.go
│ │ │ ├── tag_main.go
│ │ │ ├── tag_tag.go
│ │ │ ├── unum.go
│ │ │ ├── unum2.go
│ │ │ └── vary_day.go
│ │ └── util_test.go
│ └── toolstash/
│ ├── buildall
│ ├── cmp.go
│ └── main.go
├── codereview.cfg
├── container/
│ └── intsets/
│ ├── export_test.go
│ ├── sparse.go
│ └── sparse_test.go
├── copyright/
│ ├── copyright.go
│ └── copyright_test.go
├── cover/
│ ├── profile.go
│ └── profile_test.go
├── go/
│ ├── analysis/
│ │ ├── analysis.go
│ │ ├── analysistest/
│ │ │ ├── analysistest.go
│ │ │ └── analysistest_test.go
│ │ ├── checker/
│ │ │ ├── checker.go
│ │ │ ├── checker_test.go
│ │ │ ├── example_test.go
│ │ │ └── print.go
│ │ ├── diagnostic.go
│ │ ├── doc/
│ │ │ └── suggested_fixes.md
│ │ ├── doc.go
│ │ ├── internal/
│ │ │ ├── analysisflags/
│ │ │ │ ├── flags.go
│ │ │ │ ├── flags_test.go
│ │ │ │ └── help.go
│ │ │ ├── checker/
│ │ │ │ ├── checker.go
│ │ │ │ ├── checker_test.go
│ │ │ │ ├── fix_test.go
│ │ │ │ ├── start_test.go
│ │ │ │ └── testdata/
│ │ │ │ ├── conflict.txt
│ │ │ │ ├── diff.txt
│ │ │ │ ├── fixes.txt
│ │ │ │ ├── generated.txt
│ │ │ │ ├── importdup.txt
│ │ │ │ ├── importdup2.txt
│ │ │ │ ├── json.txt
│ │ │ │ ├── noend.txt
│ │ │ │ ├── overlap.txt
│ │ │ │ └── plain.txt
│ │ │ ├── internal.go
│ │ │ └── versiontest/
│ │ │ └── version_test.go
│ │ ├── multichecker/
│ │ │ ├── multichecker.go
│ │ │ └── multichecker_test.go
│ │ ├── passes/
│ │ │ ├── README
│ │ │ ├── appends/
│ │ │ │ ├── appends.go
│ │ │ │ ├── appends_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── asmdecl/
│ │ │ │ ├── asmdecl.go
│ │ │ │ ├── asmdecl_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── asm.go
│ │ │ │ ├── asm1.s
│ │ │ │ ├── asm10.s
│ │ │ │ ├── asm11.s
│ │ │ │ ├── asm2.s
│ │ │ │ ├── asm3.s
│ │ │ │ ├── asm4.s
│ │ │ │ ├── asm5.s
│ │ │ │ ├── asm6.s
│ │ │ │ ├── asm7.s
│ │ │ │ ├── asm8.s
│ │ │ │ └── asm9.s
│ │ │ ├── assign/
│ │ │ │ ├── assign.go
│ │ │ │ ├── assign_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── typeparams.go
│ │ │ │ └── typeparams.go.golden
│ │ │ ├── atomic/
│ │ │ │ ├── atomic.go
│ │ │ │ ├── atomic_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── atomicalign/
│ │ │ │ ├── atomicalign.go
│ │ │ │ ├── atomicalign_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── stub.go
│ │ │ │ └── b/
│ │ │ │ ├── b.go
│ │ │ │ └── stub.go
│ │ │ ├── bools/
│ │ │ │ ├── bools.go
│ │ │ │ ├── bools_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── buildssa/
│ │ │ │ ├── buildssa.go
│ │ │ │ ├── buildssa_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── buildtag/
│ │ │ │ ├── buildtag.go
│ │ │ │ ├── buildtag_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── buildtag.go
│ │ │ │ │ ├── buildtag2.go
│ │ │ │ │ ├── buildtag3.go
│ │ │ │ │ ├── buildtag4.go
│ │ │ │ │ ├── buildtag5.go
│ │ │ │ │ ├── buildtag6.s
│ │ │ │ │ ├── buildtag7.s
│ │ │ │ │ └── buildtag8.s
│ │ │ │ └── b/
│ │ │ │ ├── vers.go
│ │ │ │ ├── vers1.go
│ │ │ │ ├── vers2.go
│ │ │ │ ├── vers3.go
│ │ │ │ ├── vers4.go
│ │ │ │ ├── vers5.go
│ │ │ │ └── vers6.go
│ │ │ ├── cgocall/
│ │ │ │ ├── cgocall.go
│ │ │ │ ├── cgocall_go120.go
│ │ │ │ ├── cgocall_go121.go
│ │ │ │ ├── cgocall_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── cgo.go
│ │ │ │ │ └── cgo3.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ ├── c/
│ │ │ │ │ └── c.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── composite/
│ │ │ │ ├── composite.go
│ │ │ │ ├── composite_test.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ ├── a.go.golden
│ │ │ │ │ │ ├── a_fuzz_test.go
│ │ │ │ │ │ └── a_fuzz_test.go.golden
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── lib/
│ │ │ │ │ │ └── lib.go
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── typeparams.go.golden
│ │ │ │ └── whitelist.go
│ │ │ ├── copylock/
│ │ │ │ ├── copylock.go
│ │ │ │ ├── copylock_test.go
│ │ │ │ ├── main.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── copylock.go
│ │ │ │ │ ├── copylock_func.go
│ │ │ │ │ ├── copylock_range.go
│ │ │ │ │ ├── issue61678.go
│ │ │ │ │ └── newexpr_go126.go
│ │ │ │ ├── forstmt/
│ │ │ │ │ ├── go21.txtar
│ │ │ │ │ └── go22.txtar
│ │ │ │ ├── issue67787/
│ │ │ │ │ └── issue67787.go
│ │ │ │ ├── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ └── unfortunate/
│ │ │ │ ├── local_go123.go
│ │ │ │ └── local_go124.go
│ │ │ ├── ctrlflow/
│ │ │ │ ├── ctrlflow.go
│ │ │ │ ├── ctrlflow_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── lib/
│ │ │ │ │ └── lib.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── deepequalerrors/
│ │ │ │ ├── deepequalerrors.go
│ │ │ │ ├── deepequalerrors_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── defers/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── defers/
│ │ │ │ │ └── main.go
│ │ │ │ ├── defers.go
│ │ │ │ ├── defers_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── directive/
│ │ │ │ ├── directive.go
│ │ │ │ ├── directive_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── badspace.go
│ │ │ │ ├── issue66046.go
│ │ │ │ ├── misplaced.go
│ │ │ │ ├── misplaced.s
│ │ │ │ ├── misplaced_test.go
│ │ │ │ └── p.go
│ │ │ ├── errorsas/
│ │ │ │ ├── errorsas.go
│ │ │ │ ├── errorsas_test.go
│ │ │ │ ├── main.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── fieldalignment/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── fieldalignment/
│ │ │ │ │ └── main.go
│ │ │ │ ├── fieldalignment.go
│ │ │ │ ├── fieldalignment_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ ├── a.go.golden
│ │ │ │ ├── a_386.go
│ │ │ │ ├── a_386.go.golden
│ │ │ │ ├── a_amd64.go
│ │ │ │ └── a_amd64.go.golden
│ │ │ ├── findcall/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── findcall/
│ │ │ │ │ └── main.go
│ │ │ │ ├── findcall.go
│ │ │ │ ├── findcall_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── framepointer/
│ │ │ │ ├── framepointer.go
│ │ │ │ ├── framepointer_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── asm.go
│ │ │ │ ├── asm_amd64.s
│ │ │ │ ├── asm_arm64.s
│ │ │ │ ├── asm_darwin_amd64.s
│ │ │ │ ├── asm_linux_amd64.s
│ │ │ │ ├── asm_windows_amd64.s
│ │ │ │ └── buildtag_amd64.s
│ │ │ ├── gofix/
│ │ │ │ ├── doc.go
│ │ │ │ ├── gofix.go
│ │ │ │ ├── gofix_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── hostport/
│ │ │ │ ├── hostport.go
│ │ │ │ ├── hostport_test.go
│ │ │ │ ├── main.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── httpmux/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── httpmux/
│ │ │ │ │ └── main.go
│ │ │ │ ├── httpmux.go
│ │ │ │ ├── httpmux_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── httpresponse/
│ │ │ │ ├── httpresponse.go
│ │ │ │ ├── httpresponse_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── ifaceassert/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── ifaceassert/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── ifaceassert.go
│ │ │ │ ├── ifaceassert_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── inline/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── inline/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── inline.go
│ │ │ │ ├── inline_test.go
│ │ │ │ ├── issue77844_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ ├── a.go.golden
│ │ │ │ │ └── internal/
│ │ │ │ │ └── d.go
│ │ │ │ ├── b/
│ │ │ │ │ ├── b.go
│ │ │ │ │ └── b.go.golden
│ │ │ │ ├── binding_false/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── binding_true/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── c/
│ │ │ │ │ └── c.go
│ │ │ │ ├── directive/
│ │ │ │ │ ├── directive.go
│ │ │ │ │ └── directive.go.golden
│ │ │ │ ├── issue76190.txtar
│ │ │ │ ├── issue77610.txtar
│ │ │ │ ├── issue77844.txtar
│ │ │ │ └── rmimport/
│ │ │ │ ├── rmimport.go
│ │ │ │ └── rmimport.go.golden
│ │ │ ├── inspect/
│ │ │ │ └── inspect.go
│ │ │ ├── internal/
│ │ │ │ └── gofixdirective/
│ │ │ │ └── gofixdirective.go
│ │ │ ├── loopclosure/
│ │ │ │ ├── doc.go
│ │ │ │ ├── loopclosure.go
│ │ │ │ ├── loopclosure_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── b.go
│ │ │ │ ├── golang.org/
│ │ │ │ │ └── x/
│ │ │ │ │ └── sync/
│ │ │ │ │ └── errgroup/
│ │ │ │ │ └── errgroup.go
│ │ │ │ ├── subtests/
│ │ │ │ │ └── subtest.go
│ │ │ │ ├── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ └── versions/
│ │ │ │ ├── go18.txtar
│ │ │ │ └── go22.txtar
│ │ │ ├── lostcancel/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── lostcancel/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── lostcancel.go
│ │ │ │ ├── lostcancel_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── modernize/
│ │ │ │ ├── any.go
│ │ │ │ ├── atomictypes.go
│ │ │ │ ├── bloop.go
│ │ │ │ ├── cmd/
│ │ │ │ │ └── modernize/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── errorsastype.go
│ │ │ │ ├── fmtappendf.go
│ │ │ │ ├── forvar.go
│ │ │ │ ├── maps.go
│ │ │ │ ├── minmax.go
│ │ │ │ ├── modernize.go
│ │ │ │ ├── modernize_test.go
│ │ │ │ ├── newexpr.go
│ │ │ │ ├── omitzero.go
│ │ │ │ ├── plusbuild.go
│ │ │ │ ├── rangeint.go
│ │ │ │ ├── reflect.go
│ │ │ │ ├── slices.go
│ │ │ │ ├── slicescontains.go
│ │ │ │ ├── slicesdelete.go
│ │ │ │ ├── sortslice.go
│ │ │ │ ├── stditerators.go
│ │ │ │ ├── stringsbuilder.go
│ │ │ │ ├── stringscut.go
│ │ │ │ ├── stringscutprefix.go
│ │ │ │ ├── stringsseq.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── any/
│ │ │ │ │ │ ├── any.go
│ │ │ │ │ │ ├── any.go.golden
│ │ │ │ │ │ ├── generated.go
│ │ │ │ │ │ └── generated.go.golden
│ │ │ │ │ ├── appendclipped/
│ │ │ │ │ │ ├── appendclipped.go
│ │ │ │ │ │ ├── appendclipped.go.golden
│ │ │ │ │ │ ├── bytesclone.go
│ │ │ │ │ │ └── bytesclone.go.golden
│ │ │ │ │ ├── atomictypes/
│ │ │ │ │ │ ├── atomic.go
│ │ │ │ │ │ ├── atomic.go.golden
│ │ │ │ │ │ ├── atomic_shadow.go
│ │ │ │ │ │ ├── atomic_shadow.go.golden
│ │ │ │ │ │ ├── go118/
│ │ │ │ │ │ │ ├── atomic_go118.go
│ │ │ │ │ │ │ └── atomic_go118.go.golden
│ │ │ │ │ │ ├── go120/
│ │ │ │ │ │ │ ├── atomic_go120.go
│ │ │ │ │ │ │ └── atomic_go120.go.golden
│ │ │ │ │ │ └── ignored/
│ │ │ │ │ │ ├── atomic.go
│ │ │ │ │ │ ├── atomic.go.golden
│ │ │ │ │ │ └── atomic_ignored.go
│ │ │ │ │ ├── bloop/
│ │ │ │ │ │ ├── bloop.go
│ │ │ │ │ │ ├── bloop_test.go
│ │ │ │ │ │ └── bloop_test.go.golden
│ │ │ │ │ ├── errorsastype/
│ │ │ │ │ │ ├── dotimport/
│ │ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ │ ├── errorsastype.go
│ │ │ │ │ │ └── errorsastype.go.golden
│ │ │ │ │ ├── fieldsseq/
│ │ │ │ │ │ ├── fieldsseq.go
│ │ │ │ │ │ ├── fieldsseq.go.golden
│ │ │ │ │ │ └── fieldsseq_go123.go
│ │ │ │ │ ├── fmtappendf/
│ │ │ │ │ │ ├── fmtappendf.go
│ │ │ │ │ │ └── fmtappendf.go.golden
│ │ │ │ │ ├── forvar/
│ │ │ │ │ │ ├── forvar.go
│ │ │ │ │ │ └── forvar.go.golden
│ │ │ │ │ ├── mapsloop/
│ │ │ │ │ │ ├── mapsloop.go
│ │ │ │ │ │ ├── mapsloop.go.golden
│ │ │ │ │ │ ├── mapsloop_dot.go
│ │ │ │ │ │ └── mapsloop_dot.go.golden
│ │ │ │ │ ├── minmax/
│ │ │ │ │ │ ├── go120/
│ │ │ │ │ │ │ ├── minmax.go
│ │ │ │ │ │ │ ├── minmax_go120.go
│ │ │ │ │ │ │ └── minmax_go120.go.golden
│ │ │ │ │ │ ├── minmax.go
│ │ │ │ │ │ ├── minmax.go.golden
│ │ │ │ │ │ ├── nonstrict/
│ │ │ │ │ │ │ ├── nonstrict.go
│ │ │ │ │ │ │ └── nonstrict.go.golden
│ │ │ │ │ │ ├── userdefined/
│ │ │ │ │ │ │ ├── userdefined.go
│ │ │ │ │ │ │ └── userdefined.go.golden
│ │ │ │ │ │ ├── wrongoperators/
│ │ │ │ │ │ │ ├── wrongoperators.go
│ │ │ │ │ │ │ └── wrongoperators.go.golden
│ │ │ │ │ │ └── wrongreturn/
│ │ │ │ │ │ ├── wrongreturn.go
│ │ │ │ │ │ └── wrongreturn.go.golden
│ │ │ │ │ ├── newexpr/
│ │ │ │ │ │ ├── newexpr.go
│ │ │ │ │ │ ├── newexpr.go.golden
│ │ │ │ │ │ └── newexpr_go125.go
│ │ │ │ │ ├── omitzero/
│ │ │ │ │ │ ├── kube/
│ │ │ │ │ │ │ └── kube.go
│ │ │ │ │ │ ├── omitzero.go
│ │ │ │ │ │ └── omitzero.go.golden
│ │ │ │ │ ├── plusbuild/
│ │ │ │ │ │ ├── plusbuild.go
│ │ │ │ │ │ ├── plusbuild.go.golden
│ │ │ │ │ │ └── plusbuild2.go
│ │ │ │ │ ├── rangeint/
│ │ │ │ │ │ ├── a/
│ │ │ │ │ │ │ └── a.go
│ │ │ │ │ │ ├── rangeint.go
│ │ │ │ │ │ └── rangeint.go.golden
│ │ │ │ │ ├── reflecttypefor/
│ │ │ │ │ │ ├── reflecttypefor.go
│ │ │ │ │ │ └── reflecttypefor.go.golden
│ │ │ │ │ ├── slicescontains/
│ │ │ │ │ │ ├── slicescontains.go
│ │ │ │ │ │ └── slicescontains.go.golden
│ │ │ │ │ ├── slicesdelete/
│ │ │ │ │ │ ├── slicesdelete.go
│ │ │ │ │ │ └── slicesdelete.go.golden
│ │ │ │ │ ├── slicessort/
│ │ │ │ │ │ ├── slicessort.go
│ │ │ │ │ │ ├── slicessort.go.golden
│ │ │ │ │ │ ├── slicessort_dot.go
│ │ │ │ │ │ └── slicessort_dot.go.golden
│ │ │ │ │ ├── splitseq/
│ │ │ │ │ │ ├── splitseq.go
│ │ │ │ │ │ ├── splitseq.go.golden
│ │ │ │ │ │ └── splitseq_go123.go
│ │ │ │ │ ├── stditerators/
│ │ │ │ │ │ ├── stditerators.go
│ │ │ │ │ │ └── stditerators.go.golden
│ │ │ │ │ ├── stringsbuilder/
│ │ │ │ │ │ ├── stringsbuilder.go
│ │ │ │ │ │ └── stringsbuilder.go.golden
│ │ │ │ │ ├── stringscut/
│ │ │ │ │ │ ├── stringscut.go
│ │ │ │ │ │ └── stringscut.go.golden
│ │ │ │ │ ├── stringscutprefix/
│ │ │ │ │ │ ├── bytescutprefix/
│ │ │ │ │ │ │ ├── bytescutprefix.go
│ │ │ │ │ │ │ ├── bytescutprefix.go.golden
│ │ │ │ │ │ │ ├── bytescutprefix_dot.go
│ │ │ │ │ │ │ └── bytescutprefix_dot.go.golden
│ │ │ │ │ │ ├── stringscutprefix.go
│ │ │ │ │ │ ├── stringscutprefix.go.golden
│ │ │ │ │ │ ├── stringscutprefix_dot.go
│ │ │ │ │ │ └── stringscutprefix_dot.go.golden
│ │ │ │ │ ├── testingcontext/
│ │ │ │ │ │ ├── testingcontext.go
│ │ │ │ │ │ ├── testingcontext_test.go
│ │ │ │ │ │ └── testingcontext_test.go.golden
│ │ │ │ │ ├── unsafefuncs/
│ │ │ │ │ │ ├── unsafefuncs.go
│ │ │ │ │ │ └── unsafefuncs.go.golden
│ │ │ │ │ └── waitgroupgo/
│ │ │ │ │ ├── waitgroup.go
│ │ │ │ │ ├── waitgroup.go.golden
│ │ │ │ │ ├── waitgroup_alias.go
│ │ │ │ │ ├── waitgroup_alias.go.golden
│ │ │ │ │ ├── waitgroup_dot.go
│ │ │ │ │ └── waitgroup_dot.go.golden
│ │ │ │ ├── testingcontext.go
│ │ │ │ ├── unsafefuncs.go
│ │ │ │ └── waitgroupgo.go
│ │ │ ├── nilfunc/
│ │ │ │ ├── doc.go
│ │ │ │ ├── nilfunc.go
│ │ │ │ ├── nilfunc_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── nilness/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── nilness/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── nilness.go
│ │ │ │ ├── nilness_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ ├── c/
│ │ │ │ │ └── c.go
│ │ │ │ └── d/
│ │ │ │ └── d.go
│ │ │ ├── pkgfact/
│ │ │ │ ├── pkgfact.go
│ │ │ │ ├── pkgfact_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── printf/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── printf.go
│ │ │ │ ├── printf_test.go
│ │ │ │ ├── testdata/
│ │ │ │ │ ├── nonconst_go123.txtar
│ │ │ │ │ ├── nonconst_go124.txtar
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a2.go
│ │ │ │ │ ├── b/
│ │ │ │ │ │ └── b.go
│ │ │ │ │ ├── issue68744/
│ │ │ │ │ │ └── issue68744.go
│ │ │ │ │ ├── issue70572/
│ │ │ │ │ │ └── issue70572.go
│ │ │ │ │ ├── issue72850/
│ │ │ │ │ │ ├── a_go125.go
│ │ │ │ │ │ └── a_go126.go
│ │ │ │ │ ├── issue76616/
│ │ │ │ │ │ └── issue76616.go
│ │ │ │ │ ├── nofmt/
│ │ │ │ │ │ └── nofmt.go
│ │ │ │ │ ├── nonconst/
│ │ │ │ │ │ └── nonconst.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── diagnostics.go
│ │ │ │ │ └── wrappers.go
│ │ │ │ └── types.go
│ │ │ ├── reflectvaluecompare/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── reflectvaluecompare/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── reflectvaluecompare.go
│ │ │ │ ├── reflectvaluecompare_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── shadow/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── shadow/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── shadow.go
│ │ │ │ ├── shadow_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── shift/
│ │ │ │ ├── dead.go
│ │ │ │ ├── shift.go
│ │ │ │ ├── shift_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── sigchanyzer/
│ │ │ │ ├── doc.go
│ │ │ │ ├── sigchanyzer.go
│ │ │ │ ├── sigchanyzer_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── slog/
│ │ │ │ ├── doc.go
│ │ │ │ ├── slog.go
│ │ │ │ ├── slog_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── sortslice/
│ │ │ │ ├── analyzer.go
│ │ │ │ ├── analyzer_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── stdmethods/
│ │ │ │ ├── doc.go
│ │ │ │ ├── stdmethods.go
│ │ │ │ ├── stdmethods_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── b.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── stdversion/
│ │ │ │ ├── main.go
│ │ │ │ ├── stdversion.go
│ │ │ │ ├── stdversion_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── test.txtar
│ │ │ ├── stringintconv/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── stringintconv/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── string.go
│ │ │ │ ├── string_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── fix/
│ │ │ │ │ ├── fix.go
│ │ │ │ │ ├── fix.go.golden
│ │ │ │ │ ├── fixdot.go
│ │ │ │ │ ├── fixdot.go.golden
│ │ │ │ │ ├── fixnamed.go
│ │ │ │ │ └── fixnamed.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── structtag/
│ │ │ │ ├── structtag.go
│ │ │ │ ├── structtag_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── testinggoroutine/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── b.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ ├── testinggoroutine.go
│ │ │ │ ├── testinggoroutine_test.go
│ │ │ │ └── util.go
│ │ │ ├── tests/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ ├── a_test.go
│ │ │ │ │ │ ├── ax_test.go
│ │ │ │ │ │ └── go118_test.go
│ │ │ │ │ ├── b/
│ │ │ │ │ │ └── b.go
│ │ │ │ │ ├── b_x_test/
│ │ │ │ │ │ └── b_test.go
│ │ │ │ │ ├── divergent/
│ │ │ │ │ │ ├── buf.go
│ │ │ │ │ │ └── buf_test.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── typeparams_test.go
│ │ │ │ ├── tests.go
│ │ │ │ └── tests_test.go
│ │ │ ├── timeformat/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ └── b/
│ │ │ │ │ └── b.go
│ │ │ │ ├── timeformat.go
│ │ │ │ └── timeformat_test.go
│ │ │ ├── unmarshal/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── unmarshal/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── a.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ ├── unmarshal.go
│ │ │ │ └── unmarshal_test.go
│ │ │ ├── unreachable/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ └── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── unreachable.go
│ │ │ │ └── unreachable_test.go
│ │ │ ├── unsafeptr/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── issue40701.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ └── typeparams.go
│ │ │ │ ├── unsafeptr.go
│ │ │ │ └── unsafeptr_test.go
│ │ │ ├── unusedresult/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── unusedresult/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── a.go
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── userdefs/
│ │ │ │ │ └── userdefs.go
│ │ │ │ ├── unusedresult.go
│ │ │ │ └── unusedresult_test.go
│ │ │ ├── unusedwrite/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── unusedwrite.go
│ │ │ │ │ └── importsunsafe/
│ │ │ │ │ └── i.go
│ │ │ │ ├── unusedwrite.go
│ │ │ │ └── unusedwrite_test.go
│ │ │ ├── usesgenerics/
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ └── a.go
│ │ │ │ │ ├── b/
│ │ │ │ │ │ └── b.go
│ │ │ │ │ ├── c/
│ │ │ │ │ │ └── c.go
│ │ │ │ │ └── d/
│ │ │ │ │ └── d.go
│ │ │ │ ├── usesgenerics.go
│ │ │ │ └── usesgenerics_test.go
│ │ │ └── waitgroup/
│ │ │ ├── doc.go
│ │ │ ├── main.go
│ │ │ ├── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── waitgroup.go
│ │ │ └── waitgroup_test.go
│ │ ├── singlechecker/
│ │ │ └── singlechecker.go
│ │ ├── unitchecker/
│ │ │ ├── export_test.go
│ │ │ ├── main.go
│ │ │ ├── separate_test.go
│ │ │ ├── unitchecker.go
│ │ │ ├── unitchecker_test.go
│ │ │ └── vet_std_test.go
│ │ ├── validate.go
│ │ └── validate_test.go
│ ├── ast/
│ │ ├── astutil/
│ │ │ ├── enclosing.go
│ │ │ ├── enclosing_test.go
│ │ │ ├── imports.go
│ │ │ ├── imports_test.go
│ │ │ ├── rewrite.go
│ │ │ ├── rewrite_test.go
│ │ │ └── util.go
│ │ ├── edge/
│ │ │ └── edge.go
│ │ └── inspector/
│ │ ├── cursor.go
│ │ ├── cursor_test.go
│ │ ├── inspector.go
│ │ ├── inspector_test.go
│ │ ├── iter.go
│ │ ├── iter_test.go
│ │ ├── typeof.go
│ │ └── walk.go
│ ├── buildutil/
│ │ ├── allpackages.go
│ │ ├── allpackages_test.go
│ │ ├── fakecontext.go
│ │ ├── overlay.go
│ │ ├── overlay_test.go
│ │ ├── tags.go
│ │ ├── tags_test.go
│ │ ├── util.go
│ │ ├── util_test.go
│ │ └── util_windows_test.go
│ ├── callgraph/
│ │ ├── callgraph.go
│ │ ├── callgraph_test.go
│ │ ├── cha/
│ │ │ ├── cha.go
│ │ │ ├── cha_test.go
│ │ │ └── testdata/
│ │ │ ├── func.go
│ │ │ ├── generics.go
│ │ │ ├── iface.go
│ │ │ ├── issue23925.go
│ │ │ └── recv.go
│ │ ├── internal/
│ │ │ └── chautil/
│ │ │ └── lazy.go
│ │ ├── rta/
│ │ │ ├── rta.go
│ │ │ ├── rta_test.go
│ │ │ └── testdata/
│ │ │ ├── func.txtar
│ │ │ ├── generics.txtar
│ │ │ ├── iface.txtar
│ │ │ ├── multipkgs.txtar
│ │ │ ├── reflectcall.txtar
│ │ │ └── rtype.txtar
│ │ ├── static/
│ │ │ ├── static.go
│ │ │ └── static_test.go
│ │ ├── util.go
│ │ └── vta/
│ │ ├── graph.go
│ │ ├── graph_test.go
│ │ ├── helpers_test.go
│ │ ├── initial.go
│ │ ├── internal/
│ │ │ └── trie/
│ │ │ ├── bits.go
│ │ │ ├── bits_test.go
│ │ │ ├── builder.go
│ │ │ ├── op_test.go
│ │ │ ├── scope.go
│ │ │ ├── trie.go
│ │ │ └── trie_test.go
│ │ ├── propagation.go
│ │ ├── propagation_test.go
│ │ ├── testdata/
│ │ │ └── src/
│ │ │ ├── arrays_generics.go
│ │ │ ├── callgraph_collections.go
│ │ │ ├── callgraph_comma_maps.go
│ │ │ ├── callgraph_field_funcs.go
│ │ │ ├── callgraph_fields.go
│ │ │ ├── callgraph_generics.go
│ │ │ ├── callgraph_ho.go
│ │ │ ├── callgraph_interfaces.go
│ │ │ ├── callgraph_issue_57756.go
│ │ │ ├── callgraph_nested_ptr.go
│ │ │ ├── callgraph_pointers.go
│ │ │ ├── callgraph_range_over_func.go
│ │ │ ├── callgraph_recursive_types.go
│ │ │ ├── callgraph_static.go
│ │ │ ├── callgraph_type_aliases.go
│ │ │ ├── channels.go
│ │ │ ├── closures.go
│ │ │ ├── d/
│ │ │ │ └── d.go
│ │ │ ├── dynamic_calls.go
│ │ │ ├── fields.go
│ │ │ ├── function_alias.go
│ │ │ ├── generic_channels.go
│ │ │ ├── go117.go
│ │ │ ├── issue63146.go
│ │ │ ├── maps.go
│ │ │ ├── node_uniqueness.go
│ │ │ ├── panic.go
│ │ │ ├── phi.go
│ │ │ ├── phi_alias.go
│ │ │ ├── ranges.go
│ │ │ ├── returns.go
│ │ │ ├── select.go
│ │ │ ├── simple.go
│ │ │ ├── static_calls.go
│ │ │ ├── store.go
│ │ │ ├── store_load_alias.go
│ │ │ ├── stores_arrays.go
│ │ │ ├── t/
│ │ │ │ └── t.go
│ │ │ ├── type_assertions.go
│ │ │ └── type_conversions.go
│ │ ├── utils.go
│ │ ├── vta.go
│ │ └── vta_test.go
│ ├── cfg/
│ │ ├── builder.go
│ │ ├── cfg.go
│ │ ├── cfg_test.go
│ │ └── main.go
│ ├── gccgoexportdata/
│ │ ├── gccgoexportdata.go
│ │ ├── gccgoexportdata_test.go
│ │ └── testdata/
│ │ ├── errors.gox
│ │ ├── long.a
│ │ └── short.a
│ ├── gcexportdata/
│ │ ├── example_test.go
│ │ ├── gcexportdata.go
│ │ ├── importer.go
│ │ └── main.go
│ ├── internal/
│ │ ├── cgo/
│ │ │ ├── cgo.go
│ │ │ └── cgo_pkgconfig.go
│ │ └── gccgoimporter/
│ │ ├── ar.go
│ │ ├── backdoor.go
│ │ ├── gccgoinstallation.go
│ │ ├── gccgoinstallation_test.go
│ │ ├── importer.go
│ │ ├── importer_test.go
│ │ ├── newInterface10.go
│ │ ├── newInterface11.go
│ │ ├── parser.go
│ │ ├── parser_test.go
│ │ ├── testdata/
│ │ │ ├── aliases.go
│ │ │ ├── aliases.gox
│ │ │ ├── complexnums.go
│ │ │ ├── complexnums.gox
│ │ │ ├── conversions.go
│ │ │ ├── conversions.gox
│ │ │ ├── escapeinfo.go
│ │ │ ├── escapeinfo.gox
│ │ │ ├── imports.go
│ │ │ ├── imports.gox
│ │ │ ├── issue27856.go
│ │ │ ├── issue27856.gox
│ │ │ ├── issue29198.go
│ │ │ ├── issue29198.gox
│ │ │ ├── issue30628.go
│ │ │ ├── issue30628.gox
│ │ │ ├── issue31540.go
│ │ │ ├── issue31540.gox
│ │ │ ├── issue34182.go
│ │ │ ├── issue34182.gox
│ │ │ ├── libimportsar.a
│ │ │ ├── nointerface.go
│ │ │ ├── nointerface.gox
│ │ │ ├── notinheap.go
│ │ │ ├── notinheap.gox
│ │ │ ├── pointer.go
│ │ │ ├── pointer.gox
│ │ │ ├── time.gox
│ │ │ ├── unicode.gox
│ │ │ └── v1reflect.gox
│ │ └── testenv_test.go
│ ├── loader/
│ │ ├── doc.go
│ │ ├── loader.go
│ │ ├── loader_test.go
│ │ ├── stdlib_test.go
│ │ ├── testdata/
│ │ │ ├── a.go
│ │ │ ├── b.go
│ │ │ ├── badpkgdecl.go
│ │ │ └── issue46877/
│ │ │ ├── x.go
│ │ │ └── x.h
│ │ └── util.go
│ ├── packages/
│ │ ├── doc.go
│ │ ├── example_test.go
│ │ ├── external.go
│ │ ├── golist.go
│ │ ├── golist_overlay.go
│ │ ├── gopackages/
│ │ │ └── main.go
│ │ ├── internal/
│ │ │ ├── linecount/
│ │ │ │ └── linecount.go
│ │ │ └── nodecount/
│ │ │ └── nodecount.go
│ │ ├── loadmode_string.go
│ │ ├── overlay_test.go
│ │ ├── packages.go
│ │ ├── packages_test.go
│ │ ├── stdlib_test.go
│ │ └── visit.go
│ ├── ssa/
│ │ ├── TODO
│ │ ├── block.go
│ │ ├── blockopt.go
│ │ ├── builder.go
│ │ ├── builder_generic_test.go
│ │ ├── builder_test.go
│ │ ├── const.go
│ │ ├── const_test.go
│ │ ├── create.go
│ │ ├── doc.go
│ │ ├── dom.go
│ │ ├── dom_test.go
│ │ ├── emit.go
│ │ ├── example_test.go
│ │ ├── func.go
│ │ ├── instantiate.go
│ │ ├── instantiate_test.go
│ │ ├── interp/
│ │ │ ├── external.go
│ │ │ ├── interp.go
│ │ │ ├── interp_test.go
│ │ │ ├── map.go
│ │ │ ├── ops.go
│ │ │ ├── rangefunc_test.go
│ │ │ ├── reflect.go
│ │ │ ├── testdata/
│ │ │ │ ├── boundmeth.go
│ │ │ │ ├── complit.go
│ │ │ │ ├── convert.go
│ │ │ │ ├── coverage.go
│ │ │ │ ├── deepequal.go
│ │ │ │ ├── defer.go
│ │ │ │ ├── fieldprom.go
│ │ │ │ ├── fixedbugs/
│ │ │ │ │ ├── issue52342.go
│ │ │ │ │ ├── issue52835.go
│ │ │ │ │ ├── issue55086.go
│ │ │ │ │ ├── issue55115.go
│ │ │ │ │ ├── issue66783.go
│ │ │ │ │ ├── issue69298.go
│ │ │ │ │ └── issue69929.go
│ │ │ │ ├── forvarlifetime_go122.go
│ │ │ │ ├── forvarlifetime_old.go
│ │ │ │ ├── ifaceconv.go
│ │ │ │ ├── ifaceprom.go
│ │ │ │ ├── initorder.go
│ │ │ │ ├── methprom.go
│ │ │ │ ├── minmax.go
│ │ │ │ ├── mrvchain.go
│ │ │ │ ├── newexpr_go126.go
│ │ │ │ ├── range.go
│ │ │ │ ├── rangefunc.go
│ │ │ │ ├── rangeoverint.go
│ │ │ │ ├── rangevarlifetime_go122.go
│ │ │ │ ├── rangevarlifetime_old.go
│ │ │ │ ├── recover.go
│ │ │ │ ├── reflect.go
│ │ │ │ ├── slice2array.go
│ │ │ │ ├── slice2arrayptr.go
│ │ │ │ ├── src/
│ │ │ │ │ ├── encoding/
│ │ │ │ │ │ └── encoding.go
│ │ │ │ │ ├── errors/
│ │ │ │ │ │ └── errors.go
│ │ │ │ │ ├── fmt/
│ │ │ │ │ │ └── fmt.go
│ │ │ │ │ ├── io/
│ │ │ │ │ │ └── io.go
│ │ │ │ │ ├── log/
│ │ │ │ │ │ └── log.go
│ │ │ │ │ ├── math/
│ │ │ │ │ │ └── math.go
│ │ │ │ │ ├── os/
│ │ │ │ │ │ └── os.go
│ │ │ │ │ ├── reflect/
│ │ │ │ │ │ ├── deepequal.go
│ │ │ │ │ │ └── reflect.go
│ │ │ │ │ ├── runtime/
│ │ │ │ │ │ └── runtime.go
│ │ │ │ │ ├── sort/
│ │ │ │ │ │ └── sort.go
│ │ │ │ │ ├── strconv/
│ │ │ │ │ │ └── strconv.go
│ │ │ │ │ ├── strings/
│ │ │ │ │ │ └── strings.go
│ │ │ │ │ ├── sync/
│ │ │ │ │ │ └── sync.go
│ │ │ │ │ ├── time/
│ │ │ │ │ │ └── time.go
│ │ │ │ │ ├── unicode/
│ │ │ │ │ │ └── utf8/
│ │ │ │ │ │ └── utf8.go
│ │ │ │ │ └── unsafe/
│ │ │ │ │ └── unsafe.go
│ │ │ │ ├── static.go
│ │ │ │ ├── typeassert.go
│ │ │ │ ├── width32.go
│ │ │ │ └── zeros.go
│ │ │ └── value.go
│ │ ├── lift.go
│ │ ├── lvalue.go
│ │ ├── methods.go
│ │ ├── methods_test.go
│ │ ├── mode.go
│ │ ├── print.go
│ │ ├── sanity.go
│ │ ├── source.go
│ │ ├── source_test.go
│ │ ├── ssa.go
│ │ ├── ssautil/
│ │ │ ├── deprecated.go
│ │ │ ├── deprecated_test.go
│ │ │ ├── load.go
│ │ │ ├── load_test.go
│ │ │ ├── switch.go
│ │ │ ├── switch_test.go
│ │ │ ├── testdata/
│ │ │ │ └── switches.txtar
│ │ │ └── visit.go
│ │ ├── stdlib_test.go
│ │ ├── subst.go
│ │ ├── subst_test.go
│ │ ├── task.go
│ │ ├── testdata/
│ │ │ ├── fixedbugs/
│ │ │ │ ├── issue66783a.go
│ │ │ │ ├── issue66783b.go
│ │ │ │ └── issue73594.go
│ │ │ ├── indirect.txtar
│ │ │ ├── objlookup.go
│ │ │ ├── src/
│ │ │ │ ├── README.txt
│ │ │ │ ├── bytes/
│ │ │ │ │ └── bytes.go
│ │ │ │ ├── context/
│ │ │ │ │ └── context.go
│ │ │ │ ├── encoding/
│ │ │ │ │ ├── encoding.go
│ │ │ │ │ ├── json/
│ │ │ │ │ │ └── json.go
│ │ │ │ │ └── xml/
│ │ │ │ │ └── xml.go
│ │ │ │ ├── errors/
│ │ │ │ │ └── errors.go
│ │ │ │ ├── fmt/
│ │ │ │ │ └── fmt.go
│ │ │ │ ├── io/
│ │ │ │ │ └── io.go
│ │ │ │ ├── log/
│ │ │ │ │ └── log.go
│ │ │ │ ├── math/
│ │ │ │ │ └── math.go
│ │ │ │ ├── os/
│ │ │ │ │ └── os.go
│ │ │ │ ├── reflect/
│ │ │ │ │ └── reflect.go
│ │ │ │ ├── runtime/
│ │ │ │ │ └── runtime.go
│ │ │ │ ├── sort/
│ │ │ │ │ └── sort.go
│ │ │ │ ├── strconv/
│ │ │ │ │ └── strconv.go
│ │ │ │ ├── strings/
│ │ │ │ │ └── strings.go
│ │ │ │ ├── sync/
│ │ │ │ │ ├── atomic/
│ │ │ │ │ │ └── atomic.go
│ │ │ │ │ └── sync.go
│ │ │ │ ├── time/
│ │ │ │ │ └── time.go
│ │ │ │ └── unsafe/
│ │ │ │ └── unsafe.go
│ │ │ ├── structconv.go
│ │ │ └── valueforexpr.go
│ │ ├── testutil_test.go
│ │ ├── typeset.go
│ │ ├── util.go
│ │ └── wrappers.go
│ └── types/
│ ├── internal/
│ │ └── play/
│ │ └── play.go
│ ├── objectpath/
│ │ ├── objectpath.go
│ │ ├── objectpath_go118_test.go
│ │ └── objectpath_test.go
│ └── typeutil/
│ ├── callee.go
│ ├── callee_test.go
│ ├── example_test.go
│ ├── imports.go
│ ├── imports_test.go
│ ├── map.go
│ ├── map_test.go
│ ├── methodsetcache.go
│ ├── ui.go
│ └── ui_test.go
├── go.mod
├── go.sum
├── gopls/
│ ├── README.md
│ ├── contributors.txt
│ ├── doc/
│ │ ├── README.md
│ │ ├── advanced.md
│ │ ├── analyzers.md
│ │ ├── assets/
│ │ │ ├── assets.go
│ │ │ └── go.mod
│ │ ├── codelenses.md
│ │ ├── command-line.md
│ │ ├── contributing.md
│ │ ├── daemon.md
│ │ ├── default.tmpl
│ │ ├── design/
│ │ │ ├── design.md
│ │ │ ├── implementation.md
│ │ │ └── integrating.md
│ │ ├── editor/
│ │ │ ├── emacs.md
│ │ │ ├── helix.md
│ │ │ ├── sublime.md
│ │ │ ├── vim.md
│ │ │ └── zed.md
│ │ ├── features/
│ │ │ ├── README.md
│ │ │ ├── assembly.md
│ │ │ ├── completion.md
│ │ │ ├── diagnostics.md
│ │ │ ├── index.md
│ │ │ ├── mcp.md
│ │ │ ├── modfiles.md
│ │ │ ├── navigation.md
│ │ │ ├── passive.md
│ │ │ ├── templates.md
│ │ │ ├── transformation.md
│ │ │ └── web.md
│ │ ├── index.md
│ │ ├── inlayHints.md
│ │ ├── release/
│ │ │ ├── README
│ │ │ ├── v0.16.0.md
│ │ │ ├── v0.17.0.md
│ │ │ ├── v0.18.0.md
│ │ │ ├── v0.19.0.md
│ │ │ ├── v0.20.0.md
│ │ │ ├── v0.21.0.md
│ │ │ └── v0.22.0.md
│ │ ├── settings.md
│ │ ├── troubleshooting.md
│ │ └── workspace.md
│ ├── go.mod
│ ├── go.sum
│ ├── integration/
│ │ └── govim/
│ │ ├── Dockerfile
│ │ ├── README.md
│ │ ├── artifacts.go
│ │ ├── cloudbuild.harness.yaml
│ │ ├── cloudbuild.yaml
│ │ ├── run_local.sh
│ │ └── run_tests_for_cloudbuild.sh
│ ├── internal/
│ │ ├── analysis/
│ │ │ ├── deprecated/
│ │ │ │ ├── deprecated.go
│ │ │ │ ├── deprecated_test.go
│ │ │ │ ├── doc.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── a.go
│ │ │ │ └── a_test.go
│ │ │ ├── embeddirective/
│ │ │ │ ├── doc.go
│ │ │ │ ├── embeddirective.go
│ │ │ │ ├── embeddirective_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── embedText
│ │ │ │ ├── import_missing.go
│ │ │ │ ├── import_missing.go.golden
│ │ │ │ ├── import_present.go
│ │ │ │ └── import_present_go120.go
│ │ │ ├── fillreturns/
│ │ │ │ ├── doc.go
│ │ │ │ ├── fillreturns.go
│ │ │ │ ├── fillreturns_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── fillstruct/
│ │ │ │ ├── fillstruct.go
│ │ │ │ ├── fillstruct_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── typeparams/
│ │ │ │ └── typeparams.go
│ │ │ ├── fillswitch/
│ │ │ │ ├── doc.go
│ │ │ │ ├── fillswitch.go
│ │ │ │ ├── fillswitch_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ └── b/
│ │ │ │ └── b.go
│ │ │ ├── infertypeargs/
│ │ │ │ ├── infertypeargs.go
│ │ │ │ ├── infertypeargs_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ ├── basic.go
│ │ │ │ ├── basic.go.golden
│ │ │ │ ├── imported/
│ │ │ │ │ └── imported.go
│ │ │ │ ├── imported.go
│ │ │ │ ├── imported.go.golden
│ │ │ │ ├── notypechange.go
│ │ │ │ └── notypechange.go.golden
│ │ │ ├── maprange/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── maprange/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── maprange.go
│ │ │ │ ├── maprange_test.go
│ │ │ │ └── testdata/
│ │ │ │ ├── basic.txtar
│ │ │ │ └── old.txtar
│ │ │ ├── modernize/
│ │ │ │ └── cmd/
│ │ │ │ └── modernize/
│ │ │ │ └── main.go
│ │ │ ├── nonewvars/
│ │ │ │ ├── doc.go
│ │ │ │ ├── nonewvars.go
│ │ │ │ ├── nonewvars_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── noresultvalues/
│ │ │ │ ├── doc.go
│ │ │ │ ├── noresultvalues.go
│ │ │ │ ├── noresultvalues_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── a.go
│ │ │ │ └── a.go.golden
│ │ │ ├── recursiveiter/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── recursiveiter.go
│ │ │ │ ├── recursiveiter_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── simplifycompositelit/
│ │ │ │ ├── doc.go
│ │ │ │ ├── simplifycompositelit.go
│ │ │ │ ├── simplifycompositelit_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ └── generatedcode/
│ │ │ │ ├── generatedcode.go
│ │ │ │ └── generatedcode.go.golden
│ │ │ ├── simplifyrange/
│ │ │ │ ├── doc.go
│ │ │ │ ├── simplifyrange.go
│ │ │ │ ├── simplifyrange_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── generatedcode/
│ │ │ │ │ ├── generatedcode.go
│ │ │ │ │ └── generatedcode.go.golden
│ │ │ │ └── rangeoverfunc/
│ │ │ │ ├── rangeoverfunc.go
│ │ │ │ └── rangeoverfunc.go.golden
│ │ │ ├── simplifyslice/
│ │ │ │ ├── doc.go
│ │ │ │ ├── simplifyslice.go
│ │ │ │ ├── simplifyslice_test.go
│ │ │ │ └── testdata/
│ │ │ │ └── src/
│ │ │ │ ├── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── generatedcode/
│ │ │ │ │ ├── generatedcode.go
│ │ │ │ │ └── generatedcode.go.golden
│ │ │ │ └── typeparams/
│ │ │ │ ├── typeparams.go
│ │ │ │ └── typeparams.go.golden
│ │ │ ├── unusedfunc/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── basic.txtar
│ │ │ │ ├── unusedfunc.go
│ │ │ │ └── unusedfunc_test.go
│ │ │ ├── unusedparams/
│ │ │ │ ├── cmd/
│ │ │ │ │ └── main.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ ├── generatedcode/
│ │ │ │ │ │ ├── generatedcode.go
│ │ │ │ │ │ ├── generatedcode.go.golden
│ │ │ │ │ │ ├── nongeneratedcode.go
│ │ │ │ │ │ └── nongeneratedcode.go.golden
│ │ │ │ │ └── typeparams/
│ │ │ │ │ ├── typeparams.go
│ │ │ │ │ └── typeparams.go.golden
│ │ │ │ ├── unusedparams.go
│ │ │ │ └── unusedparams_test.go
│ │ │ ├── unusedvariable/
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── assign/
│ │ │ │ │ │ ├── a.go
│ │ │ │ │ │ └── a.go.golden
│ │ │ │ │ └── decl/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── unusedvariable.go
│ │ │ │ └── unusedvariable_test.go
│ │ │ ├── writestring/
│ │ │ │ ├── doc.go
│ │ │ │ ├── main.go
│ │ │ │ ├── testdata/
│ │ │ │ │ └── src/
│ │ │ │ │ └── a/
│ │ │ │ │ ├── a.go
│ │ │ │ │ └── a.go.golden
│ │ │ │ ├── writestring.go
│ │ │ │ └── writestring_test.go
│ │ │ └── yield/
│ │ │ ├── doc.go
│ │ │ ├── main.go
│ │ │ ├── testdata/
│ │ │ │ └── src/
│ │ │ │ └── a/
│ │ │ │ └── a.go
│ │ │ ├── yield.go
│ │ │ └── yield_test.go
│ │ ├── bloom/
│ │ │ ├── filter.go
│ │ │ └── filter_test.go
│ │ ├── cache/
│ │ │ ├── analysis.go
│ │ │ ├── cache.go
│ │ │ ├── check.go
│ │ │ ├── constraints.go
│ │ │ ├── constraints_test.go
│ │ │ ├── debug.go
│ │ │ ├── diagnostics.go
│ │ │ ├── errors.go
│ │ │ ├── errors_test.go
│ │ │ ├── filemap.go
│ │ │ ├── filemap_test.go
│ │ │ ├── filterer.go
│ │ │ ├── fs_memoized.go
│ │ │ ├── fs_overlay.go
│ │ │ ├── future.go
│ │ │ ├── future_test.go
│ │ │ ├── imports.go
│ │ │ ├── keys.go
│ │ │ ├── load.go
│ │ │ ├── metadata/
│ │ │ │ ├── cycle_test.go
│ │ │ │ ├── graph.go
│ │ │ │ └── metadata.go
│ │ │ ├── methodsets/
│ │ │ │ └── methodsets.go
│ │ │ ├── mod.go
│ │ │ ├── mod_tidy.go
│ │ │ ├── mod_vuln.go
│ │ │ ├── os_darwin.go
│ │ │ ├── os_windows.go
│ │ │ ├── package.go
│ │ │ ├── parse.go
│ │ │ ├── parse_cache.go
│ │ │ ├── parse_cache_test.go
│ │ │ ├── parsego/
│ │ │ │ ├── file.go
│ │ │ │ ├── parse.go
│ │ │ │ ├── parse_test.go
│ │ │ │ ├── resolver.go
│ │ │ │ ├── resolver_compat.go
│ │ │ │ ├── resolver_gen.go
│ │ │ │ └── resolver_test.go
│ │ │ ├── port.go
│ │ │ ├── port_test.go
│ │ │ ├── session.go
│ │ │ ├── session_test.go
│ │ │ ├── snapshot.go
│ │ │ ├── source.go
│ │ │ ├── symbols/
│ │ │ │ └── symbols.go
│ │ │ ├── symbols.go
│ │ │ ├── testfuncs/
│ │ │ │ ├── match.go
│ │ │ │ └── tests.go
│ │ │ ├── typerefs/
│ │ │ │ ├── doc.go
│ │ │ │ ├── packageset.go
│ │ │ │ ├── pkggraph_test.go
│ │ │ │ ├── pkgrefs_test.go
│ │ │ │ ├── refs.go
│ │ │ │ └── refs_test.go
│ │ │ ├── view.go
│ │ │ ├── view_test.go
│ │ │ ├── workspace.go
│ │ │ └── xrefs/
│ │ │ └── xrefs.go
│ │ ├── clonetest/
│ │ │ ├── clonetest.go
│ │ │ └── clonetest_test.go
│ │ ├── cmd/
│ │ │ ├── call_hierarchy.go
│ │ │ ├── capabilities_test.go
│ │ │ ├── check.go
│ │ │ ├── cmd.go
│ │ │ ├── codeaction.go
│ │ │ ├── codelens.go
│ │ │ ├── counters.go
│ │ │ ├── definition.go
│ │ │ ├── execute.go
│ │ │ ├── folding_range.go
│ │ │ ├── format.go
│ │ │ ├── help_test.go
│ │ │ ├── highlight.go
│ │ │ ├── implementation.go
│ │ │ ├── imports.go
│ │ │ ├── info.go
│ │ │ ├── integration_test.go
│ │ │ ├── links.go
│ │ │ ├── mcp.go
│ │ │ ├── mcp_test.go
│ │ │ ├── parsespan.go
│ │ │ ├── prepare_rename.go
│ │ │ ├── references.go
│ │ │ ├── remote.go
│ │ │ ├── rename.go
│ │ │ ├── semantictokens.go
│ │ │ ├── serve.go
│ │ │ ├── signature.go
│ │ │ ├── span.go
│ │ │ ├── spanformat_test.go
│ │ │ ├── stats.go
│ │ │ ├── subcommands.go
│ │ │ ├── symbols.go
│ │ │ ├── usage/
│ │ │ │ ├── api-json.hlp
│ │ │ │ ├── bug.hlp
│ │ │ │ ├── call_hierarchy.hlp
│ │ │ │ ├── check.hlp
│ │ │ │ ├── codeaction.hlp
│ │ │ │ ├── codelens.hlp
│ │ │ │ ├── definition.hlp
│ │ │ │ ├── execute.hlp
│ │ │ │ ├── fix.hlp
│ │ │ │ ├── folding_ranges.hlp
│ │ │ │ ├── format.hlp
│ │ │ │ ├── help.hlp
│ │ │ │ ├── highlight.hlp
│ │ │ │ ├── implementation.hlp
│ │ │ │ ├── imports.hlp
│ │ │ │ ├── inspect.hlp
│ │ │ │ ├── licenses.hlp
│ │ │ │ ├── links.hlp
│ │ │ │ ├── mcp.hlp
│ │ │ │ ├── prepare_rename.hlp
│ │ │ │ ├── references.hlp
│ │ │ │ ├── remote.hlp
│ │ │ │ ├── rename.hlp
│ │ │ │ ├── semtok.hlp
│ │ │ │ ├── serve.hlp
│ │ │ │ ├── signature.hlp
│ │ │ │ ├── stats.hlp
│ │ │ │ ├── symbols.hlp
│ │ │ │ ├── usage-v.hlp
│ │ │ │ ├── usage.hlp
│ │ │ │ ├── version.hlp
│ │ │ │ ├── vulncheck.hlp
│ │ │ │ └── workspace_symbol.hlp
│ │ │ ├── vulncheck.go
│ │ │ └── workspace_symbol.go
│ │ ├── debug/
│ │ │ ├── flight.go
│ │ │ ├── flight_go124.go
│ │ │ ├── flight_unix.go
│ │ │ ├── info.go
│ │ │ ├── info_test.go
│ │ │ ├── log/
│ │ │ │ └── log.go
│ │ │ ├── metrics.go
│ │ │ ├── rpc.go
│ │ │ ├── serve.go
│ │ │ ├── template_test.go
│ │ │ └── trace.go
│ │ ├── doc/
│ │ │ ├── api.go
│ │ │ ├── api.json
│ │ │ └── generate/
│ │ │ ├── generate.go
│ │ │ └── generate_test.go
│ │ ├── file/
│ │ │ ├── file.go
│ │ │ ├── hash.go
│ │ │ ├── kind.go
│ │ │ └── modification.go
│ │ ├── filecache/
│ │ │ ├── filecache.go
│ │ │ └── filecache_test.go
│ │ ├── filewatcher/
│ │ │ ├── export_test.go
│ │ │ ├── filewatcher.go
│ │ │ ├── filewatcher_test.go
│ │ │ └── fsnotify_watcher.go
│ │ ├── fuzzy/
│ │ │ ├── input.go
│ │ │ ├── input_test.go
│ │ │ ├── matcher.go
│ │ │ ├── matcher_test.go
│ │ │ ├── self_test.go
│ │ │ ├── symbol.go
│ │ │ └── symbol_test.go
│ │ ├── goasm/
│ │ │ └── definition.go
│ │ ├── golang/
│ │ │ ├── add_import.go
│ │ │ ├── addtest.go
│ │ │ ├── assembly.go
│ │ │ ├── call_hierarchy.go
│ │ │ ├── change_quote.go
│ │ │ ├── change_signature.go
│ │ │ ├── code_lens.go
│ │ │ ├── codeaction.go
│ │ │ ├── comment.go
│ │ │ ├── compileropt.go
│ │ │ ├── completion/
│ │ │ │ ├── builtin.go
│ │ │ │ ├── completion.go
│ │ │ │ ├── deep_completion.go
│ │ │ │ ├── deep_completion_test.go
│ │ │ │ ├── definition.go
│ │ │ │ ├── format.go
│ │ │ │ ├── fuzz.go
│ │ │ │ ├── keywords.go
│ │ │ │ ├── labels.go
│ │ │ │ ├── literal.go
│ │ │ │ ├── newfile.go
│ │ │ │ ├── package.go
│ │ │ │ ├── package_test.go
│ │ │ │ ├── postfix_snippets.go
│ │ │ │ ├── printf.go
│ │ │ │ ├── printf_test.go
│ │ │ │ ├── snippet/
│ │ │ │ │ ├── snippet_builder.go
│ │ │ │ │ └── snippet_builder_test.go
│ │ │ │ ├── snippet.go
│ │ │ │ ├── statements.go
│ │ │ │ ├── unify.go
│ │ │ │ ├── unimported.go
│ │ │ │ └── util.go
│ │ │ ├── counters.go
│ │ │ ├── definition.go
│ │ │ ├── diagnostics.go
│ │ │ ├── embeddirective.go
│ │ │ ├── extract.go
│ │ │ ├── extracttofile.go
│ │ │ ├── fix.go
│ │ │ ├── folding_range.go
│ │ │ ├── format.go
│ │ │ ├── format_test.go
│ │ │ ├── freesymbols.go
│ │ │ ├── freesymbols_test.go
│ │ │ ├── highlight.go
│ │ │ ├── hover.go
│ │ │ ├── hover_test.go
│ │ │ ├── identifier.go
│ │ │ ├── identifier_test.go
│ │ │ ├── implementation.go
│ │ │ ├── implementation_test.go
│ │ │ ├── inlay_hint.go
│ │ │ ├── inline.go
│ │ │ ├── inline_all.go
│ │ │ ├── invertifcondition.go
│ │ │ ├── known_packages.go
│ │ │ ├── lines.go
│ │ │ ├── linkname.go
│ │ │ ├── modify_tags.go
│ │ │ ├── movetype.go
│ │ │ ├── origin.go
│ │ │ ├── pkgdoc.go
│ │ │ ├── references.go
│ │ │ ├── rename.go
│ │ │ ├── rename_check.go
│ │ │ ├── semtok.go
│ │ │ ├── signature_help.go
│ │ │ ├── snapshot.go
│ │ │ ├── splitpkg/
│ │ │ │ ├── graph.go
│ │ │ │ ├── splitpkg.go
│ │ │ │ └── splitpkg.html.tmpl
│ │ │ ├── stub.go
│ │ │ ├── stubmethods/
│ │ │ │ ├── stubcalledfunc.go
│ │ │ │ └── stubmethods.go
│ │ │ ├── symbols.go
│ │ │ ├── type_definition.go
│ │ │ ├── type_hierarchy.go
│ │ │ ├── types_format.go
│ │ │ ├── undeclared.go
│ │ │ ├── util.go
│ │ │ ├── workspace_symbol.go
│ │ │ └── workspace_symbol_test.go
│ │ ├── label/
│ │ │ └── keys.go
│ │ ├── licenses/
│ │ │ ├── gen-licenses.sh
│ │ │ ├── licenses.go
│ │ │ └── licenses_test.go
│ │ ├── lsprpc/
│ │ │ ├── autostart_default.go
│ │ │ ├── autostart_posix.go
│ │ │ ├── binder.go
│ │ │ ├── binder_test.go
│ │ │ ├── commandinterceptor_test.go
│ │ │ ├── dialer.go
│ │ │ ├── export_test.go
│ │ │ ├── goenv.go
│ │ │ ├── goenv_test.go
│ │ │ ├── lsprpc.go
│ │ │ ├── lsprpc_test.go
│ │ │ └── middleware_test.go
│ │ ├── mcp/
│ │ │ ├── context.go
│ │ │ ├── counters.go
│ │ │ ├── file_context.go
│ │ │ ├── file_diagnostics.go
│ │ │ ├── file_metadata.go
│ │ │ ├── instructions.md
│ │ │ ├── mcp.go
│ │ │ ├── mcp_test.go
│ │ │ ├── outline.go
│ │ │ ├── references.go
│ │ │ ├── rename_symbol.go
│ │ │ ├── search.go
│ │ │ ├── symbol_references.go
│ │ │ ├── vulncheck.go
│ │ │ ├── workspace.go
│ │ │ └── workspace_diagnostics.go
│ │ ├── mod/
│ │ │ ├── code_lens.go
│ │ │ ├── diagnostics.go
│ │ │ ├── format.go
│ │ │ ├── hover.go
│ │ │ ├── inlay_hint.go
│ │ │ └── references.go
│ │ ├── progress/
│ │ │ ├── progress.go
│ │ │ └── progress_test.go
│ │ ├── protocol/
│ │ │ ├── command/
│ │ │ │ ├── command_gen.go
│ │ │ │ ├── commandmeta/
│ │ │ │ │ └── meta.go
│ │ │ │ ├── gen/
│ │ │ │ │ └── gen.go
│ │ │ │ ├── generate.go
│ │ │ │ ├── interface.go
│ │ │ │ ├── interface_test.go
│ │ │ │ └── util.go
│ │ │ ├── context.go
│ │ │ ├── doc.go
│ │ │ ├── edits.go
│ │ │ ├── enums.go
│ │ │ ├── form.go
│ │ │ ├── generate/
│ │ │ │ ├── README.md
│ │ │ │ ├── generate.go
│ │ │ │ ├── main.go
│ │ │ │ ├── main_test.go
│ │ │ │ ├── output.go
│ │ │ │ ├── tables.go
│ │ │ │ ├── typenames.go
│ │ │ │ └── types.go
│ │ │ ├── json_test.go
│ │ │ ├── log.go
│ │ │ ├── mapper.go
│ │ │ ├── mapper_test.go
│ │ │ ├── protocol.go
│ │ │ ├── semtok/
│ │ │ │ ├── README.txt
│ │ │ │ └── semtok.go
│ │ │ ├── span.go
│ │ │ ├── tsclient.go
│ │ │ ├── tsdocument_changes.go
│ │ │ ├── tsinsertreplaceedit.go
│ │ │ ├── tsinsertreplaceedit_test.go
│ │ │ ├── tsjson.go
│ │ │ ├── tsprotocol.go
│ │ │ ├── tsserver.go
│ │ │ ├── uri.go
│ │ │ ├── uri_test.go
│ │ │ └── uri_windows_test.go
│ │ ├── server/
│ │ │ ├── assets/
│ │ │ │ ├── common.css
│ │ │ │ ├── common.js
│ │ │ │ ├── splitpkg.css
│ │ │ │ └── splitpkg.js
│ │ │ ├── call_hierarchy.go
│ │ │ ├── code_action.go
│ │ │ ├── code_lens.go
│ │ │ ├── command.go
│ │ │ ├── completion.go
│ │ │ ├── counters.go
│ │ │ ├── debug.go
│ │ │ ├── definition.go
│ │ │ ├── diagnostics.go
│ │ │ ├── folding_range.go
│ │ │ ├── format.go
│ │ │ ├── general.go
│ │ │ ├── highlight.go
│ │ │ ├── hover.go
│ │ │ ├── implementation.go
│ │ │ ├── inlay_hint.go
│ │ │ ├── link.go
│ │ │ ├── prompt.go
│ │ │ ├── prompt_test.go
│ │ │ ├── references.go
│ │ │ ├── rename.go
│ │ │ ├── resolve.go
│ │ │ ├── selection_range.go
│ │ │ ├── semantic.go
│ │ │ ├── server.go
│ │ │ ├── signature_help.go
│ │ │ ├── symbols.go
│ │ │ ├── text_synchronization.go
│ │ │ ├── type_hierarchy.go
│ │ │ ├── unimplemented.go
│ │ │ ├── vulncheck_prompt.go
│ │ │ ├── vulncheck_prompt_test.go
│ │ │ ├── workspace.go
│ │ │ └── workspace_symbol.go
│ │ ├── settings/
│ │ │ ├── analysis.go
│ │ │ ├── codeactionkind.go
│ │ │ ├── default.go
│ │ │ ├── settings.go
│ │ │ ├── settings_test.go
│ │ │ ├── staticcheck.go
│ │ │ └── vet_test.go
│ │ ├── telemetry/
│ │ │ ├── counterpath.go
│ │ │ ├── counterpath_test.go
│ │ │ ├── latency.go
│ │ │ └── telemetry_test.go
│ │ ├── template/
│ │ │ ├── completion.go
│ │ │ ├── completion_test.go
│ │ │ ├── highlight.go
│ │ │ ├── implementations.go
│ │ │ ├── parse.go
│ │ │ ├── parse_test.go
│ │ │ └── symbols.go
│ │ ├── test/
│ │ │ ├── compare/
│ │ │ │ ├── text.go
│ │ │ │ └── text_test.go
│ │ │ ├── integration/
│ │ │ │ ├── bench/
│ │ │ │ │ ├── bench_test.go
│ │ │ │ │ ├── codeaction_test.go
│ │ │ │ │ ├── completion_test.go
│ │ │ │ │ ├── definition_test.go
│ │ │ │ │ ├── diagnostic_test.go
│ │ │ │ │ ├── didchange_test.go
│ │ │ │ │ ├── doc.go
│ │ │ │ │ ├── hover_test.go
│ │ │ │ │ ├── implementations_test.go
│ │ │ │ │ ├── imports_test.go
│ │ │ │ │ ├── iwl_test.go
│ │ │ │ │ ├── references_test.go
│ │ │ │ │ ├── reload_test.go
│ │ │ │ │ ├── rename_test.go
│ │ │ │ │ ├── repo_test.go
│ │ │ │ │ ├── stress_test.go
│ │ │ │ │ ├── tests_test.go
│ │ │ │ │ ├── typing_test.go
│ │ │ │ │ ├── unimported_test.go
│ │ │ │ │ └── workspace_symbols_test.go
│ │ │ │ ├── codelens/
│ │ │ │ │ └── codelens_test.go
│ │ │ │ ├── completion/
│ │ │ │ │ ├── completion18_test.go
│ │ │ │ │ ├── completion_test.go
│ │ │ │ │ ├── fixedbugs_test.go
│ │ │ │ │ └── postfix_snippet_test.go
│ │ │ │ ├── debug/
│ │ │ │ │ └── debug_test.go
│ │ │ │ ├── diagnostics/
│ │ │ │ │ ├── analysis_test.go
│ │ │ │ │ ├── builtin_test.go
│ │ │ │ │ ├── diagnostics_test.go
│ │ │ │ │ ├── golist_test.go
│ │ │ │ │ ├── gopackagesdriver_test.go
│ │ │ │ │ ├── invalidation_test.go
│ │ │ │ │ └── undeclared_test.go
│ │ │ │ ├── doc.go
│ │ │ │ ├── env.go
│ │ │ │ ├── env_test.go
│ │ │ │ ├── expectation.go
│ │ │ │ ├── fake/
│ │ │ │ │ ├── client.go
│ │ │ │ │ ├── doc.go
│ │ │ │ │ ├── edit.go
│ │ │ │ │ ├── edit_test.go
│ │ │ │ │ ├── editor.go
│ │ │ │ │ ├── editor_test.go
│ │ │ │ │ ├── glob/
│ │ │ │ │ │ ├── glob.go
│ │ │ │ │ │ └── glob_test.go
│ │ │ │ │ ├── proxy.go
│ │ │ │ │ ├── sandbox.go
│ │ │ │ │ ├── workdir.go
│ │ │ │ │ ├── workdir_test.go
│ │ │ │ │ └── workdir_windows.go
│ │ │ │ ├── hover/
│ │ │ │ │ └── hover_test.go
│ │ │ │ ├── inlayhints/
│ │ │ │ │ └── inlayhints_test.go
│ │ │ │ ├── misc/
│ │ │ │ │ ├── addtest_test.go
│ │ │ │ │ ├── call_hierarchy_test.go
│ │ │ │ │ ├── codeactions_test.go
│ │ │ │ │ ├── compileropt_test.go
│ │ │ │ │ ├── configuration_test.go
│ │ │ │ │ ├── debugserver_test.go
│ │ │ │ │ ├── definition_test.go
│ │ │ │ │ ├── embed_test.go
│ │ │ │ │ ├── extract_test.go
│ │ │ │ │ ├── failures_test.go
│ │ │ │ │ ├── filecache_test.go
│ │ │ │ │ ├── fix_test.go
│ │ │ │ │ ├── formatting_test.go
│ │ │ │ │ ├── generate_test.go
│ │ │ │ │ ├── highlight_test.go
│ │ │ │ │ ├── hover_test.go
│ │ │ │ │ ├── import_test.go
│ │ │ │ │ ├── imports_test.go
│ │ │ │ │ ├── link_test.go
│ │ │ │ │ ├── misc_test.go
│ │ │ │ │ ├── modify_tags_test.go
│ │ │ │ │ ├── multiple_adhoc_test.go
│ │ │ │ │ ├── package_symbols_test.go
│ │ │ │ │ ├── prompt_test.go
│ │ │ │ │ ├── references_test.go
│ │ │ │ │ ├── rename_test.go
│ │ │ │ │ ├── semantictokens_test.go
│ │ │ │ │ ├── settings_test.go
│ │ │ │ │ ├── shared_test.go
│ │ │ │ │ ├── signature_help_test.go
│ │ │ │ │ ├── staticcheck_test.go
│ │ │ │ │ ├── test_test.go
│ │ │ │ │ ├── vendor_test.go
│ │ │ │ │ ├── vuln_test.go
│ │ │ │ │ └── workspace_symbol_test.go
│ │ │ │ ├── modfile/
│ │ │ │ │ ├── modfile_test.go
│ │ │ │ │ └── tempmodfile_test.go
│ │ │ │ ├── options.go
│ │ │ │ ├── regtest.go
│ │ │ │ ├── runner.go
│ │ │ │ ├── template/
│ │ │ │ │ └── template_test.go
│ │ │ │ ├── watch/
│ │ │ │ │ ├── setting_test.go
│ │ │ │ │ └── watch_test.go
│ │ │ │ ├── web/
│ │ │ │ │ ├── assembly_test.go
│ │ │ │ │ ├── flight_test.go
│ │ │ │ │ ├── freesymbols_test.go
│ │ │ │ │ ├── pkdoc_test.go
│ │ │ │ │ ├── splitpkg_test.go
│ │ │ │ │ └── util_test.go
│ │ │ │ ├── workspace/
│ │ │ │ │ ├── adhoc_test.go
│ │ │ │ │ ├── broken_test.go
│ │ │ │ │ ├── didcreatefiles_test.go
│ │ │ │ │ ├── directoryfilters_test.go
│ │ │ │ │ ├── fromenv_test.go
│ │ │ │ │ ├── goversion_test.go
│ │ │ │ │ ├── metadata_test.go
│ │ │ │ │ ├── misspelling_test.go
│ │ │ │ │ ├── modules_test.go
│ │ │ │ │ ├── multi_folder_test.go
│ │ │ │ │ ├── packages_test.go
│ │ │ │ │ ├── quickfix_test.go
│ │ │ │ │ ├── standalone_test.go
│ │ │ │ │ ├── std_test.go
│ │ │ │ │ ├── vendor_test.go
│ │ │ │ │ ├── workspace_test.go
│ │ │ │ │ └── zero_config_test.go
│ │ │ │ └── wrappers.go
│ │ │ └── marker/
│ │ │ ├── doc.go
│ │ │ ├── marker_test.go
│ │ │ └── testdata/
│ │ │ ├── callhierarchy/
│ │ │ │ ├── callhierarchy.txt
│ │ │ │ ├── issue64451.txt
│ │ │ │ ├── issue66923.txt
│ │ │ │ └── issue75230.txt
│ │ │ ├── codeaction/
│ │ │ │ ├── add_struct_tags.txt
│ │ │ │ ├── addtest.txt
│ │ │ │ ├── change_quote.txt
│ │ │ │ ├── eliminate_dot_import.txt
│ │ │ │ ├── extract-variadic-63287.txt
│ │ │ │ ├── extract_anonymous_struct.txt
│ │ │ │ ├── extract_control.txt
│ │ │ │ ├── extract_control_label.txt
│ │ │ │ ├── extract_method.txt
│ │ │ │ ├── extract_return_err.txt
│ │ │ │ ├── extract_variable-67905.txt
│ │ │ │ ├── extract_variable-70563.txt
│ │ │ │ ├── extract_variable-if.txt
│ │ │ │ ├── extract_variable-inexact.txt
│ │ │ │ ├── extract_variable-toplevel.txt
│ │ │ │ ├── extract_variable.txt
│ │ │ │ ├── extract_variable_all.txt
│ │ │ │ ├── extract_variable_all_resolve.txt
│ │ │ │ ├── extract_variable_resolve.txt
│ │ │ │ ├── extracttofile.txt
│ │ │ │ ├── failedresolve.txt
│ │ │ │ ├── fill_struct.txt
│ │ │ │ ├── fill_struct_resolve.txt
│ │ │ │ ├── fill_switch.txt
│ │ │ │ ├── fill_switch_resolve.txt
│ │ │ │ ├── functionextraction.txt
│ │ │ │ ├── functionextraction_issue44813.txt
│ │ │ │ ├── functionextraction_issue50851.txt
│ │ │ │ ├── functionextraction_issue66289.txt
│ │ │ │ ├── functionextraction_issue73972.txt
│ │ │ │ ├── grouplines.txt
│ │ │ │ ├── import-shadows-builtin.txt
│ │ │ │ ├── imports-generated.txt
│ │ │ │ ├── imports.txt
│ │ │ │ ├── inline-lhs-var-method.txt
│ │ │ │ ├── inline-lhs-var.txt
│ │ │ │ ├── inline-var-74347.txt
│ │ │ │ ├── inline-var-74347b.txt
│ │ │ │ ├── inline-var-76144.txt
│ │ │ │ ├── inline-var-parens.txt
│ │ │ │ ├── inline-var.txt
│ │ │ │ ├── inline-version.txt
│ │ │ │ ├── inline.txt
│ │ │ │ ├── inline_issue67336.txt
│ │ │ │ ├── inline_issue68554.txt
│ │ │ │ ├── inline_resolve.txt
│ │ │ │ ├── invertif.txt
│ │ │ │ ├── issue64558.txt
│ │ │ │ ├── issue70268.txt
│ │ │ │ ├── moveparam.txt
│ │ │ │ ├── moveparam_issue70599.txt
│ │ │ │ ├── remove_struct_tags.txt
│ │ │ │ ├── removeparam.txt
│ │ │ │ ├── removeparam_formatting.txt
│ │ │ │ ├── removeparam_funcvalue.txt
│ │ │ │ ├── removeparam_imports.txt
│ │ │ │ ├── removeparam_issue65217.txt
│ │ │ │ ├── removeparam_method.txt
│ │ │ │ ├── removeparam_resolve.txt
│ │ │ │ ├── removeparam_satisfies.txt
│ │ │ │ ├── removeparam_witherrs.txt
│ │ │ │ ├── splitlines-variadic.txt
│ │ │ │ └── splitlines.txt
│ │ │ ├── codelens/
│ │ │ │ ├── generate.txt
│ │ │ │ └── test.txt
│ │ │ ├── completion/
│ │ │ │ ├── address.txt
│ │ │ │ ├── alias.txt
│ │ │ │ ├── anon.txt
│ │ │ │ ├── append.txt
│ │ │ │ ├── assign.txt
│ │ │ │ ├── bad.txt
│ │ │ │ ├── basic_lit.txt
│ │ │ │ ├── builtins.txt
│ │ │ │ ├── casesensitive.txt
│ │ │ │ ├── cast.txt
│ │ │ │ ├── channel.txt
│ │ │ │ ├── comment.txt
│ │ │ │ ├── complit.txt
│ │ │ │ ├── constant.txt
│ │ │ │ ├── danglingstmt.txt
│ │ │ │ ├── deep.txt
│ │ │ │ ├── deep2.txt
│ │ │ │ ├── errors.txt
│ │ │ │ ├── field_list.txt
│ │ │ │ ├── foobarbaz.txt
│ │ │ │ ├── func_rank.txt
│ │ │ │ ├── func_sig.txt
│ │ │ │ ├── func_snippets.txt
│ │ │ │ ├── func_value.txt
│ │ │ │ ├── fuzzy.txt
│ │ │ │ ├── imported-std.txt
│ │ │ │ ├── index.txt
│ │ │ │ ├── interfacerank.txt
│ │ │ │ ├── issue51783.txt
│ │ │ │ ├── issue56505.txt
│ │ │ │ ├── issue59096.txt
│ │ │ │ ├── issue60545.txt
│ │ │ │ ├── issue62141.txt
│ │ │ │ ├── issue62560.txt
│ │ │ │ ├── issue62676.txt
│ │ │ │ ├── issue70636.txt
│ │ │ │ ├── issue72753.txt
│ │ │ │ ├── keywords.txt
│ │ │ │ ├── labels.txt
│ │ │ │ ├── lit.txt
│ │ │ │ ├── maps.txt
│ │ │ │ ├── multi_return.txt
│ │ │ │ ├── nested_complit.txt
│ │ │ │ ├── postfix.txt
│ │ │ │ ├── postfix_placeholder.txt
│ │ │ │ ├── printf.txt
│ │ │ │ ├── randv2.txt
│ │ │ │ ├── range_func.txt
│ │ │ │ ├── rank.txt
│ │ │ │ ├── snippet.txt
│ │ │ │ ├── snippet_placeholder.txt
│ │ │ │ ├── statements.txt
│ │ │ │ ├── testy.txt
│ │ │ │ ├── type_assert.txt
│ │ │ │ ├── type_mods.txt
│ │ │ │ ├── type_params.txt
│ │ │ │ ├── type_params_reverse_infer.txt
│ │ │ │ ├── unimported-std.txt
│ │ │ │ ├── unimported.txt
│ │ │ │ ├── unresolved.txt
│ │ │ │ ├── unsafe.txt
│ │ │ │ └── variadic.txt
│ │ │ ├── configuration/
│ │ │ │ └── static.txt
│ │ │ ├── definition/
│ │ │ │ ├── asm.txt
│ │ │ │ ├── branch.txt
│ │ │ │ ├── branch_issue73797.txt
│ │ │ │ ├── branch_issue73797_go124.txt
│ │ │ │ ├── cgo.txt
│ │ │ │ ├── comment.txt
│ │ │ │ ├── embed.txt
│ │ │ │ ├── import.txt
│ │ │ │ ├── misc.txt
│ │ │ │ ├── nearby.txt
│ │ │ │ ├── return.txt
│ │ │ │ ├── standalone.txt
│ │ │ │ └── standalone_issue64557.txt
│ │ │ ├── diagnostics/
│ │ │ │ ├── addgowork.txt
│ │ │ │ ├── analyzers.txt
│ │ │ │ ├── excludedfile.txt
│ │ │ │ ├── generated.txt
│ │ │ │ ├── initcycle.txt
│ │ │ │ ├── issue56943.txt
│ │ │ │ ├── issue59005.txt
│ │ │ │ ├── issue60544.txt
│ │ │ │ ├── issue60605.txt
│ │ │ │ ├── issue64547.txt
│ │ │ │ ├── issue67360.txt
│ │ │ │ ├── issue69505.txt
│ │ │ │ ├── issue70791.txt
│ │ │ │ ├── issue71812.txt
│ │ │ │ ├── osarch_suffix.txt
│ │ │ │ ├── parseerr.txt
│ │ │ │ ├── rundespiteerrors.txt
│ │ │ │ ├── stdversion.txt
│ │ │ │ ├── stdversion_synctest.txt
│ │ │ │ ├── strangefiles.txt
│ │ │ │ ├── typeerr.txt
│ │ │ │ ├── useinternal.txt
│ │ │ │ └── usemodule.txt
│ │ │ ├── fixedbugs/
│ │ │ │ ├── issue59318.txt
│ │ │ │ ├── issue59944.txt
│ │ │ │ ├── issue61543.txt
│ │ │ │ ├── issue66109.txt
│ │ │ │ ├── issue66250.txt
│ │ │ │ ├── issue66876.txt
│ │ │ │ ├── issue71044.txt
│ │ │ │ └── issue74581.txt
│ │ │ ├── foldingrange/
│ │ │ │ ├── a.txt
│ │ │ │ ├── a_lineonly.txt
│ │ │ │ ├── bad.txt
│ │ │ │ └── parse_errors.txt
│ │ │ ├── format/
│ │ │ │ ├── format.txt
│ │ │ │ ├── generated.txt
│ │ │ │ ├── issue59554.txt
│ │ │ │ └── noparse.txt
│ │ │ ├── highlight/
│ │ │ │ ├── controlflow.txt
│ │ │ │ ├── highlight.txt
│ │ │ │ ├── highlight_kind.txt
│ │ │ │ ├── highlight_printf.txt
│ │ │ │ ├── issue60435.txt
│ │ │ │ ├── issue68918.txt
│ │ │ │ └── switchbreak.txt
│ │ │ ├── hover/
│ │ │ │ ├── basiclit.txt
│ │ │ │ ├── comment.txt
│ │ │ │ ├── const.txt
│ │ │ │ ├── embed.txt
│ │ │ │ ├── expression.txt
│ │ │ │ ├── fileuri.txt
│ │ │ │ ├── generics.txt
│ │ │ │ ├── godef.txt
│ │ │ │ ├── goprivate.txt
│ │ │ │ ├── hover-74351.txt
│ │ │ │ ├── hover.txt
│ │ │ │ ├── hover_alias.txt
│ │ │ │ ├── issue74361.txt
│ │ │ │ ├── issue75975.txt
│ │ │ │ ├── issues.txt
│ │ │ │ ├── json.txt
│ │ │ │ ├── linkable.txt
│ │ │ │ ├── linkable_generics.txt
│ │ │ │ ├── linkname.txt
│ │ │ │ ├── methods.txt
│ │ │ │ ├── pointerdoclink.txt
│ │ │ │ ├── return.txt
│ │ │ │ ├── sizeoffset.txt
│ │ │ │ ├── std.txt
│ │ │ │ └── structfield.txt
│ │ │ ├── implementation/
│ │ │ │ ├── basic.txt
│ │ │ │ ├── generics-basicalias.txt
│ │ │ │ ├── generics.txt
│ │ │ │ ├── issue43655.txt
│ │ │ │ ├── issue67041.txt
│ │ │ │ ├── issue68641.txt
│ │ │ │ ├── issue74305.txt
│ │ │ │ └── signature.txt
│ │ │ ├── inlayhints/
│ │ │ │ ├── ignored-error.txt
│ │ │ │ ├── inlayhints.txt
│ │ │ │ └── issue67142.txt
│ │ │ ├── links/
│ │ │ │ └── links.txt
│ │ │ ├── mcptools/
│ │ │ │ ├── context.txt
│ │ │ │ ├── file_context.txt
│ │ │ │ ├── file_diagnostics.txt
│ │ │ │ ├── file_metadata.txt
│ │ │ │ ├── package_api.txt
│ │ │ │ ├── references.txt
│ │ │ │ ├── rename_symbol.txt
│ │ │ │ ├── search.txt
│ │ │ │ ├── symbol_references.txt
│ │ │ │ ├── workspace.txt
│ │ │ │ ├── workspace_diagnostics.txt
│ │ │ │ └── workspace_diagnostics_empty.txt
│ │ │ ├── modfile/
│ │ │ │ ├── godebug.txt
│ │ │ │ └── godebug_bad.txt
│ │ │ ├── quickfix/
│ │ │ │ ├── embeddirective.txt
│ │ │ │ ├── infertypeargs.txt
│ │ │ │ ├── issue65024.txt
│ │ │ │ ├── noresultvalues.txt
│ │ │ │ ├── self_assignment.txt
│ │ │ │ ├── stub.txt
│ │ │ │ ├── stubmethods/
│ │ │ │ │ ├── basic.txt
│ │ │ │ │ ├── basic_resolve.txt
│ │ │ │ │ ├── fromcall_basic.txt
│ │ │ │ │ ├── fromcall_params.txt
│ │ │ │ │ ├── fromcall_returns.txt
│ │ │ │ │ ├── issue61693.txt
│ │ │ │ │ ├── issue61830.txt
│ │ │ │ │ ├── issue64078.txt
│ │ │ │ │ ├── issue64114.txt
│ │ │ │ │ ├── shadowedmethods.txt
│ │ │ │ │ └── stuberrors.txt
│ │ │ │ ├── undeclared/
│ │ │ │ │ ├── diag.txt
│ │ │ │ │ ├── missingfunction.txt
│ │ │ │ │ ├── undeclared_variable.txt
│ │ │ │ │ └── undeclaredfunc.txt
│ │ │ │ ├── unusedrequire.txt
│ │ │ │ └── unusedrequire_gowork.txt
│ │ │ ├── references/
│ │ │ │ ├── crosspackage.txt
│ │ │ │ ├── imports.txt
│ │ │ │ ├── interfaces.txt
│ │ │ │ ├── intrapackage.txt
│ │ │ │ ├── issue58506.txt
│ │ │ │ ├── issue59851.txt
│ │ │ │ ├── issue60369.txt
│ │ │ │ ├── issue60622.txt
│ │ │ │ ├── issue60676.txt
│ │ │ │ ├── issue61618.txt
│ │ │ │ ├── issue67978.txt
│ │ │ │ ├── issue75810.txt
│ │ │ │ ├── issue75810A.txt
│ │ │ │ ├── issue76872.txt
│ │ │ │ ├── shadow.txt
│ │ │ │ ├── test.txt
│ │ │ │ └── typeswitch.txt
│ │ │ ├── rename/
│ │ │ │ ├── bad.txt
│ │ │ │ ├── basic.txt
│ │ │ │ ├── conflict.txt
│ │ │ │ ├── crosspkg.txt
│ │ │ │ ├── doclink.txt
│ │ │ │ ├── embed.txt
│ │ │ │ ├── func.txt
│ │ │ │ ├── generics.txt
│ │ │ │ ├── generics_basic.txt
│ │ │ │ ├── issue39614.txt
│ │ │ │ ├── issue42134.txt
│ │ │ │ ├── issue42301.txt
│ │ │ │ ├── issue43616.txt
│ │ │ │ ├── issue57479.txt
│ │ │ │ ├── issue60752.txt
│ │ │ │ ├── issue60789.txt
│ │ │ │ ├── issue61294.txt
│ │ │ │ ├── issue61640.txt
│ │ │ │ ├── issue61813.txt
│ │ │ │ ├── issue65098.txt
│ │ │ │ ├── issue67069.txt
│ │ │ │ ├── issue70968.txt
│ │ │ │ ├── methods.txt
│ │ │ │ ├── packagedecl.txt
│ │ │ │ ├── pkgpath.txt
│ │ │ │ ├── prepare.txt
│ │ │ │ ├── prepare_func.txt
│ │ │ │ ├── prepare_move.txt
│ │ │ │ ├── random.txt
│ │ │ │ ├── recv.txt
│ │ │ │ ├── shadow.txt
│ │ │ │ ├── testy.txt
│ │ │ │ ├── typeswitch.txt
│ │ │ │ └── unexported.txt
│ │ │ ├── selectionrange/
│ │ │ │ └── selectionrange.txt
│ │ │ ├── signature/
│ │ │ │ ├── generic.txt
│ │ │ │ ├── issue63804.txt
│ │ │ │ ├── issue69552.txt
│ │ │ │ └── signature.txt
│ │ │ ├── symbol/
│ │ │ │ ├── basic.txt
│ │ │ │ └── generic.txt
│ │ │ ├── token/
│ │ │ │ ├── comment.txt
│ │ │ │ ├── format.txt
│ │ │ │ ├── illformed.txt
│ │ │ │ ├── issue66809.txt
│ │ │ │ ├── issue70251.txt
│ │ │ │ ├── modifiers.txt
│ │ │ │ └── range.txt
│ │ │ ├── typedef/
│ │ │ │ ├── expression.txt
│ │ │ │ ├── issue60544.txt
│ │ │ │ └── typedef.txt
│ │ │ ├── typehierarchy/
│ │ │ │ └── basic.txt
│ │ │ ├── workfile/
│ │ │ │ ├── godebug.txt
│ │ │ │ └── godebug_bad.txt
│ │ │ ├── workspacesymbol/
│ │ │ │ ├── allscope.txt
│ │ │ │ ├── caseinsensitive.txt
│ │ │ │ ├── casesensitive.txt
│ │ │ │ ├── issue44806.txt
│ │ │ │ ├── workspacesymbol.txt
│ │ │ │ └── wsscope.txt
│ │ │ └── zeroconfig/
│ │ │ ├── adhoc.txt
│ │ │ ├── dynamicports.txt
│ │ │ ├── nested.txt
│ │ │ └── nonworkspacemodule.txt
│ │ ├── util/
│ │ │ ├── README.md
│ │ │ ├── asm/
│ │ │ │ ├── parse.go
│ │ │ │ └── parse_test.go
│ │ │ ├── browser/
│ │ │ │ ├── README.md
│ │ │ │ └── browser.go
│ │ │ ├── bug/
│ │ │ │ ├── bug.go
│ │ │ │ └── bug_test.go
│ │ │ ├── constraints/
│ │ │ │ └── constraint.go
│ │ │ ├── cursorutil/
│ │ │ │ └── util.go
│ │ │ ├── fakenet/
│ │ │ │ └── conn.go
│ │ │ ├── fingerprint/
│ │ │ │ ├── fingerprint.go
│ │ │ │ └── fingerprint_test.go
│ │ │ ├── frob/
│ │ │ │ ├── frob.go
│ │ │ │ └── frob_test.go
│ │ │ ├── goversion/
│ │ │ │ ├── goversion.go
│ │ │ │ └── goversion_test.go
│ │ │ ├── immutable/
│ │ │ │ └── immutable.go
│ │ │ ├── lru/
│ │ │ │ ├── lru.go
│ │ │ │ ├── lru_fuzz_test.go
│ │ │ │ ├── lru_nil_test.go
│ │ │ │ └── lru_test.go
│ │ │ ├── memoize/
│ │ │ │ ├── memoize.go
│ │ │ │ └── memoize_test.go
│ │ │ ├── moremaps/
│ │ │ │ └── maps.go
│ │ │ ├── moreslices/
│ │ │ │ └── slices.go
│ │ │ ├── morestrings/
│ │ │ │ └── strings.go
│ │ │ ├── pathutil/
│ │ │ │ └── util.go
│ │ │ ├── persistent/
│ │ │ │ ├── map.go
│ │ │ │ ├── map_test.go
│ │ │ │ ├── race_test.go
│ │ │ │ ├── set.go
│ │ │ │ └── set_test.go
│ │ │ ├── safetoken/
│ │ │ │ ├── safetoken.go
│ │ │ │ └── safetoken_test.go
│ │ │ ├── tokeninternal/
│ │ │ │ └── tokeninternal.go
│ │ │ └── typesutil/
│ │ │ └── typesutil.go
│ │ ├── version/
│ │ │ └── version.go
│ │ ├── vulncheck/
│ │ │ ├── copier.go
│ │ │ ├── govulncheck/
│ │ │ │ ├── govulncheck.go
│ │ │ │ ├── handler.go
│ │ │ │ └── jsonhandler.go
│ │ │ ├── osv/
│ │ │ │ └── osv.go
│ │ │ ├── scan/
│ │ │ │ └── command.go
│ │ │ ├── semver/
│ │ │ │ ├── semver.go
│ │ │ │ └── semver_test.go
│ │ │ ├── types.go
│ │ │ └── vulntest/
│ │ │ ├── db.go
│ │ │ ├── db_test.go
│ │ │ ├── report.go
│ │ │ ├── report_test.go
│ │ │ ├── stdlib.go
│ │ │ ├── stdlib_test.go
│ │ │ └── testdata/
│ │ │ ├── GO-2020-0001.json
│ │ │ └── report.yaml
│ │ └── work/
│ │ ├── completion.go
│ │ ├── diagnostics.go
│ │ ├── format.go
│ │ └── hover.go
│ └── main.go
├── imports/
│ └── forward.go
├── internal/
│ ├── aliases/
│ │ ├── aliases.go
│ │ └── aliases_test.go
│ ├── analysis/
│ │ ├── README
│ │ ├── analyzerutil/
│ │ │ ├── doc.go
│ │ │ ├── extractdoc.go
│ │ │ ├── extractdoc_test.go
│ │ │ ├── readfile.go
│ │ │ └── version.go
│ │ ├── driverutil/
│ │ │ ├── fix.go
│ │ │ ├── print.go
│ │ │ ├── readfile.go
│ │ │ ├── url.go
│ │ │ ├── url_test.go
│ │ │ └── validatefix.go
│ │ ├── generated/
│ │ │ └── generated.go
│ │ └── typeindex/
│ │ └── typeindex.go
│ ├── astutil/
│ │ ├── clone.go
│ │ ├── comment.go
│ │ ├── comment_test.go
│ │ ├── equal.go
│ │ ├── fields.go
│ │ ├── fields_test.go
│ │ ├── free/
│ │ │ ├── free.go
│ │ │ └── free_test.go
│ │ ├── purge.go
│ │ ├── purge_test.go
│ │ ├── stringlit.go
│ │ ├── stringlit_test.go
│ │ ├── unpack.go
│ │ └── util.go
│ ├── bisect/
│ │ ├── bisect.go
│ │ └── bisect_test.go
│ ├── diff/
│ │ ├── diff.go
│ │ ├── diff_test.go
│ │ ├── difftest/
│ │ │ ├── difftest.go
│ │ │ └── difftest_test.go
│ │ ├── export_test.go
│ │ ├── lcs/
│ │ │ ├── common.go
│ │ │ ├── common_test.go
│ │ │ ├── doc.go
│ │ │ ├── git.sh
│ │ │ ├── labels.go
│ │ │ ├── old.go
│ │ │ ├── old_test.go
│ │ │ └── sequence.go
│ │ ├── merge.go
│ │ ├── merge_test.go
│ │ ├── ndiff.go
│ │ └── unified.go
│ ├── diffp/
│ │ ├── diff.go
│ │ ├── diff_test.go
│ │ └── testdata/
│ │ ├── allnew.txt
│ │ ├── allold.txt
│ │ ├── basic.txt
│ │ ├── dups.txt
│ │ ├── end.txt
│ │ ├── eof.txt
│ │ ├── eof1.txt
│ │ ├── eof2.txt
│ │ ├── long.txt
│ │ ├── same.txt
│ │ ├── start.txt
│ │ └── triv.txt
│ ├── drivertest/
│ │ ├── driver.go
│ │ └── driver_test.go
│ ├── edit/
│ │ ├── edit.go
│ │ └── edit_test.go
│ ├── event/
│ │ ├── bench_test.go
│ │ ├── core/
│ │ │ ├── event.go
│ │ │ ├── export.go
│ │ │ └── fast.go
│ │ ├── doc.go
│ │ ├── event.go
│ │ ├── export/
│ │ │ ├── eventtest/
│ │ │ │ └── eventtest.go
│ │ │ ├── id.go
│ │ │ ├── labels.go
│ │ │ ├── log.go
│ │ │ ├── log_test.go
│ │ │ ├── metric/
│ │ │ │ ├── data.go
│ │ │ │ ├── exporter.go
│ │ │ │ └── info.go
│ │ │ ├── otel/
│ │ │ │ ├── common.go
│ │ │ │ ├── metrics.go
│ │ │ │ ├── metrics_test.go
│ │ │ │ ├── options.go
│ │ │ │ ├── otel.go
│ │ │ │ ├── otel_test.go
│ │ │ │ ├── otlp.go
│ │ │ │ ├── traces.go
│ │ │ │ └── traces_test.go
│ │ │ ├── printer.go
│ │ │ ├── prometheus/
│ │ │ │ └── prometheus.go
│ │ │ └── trace.go
│ │ ├── keys/
│ │ │ ├── keys.go
│ │ │ ├── standard.go
│ │ │ ├── util.go
│ │ │ └── util_test.go
│ │ └── label/
│ │ ├── label.go
│ │ └── label_test.go
│ ├── expect/
│ │ ├── expect.go
│ │ ├── expect_test.go
│ │ ├── extract.go
│ │ └── testdata/
│ │ ├── go.fake.mod
│ │ ├── go.fake.work
│ │ └── test.go
│ ├── facts/
│ │ ├── facts.go
│ │ ├── facts_test.go
│ │ └── imports.go
│ ├── fmtstr/
│ │ ├── main.go
│ │ └── parse.go
│ ├── gcimporter/
│ │ ├── bexport_test.go
│ │ ├── bimport.go
│ │ ├── exportdata.go
│ │ ├── gcimporter.go
│ │ ├── gcimporter_test.go
│ │ ├── iexport.go
│ │ ├── iexport_common_test.go
│ │ ├── iexport_go118_test.go
│ │ ├── iexport_test.go
│ │ ├── iimport.go
│ │ ├── israce_test.go
│ │ ├── main.go
│ │ ├── predeclared.go
│ │ ├── shallow_test.go
│ │ ├── stdlib_test.go
│ │ ├── support.go
│ │ ├── testdata/
│ │ │ ├── a/
│ │ │ │ └── a.go
│ │ │ ├── a.go
│ │ │ ├── aliases/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── b.go
│ │ │ ├── exports.go
│ │ │ ├── issue15920.go
│ │ │ ├── issue20046.go
│ │ │ ├── issue25301.go
│ │ │ ├── issue51836/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── a.go
│ │ │ │ └── aa.go
│ │ │ ├── issue57015.go
│ │ │ ├── issue58296/
│ │ │ │ ├── a/
│ │ │ │ │ └── a.go
│ │ │ │ ├── b/
│ │ │ │ │ └── b.go
│ │ │ │ └── c/
│ │ │ │ └── c.go
│ │ │ ├── p.go
│ │ │ └── versions/
│ │ │ ├── test.go
│ │ │ └── test_go1.20_u.a
│ │ └── ureader_yes.go
│ ├── gocommand/
│ │ ├── invoke.go
│ │ ├── invoke_notunix.go
│ │ ├── invoke_test.go
│ │ ├── invoke_unix.go
│ │ ├── vendor.go
│ │ ├── version.go
│ │ └── version_test.go
│ ├── gopathwalk/
│ │ ├── walk.go
│ │ └── walk_test.go
│ ├── goplsexport/
│ │ └── export.go
│ ├── goroot/
│ │ └── importcfg.go
│ ├── imports/
│ │ ├── fix.go
│ │ ├── fix_test.go
│ │ ├── imports.go
│ │ ├── imports_test.go
│ │ ├── mkindex.go
│ │ ├── mod.go
│ │ ├── mod_cache.go
│ │ ├── mod_cache_test.go
│ │ ├── mod_test.go
│ │ ├── sortimports.go
│ │ ├── source.go
│ │ ├── source_env.go
│ │ ├── source_modindex.go
│ │ ├── sourcex_test.go
│ │ └── testdata/
│ │ └── mod/
│ │ ├── example.com_v1.0.0.txt
│ │ ├── golang.org_x_text_v0.0.0-20170915032832-14c0d48ead0c.txt
│ │ ├── rsc.io_!q!u!o!t!e_v1.5.2.txt
│ │ ├── rsc.io_!q!u!o!t!e_v1.5.3-!p!r!e.txt
│ │ ├── rsc.io_quote_v1.5.1.txt
│ │ ├── rsc.io_quote_v1.5.2.txt
│ │ ├── rsc.io_quote_v2_v2.0.1.txt
│ │ ├── rsc.io_quote_v3_v3.0.0.txt
│ │ ├── rsc.io_sampler_v1.3.0.txt
│ │ └── rsc.io_sampler_v1.3.1.txt
│ ├── jsonrpc2/
│ │ ├── conn.go
│ │ ├── handler.go
│ │ ├── jsonrpc2.go
│ │ ├── jsonrpc2_test.go
│ │ ├── labels.go
│ │ ├── messages.go
│ │ ├── serve.go
│ │ ├── serve_test.go
│ │ ├── servertest/
│ │ │ ├── servertest.go
│ │ │ └── servertest_test.go
│ │ ├── stack/
│ │ │ ├── parse.go
│ │ │ ├── process.go
│ │ │ ├── stack.go
│ │ │ ├── stack_test.go
│ │ │ └── stacktest/
│ │ │ └── stacktest.go
│ │ ├── stream.go
│ │ ├── wire.go
│ │ └── wire_test.go
│ ├── jsonrpc2_v2/
│ │ ├── conn.go
│ │ ├── frame.go
│ │ ├── jsonrpc2.go
│ │ ├── jsonrpc2_test.go
│ │ ├── messages.go
│ │ ├── net.go
│ │ ├── serve.go
│ │ ├── serve_test.go
│ │ ├── wire.go
│ │ └── wire_test.go
│ ├── mcp/
│ │ ├── CONTRIBUTING.md
│ │ ├── README.md
│ │ ├── client.go
│ │ ├── client_list_test.go
│ │ ├── client_test.go
│ │ ├── cmd.go
│ │ ├── cmd_test.go
│ │ ├── conformance_go124_test.go
│ │ ├── conformance_go125_test.go
│ │ ├── conformance_test.go
│ │ ├── content.go
│ │ ├── content_test.go
│ │ ├── create-repo.sh
│ │ ├── design/
│ │ │ └── design.md
│ │ ├── example_progress_test.go
│ │ ├── examples/
│ │ │ ├── hello/
│ │ │ │ └── main.go
│ │ │ └── sse/
│ │ │ └── main.go
│ │ ├── features.go
│ │ ├── features_test.go
│ │ ├── generate.go
│ │ ├── internal/
│ │ │ ├── oauthex/
│ │ │ │ ├── oauth2.go
│ │ │ │ ├── oauth2_test.go
│ │ │ │ └── resource_meta.go
│ │ │ ├── readme/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.src.md
│ │ │ │ ├── build.sh
│ │ │ │ ├── client/
│ │ │ │ │ └── client.go
│ │ │ │ └── server/
│ │ │ │ └── server.go
│ │ │ └── util/
│ │ │ ├── util.go
│ │ │ └── util_test.go
│ │ ├── jsonschema/
│ │ │ ├── annotations.go
│ │ │ ├── doc.go
│ │ │ ├── infer.go
│ │ │ ├── infer_test.go
│ │ │ ├── json_pointer.go
│ │ │ ├── json_pointer_test.go
│ │ │ ├── meta-schemas/
│ │ │ │ └── draft2020-12/
│ │ │ │ ├── meta/
│ │ │ │ │ ├── applicator.json
│ │ │ │ │ ├── content.json
│ │ │ │ │ ├── core.json
│ │ │ │ │ ├── format-annotation.json
│ │ │ │ │ ├── meta-data.json
│ │ │ │ │ ├── unevaluated.json
│ │ │ │ │ └── validation.json
│ │ │ │ └── schema.json
│ │ │ ├── resolve.go
│ │ │ ├── resolve_test.go
│ │ │ ├── schema.go
│ │ │ ├── schema_test.go
│ │ │ ├── testdata/
│ │ │ │ ├── draft2020-12/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── additionalProperties.json
│ │ │ │ │ ├── allOf.json
│ │ │ │ │ ├── anchor.json
│ │ │ │ │ ├── anyOf.json
│ │ │ │ │ ├── boolean_schema.json
│ │ │ │ │ ├── const.json
│ │ │ │ │ ├── contains.json
│ │ │ │ │ ├── default.json
│ │ │ │ │ ├── defs.json
│ │ │ │ │ ├── dependentRequired.json
│ │ │ │ │ ├── dependentSchemas.json
│ │ │ │ │ ├── dynamicRef.json
│ │ │ │ │ ├── enum.json
│ │ │ │ │ ├── exclusiveMaximum.json
│ │ │ │ │ ├── exclusiveMinimum.json
│ │ │ │ │ ├── if-then-else.json
│ │ │ │ │ ├── infinite-loop-detection.json
│ │ │ │ │ ├── items.json
│ │ │ │ │ ├── maxContains.json
│ │ │ │ │ ├── maxItems.json
│ │ │ │ │ ├── maxLength.json
│ │ │ │ │ ├── maxProperties.json
│ │ │ │ │ ├── maximum.json
│ │ │ │ │ ├── minContains.json
│ │ │ │ │ ├── minItems.json
│ │ │ │ │ ├── minLength.json
│ │ │ │ │ ├── minProperties.json
│ │ │ │ │ ├── minimum.json
│ │ │ │ │ ├── multipleOf.json
│ │ │ │ │ ├── not.json
│ │ │ │ │ ├── oneOf.json
│ │ │ │ │ ├── pattern.json
│ │ │ │ │ ├── patternProperties.json
│ │ │ │ │ ├── prefixItems.json
│ │ │ │ │ ├── properties.json
│ │ │ │ │ ├── propertyNames.json
│ │ │ │ │ ├── ref.json
│ │ │ │ │ ├── refRemote.json
│ │ │ │ │ ├── required.json
│ │ │ │ │ ├── type.json
│ │ │ │ │ ├── unevaluatedItems.json
│ │ │ │ │ ├── unevaluatedProperties.json
│ │ │ │ │ └── uniqueItems.json
│ │ │ │ └── remotes/
│ │ │ │ ├── README.md
│ │ │ │ ├── different-id-ref-string.json
│ │ │ │ ├── draft2020-12/
│ │ │ │ │ ├── baseUriChange/
│ │ │ │ │ │ └── folderInteger.json
│ │ │ │ │ ├── baseUriChangeFolder/
│ │ │ │ │ │ └── folderInteger.json
│ │ │ │ │ ├── baseUriChangeFolderInSubschema/
│ │ │ │ │ │ └── folderInteger.json
│ │ │ │ │ ├── detached-dynamicref.json
│ │ │ │ │ ├── detached-ref.json
│ │ │ │ │ ├── extendible-dynamic-ref.json
│ │ │ │ │ ├── format-assertion-false.json
│ │ │ │ │ ├── format-assertion-true.json
│ │ │ │ │ ├── integer.json
│ │ │ │ │ ├── locationIndependentIdentifier.json
│ │ │ │ │ ├── metaschema-no-validation.json
│ │ │ │ │ ├── metaschema-optional-vocabulary.json
│ │ │ │ │ ├── name-defs.json
│ │ │ │ │ ├── nested/
│ │ │ │ │ │ ├── foo-ref-string.json
│ │ │ │ │ │ └── string.json
│ │ │ │ │ ├── prefixItems.json
│ │ │ │ │ ├── ref-and-defs.json
│ │ │ │ │ ├── subSchemas.json
│ │ │ │ │ └── tree.json
│ │ │ │ ├── nested-absolute-ref-to-string.json
│ │ │ │ └── urn-ref-string.json
│ │ │ ├── util.go
│ │ │ ├── util_test.go
│ │ │ ├── validate.go
│ │ │ └── validate_test.go
│ │ ├── logging.go
│ │ ├── mcp-repo-replace.txt
│ │ ├── mcp.go
│ │ ├── mcp_test.go
│ │ ├── prompt.go
│ │ ├── protocol.go
│ │ ├── resource.go
│ │ ├── resource_test.go
│ │ ├── root.go
│ │ ├── server.go
│ │ ├── server_example_test.go
│ │ ├── server_test.go
│ │ ├── shared.go
│ │ ├── shared_test.go
│ │ ├── sse.go
│ │ ├── sse_example_test.go
│ │ ├── sse_test.go
│ │ ├── streamable.go
│ │ ├── streamable_test.go
│ │ ├── testdata/
│ │ │ ├── conformance/
│ │ │ │ └── server/
│ │ │ │ ├── prompts.txtar
│ │ │ │ ├── resources.txtar
│ │ │ │ ├── tools.txtar
│ │ │ │ ├── version-latest.txtar
│ │ │ │ └── version-older.txtar
│ │ │ ├── files/
│ │ │ │ ├── info.txt
│ │ │ │ └── template.txt
│ │ │ ├── private.txt
│ │ │ └── public/
│ │ │ ├── dir/
│ │ │ │ └── file3.txt
│ │ │ ├── file1.txt
│ │ │ └── file2.txt
│ │ ├── tool.go
│ │ ├── tool_test.go
│ │ ├── transport.go
│ │ ├── transport_test.go
│ │ ├── util.go
│ │ └── util_test.go
│ ├── modindex/
│ │ ├── dir_test.go
│ │ ├── directories.go
│ │ ├── export_test.go
│ │ ├── gomodindex/
│ │ │ └── cmd.go
│ │ ├── index.go
│ │ ├── lookup.go
│ │ ├── lookup_test.go
│ │ ├── modindex.go
│ │ └── symbols.go
│ ├── moreiters/
│ │ └── iters.go
│ ├── packagepath/
│ │ ├── packagepath.go
│ │ └── packagepath_test.go
│ ├── packagesinternal/
│ │ └── packages.go
│ ├── packagestest/
│ │ ├── expect.go
│ │ ├── expect_test.go
│ │ ├── export.go
│ │ ├── export_test.go
│ │ ├── gopath.go
│ │ ├── gopath_test.go
│ │ ├── modules.go
│ │ ├── modules_test.go
│ │ └── testdata/
│ │ ├── groups/
│ │ │ ├── one/
│ │ │ │ ├── modules/
│ │ │ │ │ └── example.com/
│ │ │ │ │ └── extra/
│ │ │ │ │ └── help.go
│ │ │ │ └── primarymod/
│ │ │ │ └── main.go
│ │ │ └── two/
│ │ │ ├── modules/
│ │ │ │ └── example.com/
│ │ │ │ ├── extra/
│ │ │ │ │ ├── geez/
│ │ │ │ │ │ └── help.go
│ │ │ │ │ ├── v2/
│ │ │ │ │ │ ├── geez/
│ │ │ │ │ │ │ └── help.go
│ │ │ │ │ │ └── me.go
│ │ │ │ │ └── yo.go
│ │ │ │ ├── tempmod/
│ │ │ │ │ └── main.go
│ │ │ │ ├── what@v1.0.0/
│ │ │ │ │ └── main.go
│ │ │ │ └── what@v1.1.0/
│ │ │ │ └── main.go
│ │ │ └── primarymod/
│ │ │ ├── expect/
│ │ │ │ ├── yo.go
│ │ │ │ └── yo_test.go
│ │ │ └── main.go
│ │ ├── test.go
│ │ ├── test_test.go
│ │ └── x_test.go
│ ├── pkgbits/
│ │ ├── codes.go
│ │ ├── decoder.go
│ │ ├── doc.go
│ │ ├── encoder.go
│ │ ├── flags.go
│ │ ├── pkgbits_test.go
│ │ ├── reloc.go
│ │ ├── support.go
│ │ ├── sync.go
│ │ ├── syncmarker_string.go
│ │ └── version.go
│ ├── pprof/
│ │ ├── main.go
│ │ ├── pprof.go
│ │ ├── pprof_test.go
│ │ └── testdata/
│ │ └── sample.pprof
│ ├── proxydir/
│ │ ├── proxydir.go
│ │ └── proxydir_test.go
│ ├── refactor/
│ │ ├── delete.go
│ │ ├── delete_test.go
│ │ ├── edit.go
│ │ ├── imports.go
│ │ ├── imports_test.go
│ │ ├── inline/
│ │ │ ├── callee.go
│ │ │ ├── calleefx.go
│ │ │ ├── calleefx_test.go
│ │ │ ├── doc.go
│ │ │ ├── escape.go
│ │ │ ├── everything_test.go
│ │ │ ├── export_test.go
│ │ │ ├── falcon.go
│ │ │ ├── falcon_test.go
│ │ │ ├── inline.go
│ │ │ ├── inline_test.go
│ │ │ ├── testdata/
│ │ │ │ ├── assignment-splice.txtar
│ │ │ │ ├── assignment.txtar
│ │ │ │ ├── basic-err.txtar
│ │ │ │ ├── basic-literal.txtar
│ │ │ │ ├── basic-reduce.txtar
│ │ │ │ ├── cgo.txtar
│ │ │ │ ├── comments.txtar
│ │ │ │ ├── crosspkg-selfref.txtar
│ │ │ │ ├── crosspkg.txtar
│ │ │ │ ├── dotimport.txtar
│ │ │ │ ├── embed.txtar
│ │ │ │ ├── empty-body.txtar
│ │ │ │ ├── err-basic.txtar
│ │ │ │ ├── err-shadow-builtin.txtar
│ │ │ │ ├── err-shadow-pkg.txtar
│ │ │ │ ├── err-unexported.txtar
│ │ │ │ ├── exprstmt.txtar
│ │ │ │ ├── generic.txtar
│ │ │ │ ├── import-comments.txtar
│ │ │ │ ├── import-comments2.txtar
│ │ │ │ ├── import-preserve-local-pkgname.txtar
│ │ │ │ ├── import-rename.txtar
│ │ │ │ ├── import-shadow-1.txtar
│ │ │ │ ├── import-shadow-2.txtar
│ │ │ │ ├── import-shadow.txtar
│ │ │ │ ├── internal.txtar
│ │ │ │ ├── issue62667.txtar
│ │ │ │ ├── issue63298.txtar
│ │ │ │ ├── issue69441.txtar
│ │ │ │ ├── issue69442.txtar
│ │ │ │ ├── line-directives.txtar
│ │ │ │ ├── method.txtar
│ │ │ │ ├── multistmt-body.txtar
│ │ │ │ ├── n-ary.txtar
│ │ │ │ ├── newexpr.txtar
│ │ │ │ ├── param-subst.txtar
│ │ │ │ ├── revdotimport.txtar
│ │ │ │ ├── std-internal.txtar
│ │ │ │ ├── substgroups.txtar
│ │ │ │ └── tailcall.txtar
│ │ │ └── util.go
│ │ └── refactor.go
│ ├── robustio/
│ │ ├── copyfiles.go
│ │ ├── gopls_windows.go
│ │ ├── robustio.go
│ │ ├── robustio_darwin.go
│ │ ├── robustio_flaky.go
│ │ ├── robustio_other.go
│ │ ├── robustio_plan9.go
│ │ ├── robustio_posix.go
│ │ ├── robustio_test.go
│ │ └── robustio_windows.go
│ ├── stdlib/
│ │ ├── deps.go
│ │ ├── deps_test.go
│ │ ├── generate.go
│ │ ├── import.go
│ │ ├── manifest.go
│ │ ├── stdlib.go
│ │ └── testdata/
│ │ ├── nethttp.deps
│ │ └── nethttp.imports
│ ├── testenv/
│ │ ├── exec.go
│ │ ├── testenv.go
│ │ ├── testenv_notunix.go
│ │ └── testenv_unix.go
│ ├── testfiles/
│ │ ├── testdata/
│ │ │ ├── somefile.txt
│ │ │ └── versions/
│ │ │ ├── go.mod.test
│ │ │ ├── mod.go
│ │ │ ├── post.go
│ │ │ ├── pre.go
│ │ │ └── sub.test/
│ │ │ └── sub.go.test
│ │ ├── testfiles.go
│ │ └── testfiles_test.go
│ ├── tool/
│ │ └── tool.go
│ ├── typeparams/
│ │ ├── common.go
│ │ ├── common_test.go
│ │ ├── copytermlist.go
│ │ ├── coretype.go
│ │ ├── coretype_test.go
│ │ ├── free.go
│ │ ├── free_test.go
│ │ ├── genericfeatures/
│ │ │ └── features.go
│ │ ├── normalize.go
│ │ ├── normalize_test.go
│ │ ├── termlist.go
│ │ └── typeterm.go
│ ├── typesinternal/
│ │ ├── classify_call.go
│ │ ├── classify_call_test.go
│ │ ├── element.go
│ │ ├── element_test.go
│ │ ├── errorcode.go
│ │ ├── errorcode_string.go
│ │ ├── errorcode_test.go
│ │ ├── fx.go
│ │ ├── fx_test.go
│ │ ├── isnamed.go
│ │ ├── qualifier.go
│ │ ├── recv.go
│ │ ├── toonew.go
│ │ ├── typeindex/
│ │ │ ├── typeindex.go
│ │ │ └── typeindex_test.go
│ │ ├── types.go
│ │ ├── varkind.go
│ │ ├── varkind_go124.go
│ │ ├── zerovalue.go
│ │ └── zerovalue_test.go
│ ├── versions/
│ │ ├── features.go
│ │ ├── gover.go
│ │ ├── types.go
│ │ ├── types_test.go
│ │ ├── versions.go
│ │ └── versions_test.go
│ └── xcontext/
│ └── xcontext.go
├── playground/
│ ├── playground.go
│ └── socket/
│ ├── socket.go
│ └── socket_test.go
├── present/
│ ├── args.go
│ ├── caption.go
│ ├── code.go
│ ├── code_test.go
│ ├── doc.go
│ ├── html.go
│ ├── iframe.go
│ ├── image.go
│ ├── link.go
│ ├── link_test.go
│ ├── parse.go
│ ├── parse_test.go
│ ├── style.go
│ ├── style_test.go
│ ├── testdata/
│ │ ├── README
│ │ ├── basic.md
│ │ ├── basic.p
│ │ ├── code.md
│ │ ├── code.p
│ │ ├── code.txt
│ │ ├── list.md
│ │ ├── list.p
│ │ ├── media.html
│ │ ├── media.md
│ │ ├── media.p
│ │ ├── pre.md
│ │ └── pre.p
│ └── video.go
├── refactor/
│ ├── README
│ ├── eg/
│ │ ├── eg.go
│ │ ├── eg_test.go
│ │ ├── match.go
│ │ ├── rewrite.go
│ │ └── testdata/
│ │ ├── a.txtar
│ │ ├── b.txtar
│ │ ├── bad_type.txtar
│ │ ├── c.txtar
│ │ ├── d.txtar
│ │ ├── e.txtar
│ │ ├── expr_type_mismatch.txtar
│ │ ├── f.txtar
│ │ ├── g.txtar
│ │ ├── h.txtar
│ │ ├── i.txtar
│ │ ├── j.txtar
│ │ ├── no_after_return.txtar
│ │ ├── no_before.txtar
│ │ └── type_mismatch.txtar
│ ├── importgraph/
│ │ ├── graph.go
│ │ └── graph_test.go
│ ├── rename/
│ │ ├── check.go
│ │ ├── mvpkg.go
│ │ ├── mvpkg_test.go
│ │ ├── rename.go
│ │ ├── rename_test.go
│ │ ├── spec.go
│ │ └── util.go
│ └── satisfy/
│ ├── find.go
│ └── find_test.go
└── txtar/
├── archive.go
├── archive_test.go
├── fs.go
└── fs_test.go
Showing preview only (1,396K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (16875 symbols across 1738 files)
FILE: benchmark/parse/parse.go
constant NsPerOp (line 21) | NsPerOp = 1 << iota
constant MBPerS (line 22) | MBPerS
constant AllocedBytesPerOp (line 23) | AllocedBytesPerOp
constant AllocsPerOp (line 24) | AllocsPerOp
type Benchmark (line 28) | type Benchmark struct
method parseMeasurement (line 64) | func (b *Benchmark) parseMeasurement(quant string, unit string) {
method String (line 89) | func (b *Benchmark) String() string {
function ParseLine (line 41) | func ParseLine(line string) (*Benchmark, error) {
type Set (line 109) | type Set
function ParseSet (line 114) | func ParseSet(r io.Reader) (Set, error) {
FILE: benchmark/parse/parse_test.go
function TestParseLine (line 13) | func TestParseLine(t *testing.T) {
function TestParseSet (line 93) | func TestParseSet(t *testing.T) {
function TestString (line 156) | func TestString(t *testing.T) {
FILE: blog/atom/atom.go
type Feed (line 15) | type Feed struct
type Entry (line 25) | type Entry struct
type Link (line 36) | type Link struct
type Person (line 45) | type Person struct
type Text (line 52) | type Text struct
type TimeStr (line 57) | type TimeStr
function Time (line 59) | func Time(t time.Time) TimeStr {
FILE: blog/blog.go
type Config (line 37) | type Config struct
type Doc (line 56) | type Doc struct
type Server (line 67) | type Server struct
method loadDocs (line 192) | func (s *Server) loadDocs(root string) error {
method renderAtomFeed (line 300) | func (s *Server) renderAtomFeed() error {
method renderJSONFeed (line 372) | func (s *Server) renderJSONFeed() error {
method ServeHTTP (line 428) | func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
function NewServer (line 83) | func NewServer(cfg Config) (*Server, error) {
function sectioned (line 151) | func sectioned(d *present.Doc) bool {
function authors (line 156) | func authors(authors []present.Author) string {
function authorName (line 176) | func authorName(a present.Author) string {
type jsonItem (line 361) | type jsonItem struct
function summary (line 397) | func summary(d *Doc) string {
type rootData (line 418) | type rootData struct
type docsByTime (line 492) | type docsByTime
method Len (line 494) | func (s docsByTime) Len() int { return len(s) }
method Swap (line 495) | func (s docsByTime) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
method Less (line 496) | func (s docsByTime) Less(i, j int) bool { return s[i].Time.After(s[j]....
function notExist (line 499) | func notExist(path string) bool {
FILE: blog/blog_test.go
function TestLinkRewrite (line 12) | func TestLinkRewrite(t *testing.T) {
FILE: cmd/benchcmp/benchcmp.go
constant usageFooter (line 24) | usageFooter = `
function main (line 34) | func main() {
function fatal (line 136) | func fatal(msg any) {
function parseFile (line 141) | func parseFile(path string) parse.Set {
function selectBest (line 157) | func selectBest(bs parse.Set) {
function formatNs (line 176) | func formatNs(ns float64) string {
FILE: cmd/benchcmp/benchcmp_test.go
function TestSelectBest (line 14) | func TestSelectBest(t *testing.T) {
function TestFormatNs (line 65) | func TestFormatNs(t *testing.T) {
FILE: cmd/benchcmp/compare.go
type BenchCmp (line 15) | type BenchCmp struct
method Name (line 37) | func (c BenchCmp) Name() string { return c.Before.Name }
method String (line 38) | func (c BenchCmp) String() string { return fmt.Sprintf("<%s, %...
method Measured (line 39) | func (c BenchCmp) Measured(flag int) bool { return (c.Before.Measured ...
method DeltaNsPerOp (line 40) | func (c BenchCmp) DeltaNsPerOp() Delta { return Delta{c.Before.NsPe...
method DeltaMBPerS (line 41) | func (c BenchCmp) DeltaMBPerS() Delta { return Delta{c.Before.MBPe...
method DeltaAllocedBytesPerOp (line 42) | func (c BenchCmp) DeltaAllocedBytesPerOp() Delta {
method DeltaAllocsPerOp (line 45) | func (c BenchCmp) DeltaAllocsPerOp() Delta {
function Correlate (line 21) | func Correlate(before, after parse.Set) (cmps []BenchCmp, warnings []str...
type Delta (line 51) | type Delta struct
method mag (line 58) | func (d Delta) mag() float64 {
method Changed (line 74) | func (d Delta) Changed() bool { return d.Before != d.After }
method Float64 (line 78) | func (d Delta) Float64() float64 {
method Percent (line 90) | func (d Delta) Percent() string {
method Multiple (line 95) | func (d Delta) Multiple() string {
method String (line 99) | func (d Delta) String() string {
type ByParseOrder (line 105) | type ByParseOrder
method Len (line 107) | func (x ByParseOrder) Len() int { return len(x) }
method Swap (line 108) | func (x ByParseOrder) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
method Less (line 109) | func (x ByParseOrder) Less(i, j int) bool { return x[i].Before.Ord < x...
function lessByDelta (line 114) | func lessByDelta(i, j BenchCmp, calcDelta func(BenchCmp) Delta) bool {
type ByDeltaNsPerOp (line 124) | type ByDeltaNsPerOp
method Len (line 126) | func (x ByDeltaNsPerOp) Len() int { return len(x) }
method Swap (line 127) | func (x ByDeltaNsPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
method Less (line 128) | func (x ByDeltaNsPerOp) Less(i, j int) bool { return lessByDelta(x[i],...
type ByDeltaMBPerS (line 132) | type ByDeltaMBPerS
method Len (line 134) | func (x ByDeltaMBPerS) Len() int { return len(x) }
method Swap (line 135) | func (x ByDeltaMBPerS) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
method Less (line 136) | func (x ByDeltaMBPerS) Less(i, j int) bool { return lessByDelta(x[i], ...
type ByDeltaAllocedBytesPerOp (line 140) | type ByDeltaAllocedBytesPerOp
method Len (line 142) | func (x ByDeltaAllocedBytesPerOp) Len() int { return len(x) }
method Swap (line 143) | func (x ByDeltaAllocedBytesPerOp) Swap(i, j int) { x[i], x[j] = x[j], ...
method Less (line 144) | func (x ByDeltaAllocedBytesPerOp) Less(i, j int) bool {
type ByDeltaAllocsPerOp (line 150) | type ByDeltaAllocsPerOp
method Len (line 152) | func (x ByDeltaAllocsPerOp) Len() int { return len(x) }
method Swap (line 153) | func (x ByDeltaAllocsPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
method Less (line 154) | func (x ByDeltaAllocsPerOp) Less(i, j int) bool {
FILE: cmd/benchcmp/compare_test.go
function TestDelta (line 16) | func TestDelta(t *testing.T) {
function TestCorrelate (line 53) | func TestCorrelate(t *testing.T) {
function TestBenchCmpSorting (line 111) | func TestBenchCmpSorting(t *testing.T) {
FILE: cmd/bisect/go120.go
function cmdInterrupt (line 13) | func cmdInterrupt(cmd *exec.Cmd) {
FILE: cmd/bisect/main.go
function usage (line 154) | func usage() {
function main (line 160) | func main() {
type Bisect (line 231) | type Bisect struct
method Search (line 308) | func (b *Bisect) Search() bool {
method Fatalf (line 420) | func (b *Bisect) Fatalf(format string, args ...any) {
method Logf (line 430) | func (b *Bisect) Logf(format string, args ...any) {
method search (line 473) | func (b *Bisect) search(r *Result) []string {
method Run (line 564) | func (b *Bisect) Run(suffix string) *Result {
method run (line 576) | func (b *Bisect) run(suffix string) *Result {
type Result (line 290) | type Result struct
function skipHexDigits (line 438) | func skipHexDigits(idY, idN []uint64) int {
function replace (line 707) | func replace(x, pattern, random string) string {
function commonSuffix (line 715) | func commonSuffix(list []uint64) string {
FILE: cmd/bisect/main_test.go
function Test (line 26) | func Test(t *testing.T) {
function eval (line 124) | func eval(rnd *rand.Rand, z constraint.Expr, have map[string]bool) bool {
FILE: cmd/bundle/main.go
function init (line 101) | func init() {
function addImportMap (line 105) | func addImportMap(s string) {
function usage (line 117) | func usage() {
function main (line 122) | func main() {
function isStandardImportPath (line 164) | func isStandardImportPath(path string) bool {
function bundle (line 175) | func bundle(src, dst, dstpkg, prefix, buildTags string) ([]byte, error) {
function sourceRange (line 388) | func sourceRange(decl ast.Decl) (beg, end token.Pos) {
function printComments (line 419) | func printComments(out *bytes.Buffer, comments []*ast.CommentGroup, pos,...
constant infinity (line 430) | infinity = 1 << 30
function printLastComments (line 432) | func printLastComments(out *bytes.Buffer, comments []*ast.CommentGroup, ...
function printSameLineComment (line 436) | func printSameLineComment(out *bytes.Buffer, comments []*ast.CommentGrou...
function quoteArgs (line 449) | func quoteArgs(ss []string) []string {
function containsSpace (line 469) | func containsSpace(s string) bool {
type flagFunc (line 478) | type flagFunc
method Set (line 480) | func (f flagFunc) Set(s string) error {
method String (line 485) | func (f flagFunc) String() string { return "" }
FILE: cmd/bundle/main_test.go
function TestBundle (line 17) | func TestBundle(t *testing.T) { packagestest.TestAll(t, testBundle) }
function testBundle (line 18) | func testBundle(t *testing.T, x packagestest.Exporter) {
function diff (line 62) | func diff(a, b string) string {
FILE: cmd/bundle/testdata/src/domain.name/importdecl/p.go
function F (line 3) | func F() int { return 1 }
FILE: cmd/bundle/testdata/src/initial/a.go
function init (line 6) | func init() { foo() }
type S (line 9) | type S struct
function bar (line 23) | func bar(s *S) {
FILE: cmd/bundle/testdata/src/initial/b.go
type t (line 10) | type t
constant c (line 13) | c = 1
function foo (line 15) | func foo() {
constant z1 (line 21) | z1 = iota
constant z2 (line 22) | z2
FILE: cmd/bundle/testdata/src/initial/c.go
function baz (line 8) | func baz() {
FILE: cmd/callgraph/main.go
constant Usage (line 57) | Usage = `callgraph: display the call graph of a Go program.
function init (line 147) | func init() {
function main (line 156) | func main() {
function doCallgraph (line 166) | func doCallgraph(dir, gopath, algo, format string, tests bool, args []st...
function mainPackages (line 285) | func mainPackages(pkgs []*ssa.Package) ([]*ssa.Package, error) {
type Edge (line 298) | type Edge struct
method pos (line 307) | func (e *Edge) pos() *token.Position {
method Filename (line 314) | func (e *Edge) Filename() string { return e.pos().Filename }
method Column (line 315) | func (e *Edge) Column() int { return e.pos().Column }
method Line (line 316) | func (e *Edge) Line() int { return e.pos().Line }
method Offset (line 317) | func (e *Edge) Offset() int { return e.pos().Offset }
method Dynamic (line 319) | func (e *Edge) Dynamic() string {
method Description (line 326) | func (e *Edge) Description() string { return e.edge.Description() }
FILE: cmd/callgraph/main_test.go
function init (line 23) | func init() {
function TestCallgraph (line 35) | func TestCallgraph(t *testing.T) {
FILE: cmd/callgraph/testdata/src/pkg/pkg.go
type I (line 3) | type I interface
type C (line 7) | type C
method f (line 9) | func (C) f() {}
type D (line 11) | type D
method f (line 13) | func (D) f() {}
function main (line 15) | func main() {
function main2 (line 22) | func main2() {
FILE: cmd/callgraph/testdata/src/pkg/pkg_test.go
function Example (line 6) | func Example() {
FILE: cmd/compilebench/main.go
type test (line 124) | type test struct
type runner (line 129) | type runner interface
function usage (line 153) | func usage() {
function main (line 160) | func main() {
function toolPath (line 234) | func toolPath(names ...string) (found, path string) {
type Pkg (line 250) | type Pkg struct
function goList (line 257) | func goList(dir string) (*Pkg, error) {
function runCmd (line 269) | func runCmd(name string, cmd *exec.Cmd) error {
type goBuild (line 279) | type goBuild struct
method long (line 281) | func (goBuild) long() bool { return true }
method run (line 283) | func (r goBuild) run(name string, count int) error {
type size (line 294) | type size struct
method long (line 300) | func (r size) long() bool { return r.isLong }
method run (line 302) | func (r size) run(name string, count int) error {
type compile (line 335) | type compile struct
method long (line 337) | func (compile) long() bool { return false }
method run (line 339) | func (c compile) run(name string, count int) error {
type link (line 409) | type link struct
method long (line 411) | func (link) long() bool { return false }
method run (line 413) | func (r link) run(name string, count int) error {
function runBuildCmd (line 479) | func runBuildCmd(name string, count int, dir, tool string, args []string...
function checkCompilingRuntimeFlag (line 579) | func checkCompilingRuntimeFlag(assembler string) error {
function genSymAbisFile (line 623) | func genSymAbisFile(pkg *Pkg, symAbisFile, incdir string) error {
function genImportcfgFile (line 652) | func genImportcfgFile(dir string, flags string, full bool) (string, erro...
FILE: cmd/deadcode/deadcode.go
function usage (line 55) | func usage() {
function main (line 66) | func main() {
function prettyName (line 388) | func prettyName(fn *ssa.Function, qualified bool) string {
function printObjects (line 423) | func printObjects(format string, objects []any) {
function pathSearch (line 449) | func pathSearch(roots []*ssa.Function, res *rta.Result, targets map[*ssa...
function isStaticCall (line 538) | func isStaticCall(edge *callgraph.Edge) bool {
function toJSONPosition (line 544) | func toJSONPosition(posn token.Position) jsonPosition {
function cond (line 554) | func cond[T any](cond bool, t, f T) T {
function isMarkerMethod (line 565) | func isMarkerMethod(fn *ssa.Function, interfaceTypes []*types.Interface)...
type jsonFunction (line 590) | type jsonFunction struct
method String (line 597) | func (f jsonFunction) String() string { return f.Name }
type jsonPackage (line 599) | type jsonPackage struct
method String (line 605) | func (p jsonPackage) String() string { return p.Path }
type jsonEdge (line 608) | type jsonEdge struct
type jsonPosition (line 615) | type jsonPosition struct
method String (line 620) | func (p jsonPosition) String() string {
FILE: cmd/deadcode/deadcode_test.go
function Test (line 24) | func Test(t *testing.T) {
function buildDeadcode (line 147) | func buildDeadcode(t *testing.T) string {
function words (line 161) | func words(s string) ([]string, error) {
FILE: cmd/digraph/digraph.go
function usage (line 29) | func usage() {
function main (line 42) | func main() {
type nodelist (line 57) | type nodelist
method println (line 59) | func (l nodelist) println(sep string) {
type nodeset (line 69) | type nodeset
method sort (line 73) | func (s nodeset) sort() nodelist {
method addAll (line 84) | func (s nodeset) addAll(x nodeset) {
function singleton (line 71) | func singleton(x string) nodeset { return nodeset{x: true} }
type graph (line 91) | type graph
method addNode (line 93) | func (g graph) addNode(node string) nodeset {
method addEdges (line 102) | func (g graph) addEdges(from string, to ...string) {
method nodelist (line 110) | func (g graph) nodelist() nodelist {
method reachableFrom (line 118) | func (g graph) reachableFrom(roots nodeset) nodeset {
method transpose (line 135) | func (g graph) transpose() graph {
method sccs (line 146) | func (g graph) sccs() []nodeset {
method allpaths (line 196) | func (g graph) allpaths(from, to string) error {
method somepath (line 228) | func (g graph) somepath(from, to string) error {
method toDot (line 269) | func (g graph) toDot(w *bytes.Buffer) {
function parse (line 283) | func parse(rd io.Reader) (graph, error) {
function digraph (line 318) | func digraph(cmd string, args []string) error {
function split (line 509) | func split(line string) ([]string, error) {
function quotedLength (line 565) | func quotedLength(input string) (n int, ok bool) {
FILE: cmd/digraph/digraph_test.go
function TestDigraph (line 16) | func TestDigraph(t *testing.T) {
function TestAllpaths (line 71) | func TestAllpaths(t *testing.T) {
function TestSomepath (line 202) | func TestSomepath(t *testing.T) {
function TestSplit (line 267) | func TestSplit(t *testing.T) {
function TestQuotedLength (line 285) | func TestQuotedLength(t *testing.T) {
function TestFocus (line 325) | func TestFocus(t *testing.T) {
function TestToDot (line 386) | func TestToDot(t *testing.T) {
FILE: cmd/eg/eg.go
constant usage (line 37) | usage = `eg: an example-based refactoring tool.
function main (line 51) | func main() {
function doMain (line 58) | func doMain() error {
type pkgsImporter (line 180) | type pkgsImporter
method Import (line 182) | func (p pkgsImporter) Import(path string) (tpkg *types.Package, err er...
FILE: cmd/file2fuzz/main.go
function encodeByteSlice (line 36) | func encodeByteSlice(b []byte) []byte {
function usage (line 40) | func usage() {
function dirWriter (line 46) | func dirWriter(dir string) func([]byte) error {
function convert (line 61) | func convert(inputArgs []string, outputArg string) error {
function main (line 119) | func main() {
FILE: cmd/file2fuzz/main_test.go
function TestMain (line 18) | func TestMain(m *testing.M) {
function file2fuzz (line 33) | func file2fuzz(t *testing.T, dir string, args []string, stdin string) (s...
function TestFile2Fuzz (line 56) | func TestFile2Fuzz(t *testing.T) {
FILE: cmd/fiximports/main.go
constant usage (line 104) | usage = `fiximports: rewrite import paths to use canonical package names.
function main (line 120) | func main() {
type canonicalName (line 132) | type canonicalName struct
function fiximports (line 136) | func fiximports(packages ...string) bool {
function rewritePackage (line 351) | func rewritePackage(client *listPackage, canonical map[string]canonicalN...
function rewriteFile (line 394) | func rewriteFile(filename string, canonical map[string]canonicalName, us...
type listPackage (line 453) | type listPackage struct
type packageError (line 468) | type packageError struct
method Error (line 474) | func (e packageError) Error() string {
function list (line 483) | func list(args ...string) ([]*listPackage, error) {
function shortPath (line 520) | func shortPath(path string) string {
FILE: cmd/fiximports/main_test.go
function init (line 40) | func init() {
function TestFixImports (line 56) | func TestFixImports(t *testing.T) {
function TestDryRun (line 249) | func TestDryRun(t *testing.T) {
FILE: cmd/go-contrib-init/contrib.go
function main (line 30) | func main() {
function detectrepo (line 44) | func detectrepo() string {
function checkCLA (line 67) | func checkCLA() {
function expandUser (line 84) | func expandUser(s string) string {
function cookiesFile (line 111) | func cookiesFile() string {
function checkGoroot (line 125) | func checkGoroot() {
function checkWorkingDir (line 148) | func checkWorkingDir() {
function inGoPath (line 165) | func inGoPath(wd string) bool {
function checkGitOrigin (line 180) | func checkGitOrigin() {
function cmdErr (line 211) | func cmdErr(err error) string {
function checkGitCodeReview (line 218) | func checkGitCodeReview() {
FILE: cmd/go-contrib-init/contrib_test.go
function TestExpandUser (line 15) | func TestExpandUser(t *testing.T) {
function TestCmdErr (line 43) | func TestCmdErr(t *testing.T) {
FILE: cmd/godex/gc.go
function init (line 14) | func init() {
FILE: cmd/godex/gccgo.go
function init (line 15) | func init() {
method printGccgoExtra (line 20) | func (p *printer) printGccgoExtra(pkg *types.Package) {
FILE: cmd/godex/godex.go
function usage (line 30) | func usage() {
function report (line 36) | func report(msg string) {
function main (line 41) | func main() {
function logf (line 87) | func logf(format string, args ...any) {
function splitPathIdent (line 95) | func splitPathIdent(arg string) (path, name string) {
function tryPrefixes (line 111) | func tryPrefixes(prefixes chan string, path string, imp types.Importer) ...
type tryImporters (line 134) | type tryImporters struct
method Import (line 136) | func (t *tryImporters) Import(path string) (pkg *types.Package, err er...
type protector (line 148) | type protector struct
method Import (line 152) | func (p *protector) Import(path string) (pkg *types.Package, err error) {
function protect (line 163) | func protect(imp types.Importer) types.Importer {
function register (line 168) | func register(src string, imp types.Importer) {
function lookup (line 177) | func lookup(src string) types.Importer {
function genPrefixes (line 186) | func genPrefixes(out chan string, all bool) {
function walkDir (line 198) | func walkDir(dirname, prefix string, out chan string) {
FILE: cmd/godex/isAlias18.go
function isAlias (line 11) | func isAlias(obj *types.TypeName) bool {
FILE: cmd/godex/isAlias19.go
function isAlias (line 11) | func isAlias(obj *types.TypeName) bool {
FILE: cmd/godex/print.go
function print (line 19) | func print(w io.Writer, pkg *types.Package, filter func(types.Object) bo...
type printer (line 27) | type printer struct
method print (line 34) | func (p *printer) print(s string) {
method printf (line 51) | func (p *printer) printf(format string, args ...any) {
method printPackage (line 76) | func (p *printer) printPackage(pkg *types.Package, filter func(types.O...
method printDecl (line 198) | func (p *printer) printDecl(keyword string, n int, printGroup func()) {
method printObj (line 317) | func (p *printer) printObj(obj types.Object) {
method printFunc (line 335) | func (p *printer) printFunc(recvType types.Type, obj *types.Func) {
function methodsFor (line 58) | func methodsFor(obj *types.TypeName) (*types.Named, []*types.Selection) {
function absInt (line 216) | func absInt(v constant.Value) *big.Int {
function floatString (line 232) | func floatString(v constant.Value) string {
function valString (line 290) | func valString(v constant.Value, floatFmt bool) string {
function combinedMethodSet (line 355) | func combinedMethodSet(T *types.Named) []*types.Selection {
FILE: cmd/godex/source.go
function init (line 11) | func init() {
type sourceImporter (line 15) | type sourceImporter struct
method Import (line 17) | func (sourceImporter) Import(path string) (*types.Package, error) {
FILE: cmd/godex/writetype.go
method writeType (line 20) | func (p *printer) writeType(this *types.Package, typ types.Type) {
constant GcCompatibilityMode (line 25) | GcCompatibilityMode = false
method writeTypeInternal (line 27) | func (p *printer) writeTypeInternal(this *types.Package, typ types.Type,...
method writeTuple (line 203) | func (p *printer) writeTuple(this *types.Package, tup *types.Tuple, vari...
method writeSignature (line 224) | func (p *printer) writeSignature(this *types.Package, sig *types.Signatu...
method writeSignatureInternal (line 228) | func (p *printer) writeSignatureInternal(this *types.Package, sig *types...
FILE: cmd/goimports/goimports.go
function init (line 53) | func init() {
function report (line 59) | func report(err error) {
function usage (line 64) | func usage() {
function isGoFile (line 70) | func isGoFile(f os.FileInfo) bool {
type argumentType (line 77) | type argumentType
constant fromStdin (line 81) | fromStdin argumentType = iota
constant singleArg (line 85) | singleArg
constant multipleArg (line 89) | multipleArg
function processFile (line 92) | func processFile(filename string, in io.Reader, out io.Writer, argType a...
function visitFile (line 187) | func visitFile(path string, f os.FileInfo, err error) error {
function walkDir (line 197) | func walkDir(path string) {
function main (line 201) | func main() {
function bufferedFileWriter (line 223) | func bufferedFileWriter(dest string) (w io.Writer, close func()) {
function gofmtMain (line 239) | func gofmtMain() {
function writeTempFile (line 301) | func writeTempFile(dir, prefix string, data []byte) (string, error) {
function diff (line 317) | func diff(b1, b2 []byte, filename string) (data []byte, err error) {
function replaceTempFilename (line 353) | func replaceTempFilename(diff []byte, filename string) ([]byte, error) {
function isFile (line 374) | func isFile(name string) bool {
function isDir (line 380) | func isDir(name string) bool {
FILE: cmd/goimports/goimports_gc.go
function doTrace (line 16) | func doTrace() func() {
FILE: cmd/goimports/goimports_not_gc.go
function doTrace (line 9) | func doTrace() func() {
FILE: cmd/gomvpkg/main.go
function init (line 26) | func init() {
constant Usage (line 30) | Usage = `gomvpkg: moves a package, updating import declarations
function main (line 77) | func main() {
FILE: cmd/gonew/main.go
function usage (line 56) | func usage() {
function main (line 62) | func main() {
function fixGo (line 168) | func fixGo(data []byte, file string, srcMod, dstMod string, isRoot bool)...
function fixGoMod (line 222) | func fixGoMod(data []byte, dstMod string) []byte {
FILE: cmd/gonew/main_test.go
function init (line 24) | func init() {
function Test (line 31) | func Test(t *testing.T) {
type Zip (line 158) | type Zip struct
function writeProxyFiles (line 166) | func writeProxyFiles(t *testing.T, proxy string, ar *txtar.Archive) {
FILE: cmd/gotype/gotype.go
function initParserMode (line 128) | func initParserMode() {
constant usageString (line 144) | usageString = `usage: gotype [flags] [path ...]
function usage (line 171) | func usage() {
function report (line 178) | func report(err error) {
function parse (line 188) | func parse(filename string, src any) (*ast.File, error) {
function parseStdin (line 199) | func parseStdin() (*ast.File, error) {
function parseFiles (line 207) | func parseFiles(dir string, filenames []string) ([]*ast.File, error) {
function parseDir (line 234) | func parseDir(dir string) ([]*ast.File, error) {
function getPkgFiles (line 252) | func getPkgFiles(args []string) ([]*ast.File, error) {
function checkPkgFiles (line 278) | func checkPkgFiles(files []*ast.File) {
function printStats (line 308) | func printStats(d time.Duration) {
function main (line 323) | func main() {
FILE: cmd/gotype/sizesFor18.go
constant defaultCompiler (line 14) | defaultCompiler = "gc"
function SizesFor (line 31) | func SizesFor(compiler, arch string) types.Sizes {
FILE: cmd/gotype/sizesFor19.go
constant defaultCompiler (line 11) | defaultCompiler = "source"
function SizesFor (line 13) | func SizesFor(compiler, arch string) types.Sizes {
FILE: cmd/goyacc/yacc.go
constant ACTSIZE (line 64) | ACTSIZE = 240000
constant NSTATES (line 65) | NSTATES = 16000
constant TEMPSIZE (line 66) | TEMPSIZE = 16000
constant SYMINC (line 68) | SYMINC = 50
constant RULEINC (line 69) | RULEINC = 50
constant PRODINC (line 70) | PRODINC = 100
constant WSETINC (line 71) | WSETINC = 50
constant STATEINC (line 72) | STATEINC = 200
constant PRIVATE (line 74) | PRIVATE = 0xE000
constant NTBASE (line 81) | NTBASE = 010000
constant ERRCODE (line 82) | ERRCODE = 8190
constant ACCEPTCODE (line 83) | ACCEPTCODE = 8191
constant YYLEXUNK (line 84) | YYLEXUNK = 3
constant TOKSTART (line 85) | TOKSTART = 4
constant NOASC (line 90) | NOASC = iota
constant LASC (line 91) | LASC
constant RASC (line 92) | RASC
constant BASC (line 93) | BASC
constant DONE (line 98) | DONE = iota
constant MUSTDO (line 99) | MUSTDO
constant MUSTLOOKAHEAD (line 100) | MUSTLOOKAHEAD
constant ACTFLAG (line 105) | ACTFLAG = 1 << (iota + 2)
constant REDFLAG (line 106) | REDFLAG
constant yyFlag (line 110) | yyFlag = -1000
constant IDENTIFIER (line 114) | IDENTIFIER = PRIVATE + iota
constant MARK (line 115) | MARK
constant TERM (line 116) | TERM
constant LEFT (line 117) | LEFT
constant RIGHT (line 118) | RIGHT
constant BINARY (line 119) | BINARY
constant PREC (line 120) | PREC
constant LCURLY (line 121) | LCURLY
constant IDENTCOLON (line 122) | IDENTCOLON
constant NUMBER (line 123) | NUMBER
constant START (line 124) | START
constant TYPEDEF (line 125) | TYPEDEF
constant TYPENAME (line 126) | TYPENAME
constant UNION (line 127) | UNION
constant ERROR (line 128) | ERROR
constant ENDFILE (line 131) | ENDFILE = 0
constant EMPTY (line 132) | EMPTY = 1
constant WHOKNOWS (line 133) | WHOKNOWS = 0
constant OK (line 134) | OK = 1
constant NOMORE (line 135) | NOMORE = -1000
function ASSOC (line 138) | func ASSOC(i int) int { return i & 3 }
function PLEVEL (line 140) | func PLEVEL(i int) int { return (i >> 4) & 077 }
function TYPE (line 142) | func TYPE(i int) int { return (i >> 10) & 077 }
function SETASC (line 145) | func SETASC(i, j int) int { return i | j }
function SETPLEV (line 147) | func SETPLEV(i, j int) int { return i | (j << 4) }
function SETTYPE (line 149) | func SETTYPE(i, j int) int { return i | (j << 10) }
function init (line 165) | func init() {
type Lkset (line 181) | type Lkset
type Pitem (line 183) | type Pitem struct
type Item (line 190) | type Item struct
type Symb (line 195) | type Symb struct
type Wset (line 201) | type Wset struct
type Resrv (line 308) | type Resrv struct
type Error (line 328) | type Error struct
type Row (line 336) | type Row struct
constant EOF (line 345) | EOF = -1
function main (line 347) | func main() {
function setup (line 373) | func setup() {
function moreprod (line 746) | func moreprod() {
function defin (line 766) | func defin(nt int, s string) int {
function gettok (line 825) | func gettok() int {
function getword (line 997) | func getword(c rune) {
function fdtype (line 1007) | func fdtype(t int) int {
function chfind (line 1024) | func chfind(t int, s string) int {
function cpyunion (line 1047) | func cpyunion() {
function cpycode (line 1083) | func cpycode() {
function emitcode (line 1118) | func emitcode(code []rune, lineno int) {
function isPackageClause (line 1132) | func isPackageClause(line []rune) bool {
function skipspace (line 1174) | func skipspace(line []rune) []rune {
function lines (line 1185) | func lines(code []rune) [][]rune {
function writecode (line 1202) | func writecode(code []rune) {
function skipcom (line 1210) | func skipcom() int {
function cpyact (line 1250) | func cpyact(curprod []int, max int) {
function openup (line 1441) | func openup() {
function symnam (line 1468) | func symnam(i int) string {
function aryfil (line 1480) | func aryfil(v []int, n, c int) {
function cpres (line 1489) | func cpres() {
function cempty (line 1528) | func cempty() {
function cpfir (line 1611) | func cpfir() {
function stagen (line 1677) | func stagen() {
function closure (line 1767) | func closure(i int) {
function state (line 1897) | func state(c int) int {
function putitem (line 1986) | func putitem(p Pitem, set Lkset) {
function writem (line 2010) | func writem(pp Pitem) string {
function apack (line 2046) | func apack(p []int, n int) int {
function output (line 2111) | func output() {
function precftn (line 2203) | func precftn(r, t, s int) {
function addActions (line 2235) | func addActions(act []int, i int) []int {
function wrstate (line 2324) | func wrstate(i int) {
function go2out (line 2394) | func go2out() {
function go2gen (line 2457) | func go2gen(c int) {
function hideprod (line 2512) | func hideprod() {
function callopt (line 2531) | func callopt() {
function nxti (line 2626) | func nxti() int {
function gin (line 2647) | func gin(i int) {
function stin (line 2693) | func stin(i int) {
function aoutput (line 2764) | func aoutput() {
function others (line 2773) | func others() {
function runMachine (line 2895) | func runMachine(tokens []string) (state, token int) {
function minMax (line 2948) | func minMax(v []int) (min, max int) {
function minType (line 2966) | func minType(v []int, allowUnsigned bool) (typ string) {
function arrayOutColumns (line 2987) | func arrayOutColumns(s string, v []int, columns int, allowUnsigned bool) {
function arout (line 3003) | func arout(s string, v []int, n int) {
function summary (line 3008) | func summary() {
function osummary (line 3036) | func osummary() {
function chcopy (line 3053) | func chcopy(q string) string {
function usage (line 3068) | func usage() {
function bitset (line 3073) | func bitset(set Lkset, bit int) int { return set[bit>>5] & (1 << uint(bi...
function setbit (line 3075) | func setbit(set Lkset, bit int) { set[bit>>5] |= (1 << uint(bit&31)) }
function mkset (line 3077) | func mkset() Lkset { return make([]int, tbitset) }
function setunion (line 3081) | func setunion(a, b []int) int {
function prlook (line 3094) | func prlook(p Lkset) {
function isdigit (line 3111) | func isdigit(c rune) bool { return c >= '0' && c <= '9' }
function isword (line 3113) | func isword(c rune) bool {
function aryeq (line 3119) | func aryeq(a []int, b []int) int {
function getrune (line 3132) | func getrune(f *bufio.Reader) rune {
function ungetrune (line 3155) | func ungetrune(f *bufio.Reader, c rune) {
function open (line 3165) | func open(s string) *bufio.Reader {
function create (line 3174) | func create(s string) *bufio.Writer {
function lerrorf (line 3184) | func lerrorf(lineno int, s string, v ...any) {
function errorf (line 3194) | func errorf(s string, v ...any) {
function exit (line 3198) | func exit(status int) {
function gofmt (line 3215) | func gofmt() {
FILE: cmd/html2article/conv.go
function main (line 26) | func main() {
function convert (line 35) | func convert(w io.Writer, r io.Reader) error {
type Style (line 55) | type Style
constant Bold (line 58) | Bold Style = "*"
constant Italic (line 59) | Italic Style = "_"
constant Code (line 60) | Code Style = "`"
function parseStyles (line 65) | func parseStyles(style *html.Node) error {
function limitNewlineRuns (line 107) | func limitNewlineRuns(s string) string {
function makeHeadings (line 111) | func makeHeadings(body string) string {
function isBoldTitle (line 128) | func isBoldTitle(s string) bool {
function indent (line 134) | func indent(buf *bytes.Buffer, s string) {
function unwrap (line 144) | func unwrap(buf *bytes.Buffer, s string) {
function text (line 164) | func text(n *html.Node) string {
function childText (line 249) | func childText(node *html.Node) string {
function highlight (line 257) | func highlight(node *html.Node, char string) string {
type selector (line 262) | type selector
function isTag (line 264) | func isTag(a atom.Atom) selector {
function hasClass (line 270) | func hasClass(name string) selector {
function hasStyle (line 283) | func hasStyle(s Style) selector {
function attr (line 300) | func attr(node *html.Node, key string) (value string) {
function find (line 309) | func find(n *html.Node, fn selector) *html.Node {
function walk (line 324) | func walk(n *html.Node, fn selector) {
FILE: cmd/present/dir.go
function init (line 22) | func init() {
function dirHandler (line 27) | func dirHandler(w http.ResponseWriter, r *http.Request) {
function isDoc (line 55) | func isDoc(path string) bool {
function initTemplates (line 69) | func initTemplates(fsys fs.FS) error {
function renderDoc (line 97) | func renderDoc(w io.Writer, docFile string) error {
function parse (line 111) | func parse(name string, mode present.ParseMode) (*present.Doc, error) {
function dirList (line 125) | func dirList(w io.Writer, name string) (isDir bool, err error) {
function showFile (line 186) | func showFile(n string) bool {
function showDir (line 198) | func showDir(n string) bool {
type dirListData (line 205) | type dirListData struct
type dirEntry (line 210) | type dirEntry struct
type dirEntrySlice (line 214) | type dirEntrySlice
method Len (line 216) | func (s dirEntrySlice) Len() int { return len(s) }
method Swap (line 217) | func (s dirEntrySlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
method Less (line 218) | func (s dirEntrySlice) Less(i, j int) bool { return s[i].Name < s[j].N...
FILE: cmd/present/main.go
function main (line 33) | func main() {
constant localhostWarning (line 112) | localhostWarning = `
FILE: cmd/present/play.go
function playScript (line 31) | func playScript(fsys fs.FS, transport string) {
function initPlayground (line 49) | func initPlayground(fsys fs.FS, origin *url.URL) {
function playable (line 62) | func playable(c present.Code) bool {
FILE: cmd/present/static/dir.js
function bindEvent (line 7) | function bindEvent(el, e, fn) {
function godocs_bindSearchEvents (line 15) | function godocs_bindSearchEvents() {
FILE: cmd/present/static/jquery-ui.js
function i (line 6) | function i(t,i){var a,n,r,o=t.nodeName.toLowerCase();return"area"===o?(a...
function s (line 6) | function s(t){return e.expr.filters.visible(t)&&!e(t).parents().addBack(...
function a (line 6) | function a(t,i,s,a){return e.each(n,function(){i-=parseFloat(e.css(t,"pa...
function h (line 6) | function h(){return i||r.options.disabled!==!0&&!e(this).hasClass("ui-st...
function i (line 6) | function i(){return("string"==typeof e?s[e]:e).apply(s,arguments)}
function t (line 6) | function t(e){return parseInt(e,10)||0}
function i (line 6) | function i(e){return!isNaN(parseInt(e,10))}
FILE: cmd/present/static/jquery.js
function G (line 2) | function G(a){var b=F[a]={};return p.each(a.split(s),function(a,c){b[c]=...
function J (line 2) | function J(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(I,"-...
function K (line 2) | function K(a){var b;for(b in a){if(b==="data"&&p.isEmptyObject(a[b]))con...
function ba (line 2) | function ba(){return!1}
function bb (line 2) | function bb(){return!0}
function bh (line 2) | function bh(a){return!a||!a.parentNode||a.parentNode.nodeType===11}
function bi (line 2) | function bi(a,b){do a=a[b];while(a&&a.nodeType!==1);return a}
function bj (line 2) | function bj(a,b,c){b=b||0;if(p.isFunction(b))return p.grep(a,function(a,...
function bk (line 2) | function bk(a){var b=bl.split("|"),c=a.createDocumentFragment();if(c.cre...
function bC (line 2) | function bC(a,b){return a.getElementsByTagName(b)[0]||a.appendChild(a.ow...
function bD (line 2) | function bD(a,b){if(b.nodeType!==1||!p.hasData(a))return;var c,d,e,f=p._...
function bE (line 2) | function bE(a,b){var c;if(b.nodeType!==1)return;b.clearAttributes&&b.cle...
function bF (line 2) | function bF(a){return typeof a.getElementsByTagName!="undefined"?a.getEl...
function bG (line 2) | function bG(a){bv.test(a.type)&&(a.defaultChecked=a.checked)}
function bY (line 2) | function bY(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.sl...
function bZ (line 2) | function bZ(a,b){return a=b||a,p.css(a,"display")==="none"||!p.contains(...
function b$ (line 2) | function b$(a,b){var c,d,e=[],f=0,g=a.length;for(;f<g;f++){c=a[f];if(!c....
function b_ (line 2) | function b_(a,b,c){var d=bP.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[...
function ca (line 2) | function ca(a,b,c,d){var e=c===(d?"border":"content")?4:b==="width"?1:0,...
function cb (line 2) | function cb(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=!0,f...
function cc (line 2) | function cc(a){if(bS[a])return bS[a];var b=p("<"+a+">").appendTo(e.body)...
function ci (line 2) | function ci(a,b,c,d){var e;if(p.isArray(b))p.each(b,function(b,e){c||ce....
function cz (line 2) | function cz(a){return function(b,c){typeof b!="string"&&(c=b,b="*");var ...
function cA (line 2) | function cA(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h,i=a[f...
function cB (line 2) | function cB(a,c){var d,e,f=p.ajaxSettings.flatOptions||{};for(d in c)c[d...
function cC (line 2) | function cC(a,c,d){var e,f,g,h,i=a.contents,j=a.dataTypes,k=a.responseFi...
function cD (line 2) | function cD(a,b){var c,d,e,f,g=a.dataTypes.slice(),h=g[0],i={},j=0;a.dat...
function cL (line 2) | function cL(){try{return new a.XMLHttpRequest}catch(b){}}
function cM (line 2) | function cM(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(...
function cU (line 2) | function cU(){return setTimeout(function(){cN=b},0),cN=p.now()}
function cV (line 2) | function cV(a,b){p.each(b,function(b,c){var d=(cT[b]||[]).concat(cT["*"]...
function cW (line 2) | function cW(a,b,c){var d,e=0,f=0,g=cS.length,h=p.Deferred().always(funct...
function cX (line 2) | function cX(a,b){var c,d,e,f,g;for(c in a){d=p.camelCase(c),e=b[d],f=a[c...
function cY (line 2) | function cY(a,b,c){var d,e,f,g,h,i,j,k,l=this,m=a.style,n={},o=[],q=a.no...
function cZ (line 2) | function cZ(a,b,c,d,e){return new cZ.prototype.init(a,b,c,d,e)}
function c$ (line 2) | function c$(a,b){var c,d={height:a},e=0;b=b?1:0;for(;e<4;e+=2-b)c=bV[e],...
function da (line 2) | function da(a){return p.isWindow(a)?a:a.nodeType===9?a.defaultView||a.pa...
function bc (line 2) | function bc(a,b,c,d){c=c||[],b=b||r;var e,f,i,j,k=b.nodeType;if(!a||type...
function bd (line 2) | function bd(a){return function(b){var c=b.nodeName.toLowerCase();return ...
function be (line 2) | function be(a){return function(b){var c=b.nodeName.toLowerCase();return(...
function bf (line 2) | function bf(a){return z(function(b){return b=+b,z(function(c,d){var e,f=...
function bg (line 2) | function bg(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d==...
function bh (line 2) | function bh(a,b){var c,d,f,g,h,i,j,k=C[o][a];if(k)return b?0:k.slice(0);...
function bi (line 2) | function bi(a,b,d){var e=b.dir,f=d&&b.dir==="parentNode",g=u++;return b....
function bj (line 2) | function bj(a){return a.length>1?function(b,c,d){var e=a.length;while(e-...
function bk (line 2) | function bk(a,b,c,d,e){var f,g=[],h=0,i=a.length,j=b!=null;for(;h<i;h++)...
function bl (line 2) | function bl(a,b,c,d,e,f){return d&&!d[o]&&(d=bl(d)),e&&!e[o]&&(e=bl(e,f)...
function bm (line 2) | function bm(a){var b,c,d,f=a.length,g=e.relative[a[0].type],h=g||e.relat...
function bn (line 2) | function bn(a,b){var d=b.length>0,f=a.length>0,g=function(h,i,j,k,m){var...
function bo (line 2) | function bo(a,b,c,d){var e=0,f=b.length;for(;e<f;e++)bc(a,b[e],c,d);retu...
function bp (line 2) | function bp(a,b,c,d,f){var g,h,j,k,l,m=bh(a),n=m.length;if(!d&&m.length=...
function bq (line 2) | function bq(){}
function a (line 2) | function a(b,c){return new a.fn.init(b,c)}
function y (line 2) | function y(a,c,f,i){var k,s,t,u,w,y=c;if(v===2)return;v=2,h&&clearTimeou...
FILE: cmd/present/static/notes.js
function toggleNotesWindow (line 18) | function toggleNotesWindow() {
function destSlideKey (line 31) | function destSlideKey() {
function initNotes (line 42) | function initNotes() {
function formatNotes (line 96) | function formatNotes(notes) {
function updateNotes (line 106) | function updateNotes() {
function updatePlay (line 131) | function updatePlay(e) {
function updatePlayStorage (line 157) | function updatePlayStorage(action, index, e) {
FILE: cmd/present/static/play.js
function initPlayground (line 5) | function initPlayground(transport) {
FILE: cmd/present/static/playground.js
function HTTPTransport (line 46) | function HTTPTransport(enableVet) {
function SocketTransport (line 209) | function SocketTransport() {
function PlaygroundOutput (line 256) | function PlaygroundOutput(el) {
function lineHighlight (line 305) | function lineHighlight(error) {
function highlightOutput (line 315) | function highlightOutput(wrappedOutput) {
function lineClear (line 321) | function lineClear() {
function playground (line 339) | function playground(opts) {
FILE: cmd/present/static/slides.js
function hideHelpText (line 137) | function hideHelpText() {
function getSlideEl (line 141) | function getSlideEl(no) {
function updateSlideClass (line 149) | function updateSlideClass(slideNo, className) {
function updateSlides (line 167) | function updateSlides() {
function prevSlide (line 207) | function prevSlide() {
function nextSlide (line 218) | function nextSlide() {
function triggerEnterEvent (line 231) | function triggerEnterEvent(no) {
function triggerLeaveEvent (line 249) | function triggerLeaveEvent(no) {
function handleTouchStart (line 269) | function handleTouchStart(event) {
function handleTouchMove (line 282) | function handleTouchMove(event) {
function handleTouchEnd (line 292) | function handleTouchEnd(event) {
function cancelTouch (line 307) | function cancelTouch() {
function disableSlideFrames (line 314) | function disableSlideFrames(no) {
function enableSlideFrames (line 326) | function enableSlideFrames(no) {
function disableFrame (line 338) | function disableFrame(frame) {
function enableFrame (line 342) | function enableFrame(frame) {
function setupFrames (line 350) | function setupFrames() {
function setupInteraction (line 362) | function setupInteraction() {
function getCurSlideFromHash (line 384) | function getCurSlideFromHash() {
function updateHash (line 394) | function updateHash() {
function handleBodyKeyDown (line 400) | function handleBodyKeyDown(event) {
function scaleSmallViewports (line 444) | function scaleSmallViewports() {
function addEventListeners (line 460) | function addEventListeners() {
function addFontStyle (line 489) | function addFontStyle() {
function addGeneralStyle (line 500) | function addGeneralStyle() {
function handleDomLoaded (line 520) | function handleDomLoaded() {
function initialize (line 546) | function initialize() {
function setupNotesSync (line 586) | function setupNotesSync() {
function updateOtherWindow (line 620) | function updateOtherWindow(e) {
FILE: cmd/present2md/main.go
function usage (line 38) | func usage() {
function main (line 48) | func main() {
function convert (line 85) | func convert(r io.Reader, file string, writeBack bool) error {
function printSectionBody (line 189) | func printSectionBody(file string, depth int, w *bytes.Buffer, elems []p...
function markdownEscape (line 254) | func markdownEscape(s string) string {
function printStyled (line 285) | func printStyled(w *bytes.Buffer, text string) {
function font (line 290) | func font(s string) string {
function split (line 383) | func split(s string) []string {
function parseInlineLink (line 429) | func parseInlineLink(s string) (link string, length int) {
function renderLink (line 465) | func renderLink(href, text string) string {
FILE: cmd/signature-fuzzer/fuzz-driver/driver.go
function verb (line 62) | func verb(vlevel int, s string, a ...any) {
function usage (line 69) | func usage(msg string) {
function setupTunables (line 84) | func setupTunables() {
function main (line 110) | func main() {
FILE: cmd/signature-fuzzer/fuzz-driver/drv_test.go
function buildDriver (line 18) | func buildDriver(t *testing.T) string {
function TestEndToEndIntegration (line 40) | func TestEndToEndIntegration(t *testing.T) {
FILE: cmd/signature-fuzzer/fuzz-runner/rnr_test.go
function canRace (line 19) | func canRace() bool {
function buildRunner (line 25) | func buildRunner(t *testing.T) string {
function TestRunner (line 43) | func TestRunner(t *testing.T) {
function testBasic (line 57) | func testBasic(t *testing.T, binaryPath string) {
function testRace (line 68) | func testRace(t *testing.T, binaryPath string) {
function testMinimization1 (line 86) | func testMinimization1(t *testing.T, binaryPath string) {
function testMinimization2 (line 117) | func testMinimization2(t *testing.T, binaryPath string) {
FILE: cmd/signature-fuzzer/fuzz-runner/runner.go
constant pkName (line 27) | pkName = "fzTest"
function verb (line 46) | func verb(vlevel int, s string, a ...any) {
function warn (line 53) | func warn(s string, a ...any) {
function fatal (line 58) | func fatal(s string, a ...any) {
type config (line 64) | type config struct
method gen (line 142) | func (c *config) gen(singlepk int, singlefn int) {
method action (line 195) | func (c *config) action(cmd []string, outfile string, emitout bool) int {
method build (line 218) | func (c *config) build(emitout bool) int {
method run (line 236) | func (c *config) run(emitout bool) int {
method minimize (line 255) | func (c *config) minimize(mode minimizeMode) int {
method cleanTemp (line 345) | func (c *config) cleanTemp() {
method perform (line 361) | func (c *config) perform() int {
function usage (line 74) | func usage(msg string) {
function docmd (line 92) | func docmd(cmd []string, dir string) int {
function docmdout (line 111) | func docmdout(cmd []string, dir string, outfile string) int {
function binaryName (line 207) | func binaryName() string {
type minimizeMode (line 244) | type minimizeMode
constant minimizeBuildFailure (line 247) | minimizeBuildFailure = iota
constant minimizeRuntimeFailure (line 248) | minimizeRuntimeFailure
function main (line 398) | func main() {
FILE: cmd/signature-fuzzer/fuzz-runner/testdata/himom.go
function main (line 7) | func main() {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/arrayparm.go
type arrayparm (line 14) | type arrayparm struct
method IsControl (line 26) | func (p arrayparm) IsControl() bool {
method TypeName (line 30) | func (p arrayparm) TypeName() string {
method QualName (line 34) | func (p arrayparm) QualName() string {
method Declare (line 38) | func (p arrayparm) Declare(b *bytes.Buffer, prefix string, suffix stri...
method String (line 46) | func (p arrayparm) String() string {
method GenValue (line 50) | func (p arrayparm) GenValue(s *genstate, f *funcdef, value int, caller...
method GenElemRef (line 70) | func (p arrayparm) GenElemRef(elidx int, path string) (string, parm) {
method NumElements (line 102) | func (p arrayparm) NumElements() int {
method HasPointer (line 106) | func (p arrayparm) HasPointer() bool {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/gen_test.go
function mkGenState (line 18) | func mkGenState() *genstate {
function TestBasic (line 35) | func TestBasic(t *testing.T) {
function TestMoreComplicated (line 55) | func TestMoreComplicated(t *testing.T) {
function TestIsBuildable (line 80) | func TestIsBuildable(t *testing.T) {
function TestExhaustive (line 122) | func TestExhaustive(t *testing.T) {
function TestEmitBadBuildFailure (line 247) | func TestEmitBadBuildFailure(t *testing.T) {
function TestEmitBadRunFailure (line 281) | func TestEmitBadRunFailure(t *testing.T) {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/generator.go
type GenConfig (line 60) | type GenConfig struct
constant CallerName (line 121) | CallerName = "Caller"
constant CheckerName (line 122) | CheckerName = "Checker"
type TunableParams (line 128) | type TunableParams struct
method DisableReflectionCalls (line 359) | func (t *TunableParams) DisableReflectionCalls() {
method DisableRecursiveCalls (line 363) | func (t *TunableParams) DisableRecursiveCalls() {
method DisableMethodCalls (line 367) | func (t *TunableParams) DisableMethodCalls() {
method DisableTakeAddr (line 371) | func (t *TunableParams) DisableTakeAddr() {
method DisableDefer (line 375) | func (t *TunableParams) DisableDefer() {
method LimitInputs (line 379) | func (t *TunableParams) LimitInputs(n int) error {
method LimitOutputs (line 390) | func (t *TunableParams) LimitOutputs(n int) error {
function SetTunables (line 230) | func SetTunables(t TunableParams) {
constant StructTfIdx (line 249) | StructTfIdx = iota
constant ArrayTfIdx (line 250) | ArrayTfIdx
constant MapTfIdx (line 251) | MapTfIdx
constant PointerTfIdx (line 252) | PointerTfIdx
constant NumericTfIdx (line 253) | NumericTfIdx
constant FloatTfIdx (line 254) | FloatTfIdx
constant ComplexTfIdx (line 255) | ComplexTfIdx
constant ByteTfIdx (line 256) | ByteTfIdx
constant StringTfIdx (line 257) | StringTfIdx
function DefaultTunables (line 287) | func DefaultTunables() TunableParams {
function checkTunables (line 291) | func checkTunables(t TunableParams) {
function ParseMaskString (line 406) | func ParseMaskString(arg string, tag string) (map[int]int, error) {
function writeCom (line 440) | func writeCom(b *bytes.Buffer, i int) {
function verb (line 448) | func verb(vlevel int, s string, a ...any) {
type funcdef (line 455) | type funcdef struct
method complexityMeasure (line 1779) | func (f *funcdef) complexityMeasure() int {
type genstate (line 475) | type genstate struct
method intFlavor (line 500) | func (s *genstate) intFlavor() string {
method intBits (line 508) | func (s *genstate) intBits() uint32 {
method floatBits (line 522) | func (s *genstate) floatBits() uint32 {
method genAddrTaken (line 530) | func (s *genstate) genAddrTaken() addrTakenHow {
method pushTunables (line 544) | func (s *genstate) pushTunables() {
method popTunables (line 548) | func (s *genstate) popTunables() {
method redistributeFraction (line 562) | func (s *genstate) redistributeFraction(toIncorporate uint8, avoid []i...
method precludeSelectedTypes (line 595) | func (s *genstate) precludeSelectedTypes(t int, t2 ...int) {
method GenMapKeyType (line 606) | func (s *genstate) GenMapKeyType(f *funcdef, depth int, pidx int) parm {
method GenParm (line 616) | func (s *genstate) GenParm(f *funcdef, depth int, mkctl bool, pidx int...
method GenReturn (line 797) | func (s *genstate) GenReturn(f *funcdef, depth int, pidx int) parm {
method GenFunc (line 804) | func (s *genstate) GenFunc(fidx int, pidx int) *funcdef {
method eqFuncRef (line 872) | func (s *genstate) eqFuncRef(f *funcdef, t parm, caller bool) string {
method emitCompareFunc (line 885) | func (s *genstate) emitCompareFunc(f *funcdef, b *bytes.Buffer, p parm) {
method emitStructAndArrayDefs (line 932) | func (s *genstate) emitStructAndArrayDefs(f *funcdef, b *bytes.Buffer) {
method GenValue (line 972) | func (s *genstate) GenValue(f *funcdef, p parm, value int, caller bool...
method emitMapKeyTmps (line 1011) | func (s *genstate) emitMapKeyTmps(f *funcdef, b *bytes.Buffer, pidx in...
method emitCheckReturnsInCaller (line 1031) | func (s *genstate) emitCheckReturnsInCaller(f *funcdef, b *bytes.Buffe...
method emitCaller (line 1071) | func (s *genstate) emitCaller(f *funcdef, b *bytes.Buffer, pidx int) {
method emitDerefFuncs (line 1220) | func (s *genstate) emitDerefFuncs(b *bytes.Buffer, emit bool) {
method emitAssignFuncs (line 1240) | func (s *genstate) emitAssignFuncs(b *bytes.Buffer, emit bool) {
method emitNewFuncs (line 1260) | func (s *genstate) emitNewFuncs(b *bytes.Buffer, emit bool) {
method emitGlobalVars (line 1284) | func (s *genstate) emitGlobalVars(b *bytes.Buffer, emit bool) {
method emitGenValFuncs (line 1300) | func (s *genstate) emitGenValFuncs(f *funcdef, b *bytes.Buffer, emit b...
method emitAddrTakenHelpers (line 1333) | func (s *genstate) emitAddrTakenHelpers(f *funcdef, b *bytes.Buffer, e...
method genGlobVar (line 1343) | func (s *genstate) genGlobVar(p parm) string {
method genParamDerefFunc (line 1360) | func (s *genstate) genParamDerefFunc(p parm) string {
method genAssignFunc (line 1377) | func (s *genstate) genAssignFunc(p parm) string {
method genAllocFunc (line 1394) | func (s *genstate) genAllocFunc(p parm) string {
method genParamRef (line 1411) | func (s *genstate) genParamRef(p parm, idx int) string {
method genReturnAssign (line 1425) | func (s *genstate) genReturnAssign(b *bytes.Buffer, r parm, idx int, v...
method emitParamElemCheck (line 1439) | func (s *genstate) emitParamElemCheck(f *funcdef, b *bytes.Buffer, p p...
method emitParamChecks (line 1473) | func (s *genstate) emitParamChecks(f *funcdef, b *bytes.Buffer, pidx i...
method emitDeferChecks (line 1567) | func (s *genstate) emitDeferChecks(f *funcdef, b *bytes.Buffer, value ...
method emitVarAssign (line 1639) | func (s *genstate) emitVarAssign(f *funcdef, b *bytes.Buffer, r parm, ...
method emitChecker (line 1656) | func (s *genstate) emitChecker(f *funcdef, b *bytes.Buffer, pidx int, ...
method emitRecursiveCall (line 1794) | func (s *genstate) emitRecursiveCall(f *funcdef) string {
method emitReturn (line 1818) | func (s *genstate) emitReturn(f *funcdef, b *bytes.Buffer, doRecursive...
method GenPair (line 1886) | func (s *genstate) GenPair(calloutfile *os.File, checkoutfile *os.File...
method openOutputFile (line 1922) | func (s *genstate) openOutputFile(filename string, pk string, imports ...
method emitUtils (line 2027) | func (s *genstate) emitUtils(outf *os.File, maxfail int, numtpk int) {
method emitMain (line 2050) | func (s *genstate) emitMain(outf *os.File, numit int, fcnmask map[int]...
method callerPkg (line 2093) | func (s *genstate) callerPkg(which int) string {
method callerFile (line 2097) | func (s *genstate) callerFile(which int) string {
method checkerPkg (line 2102) | func (s *genstate) checkerPkg(which int) string {
method checkerFile (line 2106) | func (s *genstate) checkerFile(which int) string {
method utilsPkg (line 2111) | func (s *genstate) utilsPkg() string {
method beginPackage (line 2115) | func (s *genstate) beginPackage(pkidx int) {
function genDeref (line 859) | func genDeref(p parm) (parm, string) {
function checkableElements (line 1182) | func checkableElements(p parm) int {
type funcdesc (line 1212) | type funcdesc struct
type miscVals (line 1962) | type miscVals struct
constant utilsTemplate (line 1968) | utilsTemplate = `
constant mainPreamble (line 2039) | mainPreamble = `
function makeDir (line 2082) | func makeDir(d string) {
function runImports (line 2124) | func runImports(files []string) {
function shouldEmitFP (line 2143) | func shouldEmitFP(fn int, pk int, fcnmask map[int]int, pkmask map[int]in...
function Generate (line 2165) | func Generate(c GenConfig) int {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/mapparm.go
type mapparm (line 14) | type mapparm struct
method IsControl (line 26) | func (p mapparm) IsControl() bool {
method TypeName (line 30) | func (p mapparm) TypeName() string {
method QualName (line 34) | func (p mapparm) QualName() string {
method Declare (line 38) | func (p mapparm) Declare(b *bytes.Buffer, prefix string, suffix string...
method String (line 46) | func (p mapparm) String() string {
method GenValue (line 51) | func (p mapparm) GenValue(s *genstate, f *funcdef, value int, caller b...
method GenElemRef (line 69) | func (p mapparm) GenElemRef(elidx int, path string) (string, parm) {
method NumElements (line 85) | func (p mapparm) NumElements() int {
method HasPointer (line 89) | func (p mapparm) HasPointer() bool {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/numparm.go
type numparm (line 15) | type numparm struct
method TypeName (line 36) | func (p numparm) TypeName() string {
method QualName (line 43) | func (p numparm) QualName() string {
method String (line 47) | func (p numparm) String() string {
method NumElements (line 58) | func (p numparm) NumElements() int {
method IsControl (line 62) | func (p numparm) IsControl() bool {
method GenElemRef (line 66) | func (p numparm) GenElemRef(elidx int, path string) (string, parm) {
method Declare (line 70) | func (p numparm) Declare(b *bytes.Buffer, prefix string, suffix string...
method genRandNum (line 78) | func (p numparm) genRandNum(s *genstate, value int) (string, int) {
method GenValue (line 136) | func (p numparm) GenValue(s *genstate, f *funcdef, value int, caller b...
method HasPointer (line 142) | func (p numparm) HasPointer() bool {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/parm.go
type parm (line 17) | type parm interface
type addrTakenHow (line 105) | type addrTakenHow
method AddrTaken (line 121) | func (a *addrTakenHow) AddrTaken() addrTakenHow {
method SetAddrTaken (line 125) | func (a *addrTakenHow) SetAddrTaken(val addrTakenHow) {
constant notAddrTaken (line 109) | notAddrTaken addrTakenHow = 0
constant addrTakenSimple (line 112) | addrTakenSimple addrTakenHow = 1
constant addrTakenPassed (line 115) | addrTakenPassed addrTakenHow = 2
constant addrTakenHeap (line 118) | addrTakenHeap addrTakenHow = 3
type isBlank (line 129) | type isBlank
method IsBlank (line 131) | func (b *isBlank) IsBlank() bool {
method SetBlank (line 135) | func (b *isBlank) SetBlank(val bool) {
type isGenValFunc (line 139) | type isGenValFunc
method IsGenVal (line 141) | func (g *isGenValFunc) IsGenVal() bool {
method SetIsGenVal (line 145) | func (g *isGenValFunc) SetIsGenVal(val bool) {
type skipCompare (line 149) | type skipCompare
method SkipCompare (line 158) | func (s *skipCompare) SkipCompare() skipCompare {
method SetSkipCompare (line 162) | func (s *skipCompare) SetSkipCompare(val skipCompare) {
constant SkipAll (line 153) | SkipAll = -1
constant SkipNone (line 154) | SkipNone = 0
constant SkipPayload (line 155) | SkipPayload = 1
function containedParms (line 168) | func containedParms(p parm) []parm {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/pointerparm.go
type pointerparm (line 14) | type pointerparm struct
method Declare (line 23) | func (p pointerparm) Declare(b *bytes.Buffer, prefix string, suffix st...
method GenElemRef (line 31) | func (p pointerparm) GenElemRef(elidx int, path string) (string, parm) {
method GenValue (line 35) | func (p pointerparm) GenValue(s *genstate, f *funcdef, value int, call...
method IsControl (line 46) | func (p pointerparm) IsControl() bool {
method NumElements (line 50) | func (p pointerparm) NumElements() int {
method String (line 54) | func (p pointerparm) String() string {
method TypeName (line 58) | func (p pointerparm) TypeName() string {
method QualName (line 62) | func (p pointerparm) QualName() string {
method HasPointer (line 73) | func (p pointerparm) HasPointer() bool {
function mkPointerParm (line 66) | func mkPointerParm(to parm) pointerparm {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/stringparm.go
type stringparm (line 13) | type stringparm struct
method Declare (line 21) | func (p stringparm) Declare(b *bytes.Buffer, prefix string, suffix str...
method GenElemRef (line 25) | func (p stringparm) GenElemRef(elidx int, path string) (string, parm) {
method GenValue (line 31) | func (p stringparm) GenValue(s *genstate, f *funcdef, value int, calle...
method IsControl (line 39) | func (p stringparm) IsControl() bool {
method NumElements (line 43) | func (p stringparm) NumElements() int {
method String (line 47) | func (p stringparm) String() string {
method TypeName (line 51) | func (p stringparm) TypeName() string {
method QualName (line 55) | func (p stringparm) QualName() string {
method HasPointer (line 59) | func (p stringparm) HasPointer() bool {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/structparm.go
type structparm (line 15) | type structparm struct
method TypeName (line 25) | func (p structparm) TypeName() string {
method QualName (line 29) | func (p structparm) QualName() string {
method Declare (line 33) | func (p structparm) Declare(b *bytes.Buffer, prefix string, suffix str...
method FieldName (line 41) | func (p structparm) FieldName(i int) string {
method String (line 48) | func (p structparm) String() string {
method GenValue (line 59) | func (p structparm) GenValue(s *genstate, f *funcdef, value int, calle...
method IsControl (line 92) | func (p structparm) IsControl() bool {
method NumElements (line 96) | func (p structparm) NumElements() int {
method GenElemRef (line 104) | func (p structparm) GenElemRef(elidx int, path string) (string, parm) {
method HasPointer (line 156) | func (p structparm) HasPointer() bool {
FILE: cmd/signature-fuzzer/internal/fuzz-generator/typedefparm.go
type typedefparm (line 14) | type typedefparm struct
method Declare (line 24) | func (p typedefparm) Declare(b *bytes.Buffer, prefix string, suffix st...
method GenElemRef (line 32) | func (p typedefparm) GenElemRef(elidx int, path string) (string, parm) {
method GenValue (line 45) | func (p typedefparm) GenValue(s *genstate, f *funcdef, value int, call...
method IsControl (line 55) | func (p typedefparm) IsControl() bool {
method NumElements (line 59) | func (p typedefparm) NumElements() int {
method String (line 63) | func (p typedefparm) String() string {
method TypeName (line 68) | func (p typedefparm) TypeName() string {
method QualName (line 73) | func (p typedefparm) QualName() string {
method HasPointer (line 77) | func (p typedefparm) HasPointer() bool {
method makeTypedefParm (line 81) | func (s *genstate) makeTypedefParm(f *funcdef, target parm, pidx int) pa...
FILE: cmd/signature-fuzzer/internal/fuzz-generator/wraprand.go
constant RandCtlNochecks (line 16) | RandCtlNochecks = 0
constant RandCtlChecks (line 17) | RandCtlChecks = 1 << iota
constant RandCtlCapture (line 18) | RandCtlCapture
constant RandCtlPanic (line 19) | RandCtlPanic
function NewWrapRand (line 22) | func NewWrapRand(seed int64, ctl int) *wraprand {
type wraprand (line 26) | type wraprand struct
method captureCall (line 37) | func (w *wraprand) captureCall(tag string, val string) {
method Intn (line 61) | func (w *wraprand) Intn(n int64) int64 {
method Float32 (line 70) | func (w *wraprand) Float32() float32 {
method NormFloat64 (line 79) | func (w *wraprand) NormFloat64() float64 {
method emitCalls (line 88) | func (w *wraprand) emitCalls(fn string) {
method Equal (line 99) | func (w *wraprand) Equal(w2 *wraprand) bool {
method Check (line 105) | func (w *wraprand) Check(w2 *wraprand) {
method Checkpoint (line 133) | func (w *wraprand) Checkpoint(tag string) {
FILE: cmd/splitdwarf/internal/macho/fat.go
type FatFile (line 14) | type FatFile struct
method Close (line 134) | func (ff *FatFile) Close() error {
type FatArchHeader (line 21) | type FatArchHeader struct
constant fatArchHeaderSize (line 29) | fatArchHeaderSize = 5 * 4
type FatArch (line 32) | type FatArch struct
function NewFatFile (line 40) | func NewFatFile(r io.ReaderAt) (*FatFile, error) {
function OpenFat (line 120) | func OpenFat(name string) (*FatFile, error) {
FILE: cmd/splitdwarf/internal/macho/file.go
type File (line 24) | type File struct
method Close (line 763) | func (f *File) Close() error {
method parseSymtab (line 1065) | func (f *File) parseSymtab(symdat, strtab []byte, hdr *SymtabCmd, offs...
method pushSection (line 1106) | func (f *File) pushSection(sh *Section, r io.ReaderAt) error {
method Segment (line 1171) | func (f *File) Segment(name string) *Segment {
method Section (line 1182) | func (f *File) Section(name string) *Section {
method DWARF (line 1192) | func (f *File) DWARF() (*dwarf.Data, error) {
method ImportedSymbols (line 1276) | func (f *File) ImportedSymbols() ([]string, error) {
method ImportedLibraries (line 1293) | func (f *File) ImportedLibraries() ([]string, error) {
type FileTOC (line 33) | type FileTOC struct
method AddLoad (line 40) | func (t *FileTOC) AddLoad(l Load) {
method AddSegment (line 49) | func (t *FileTOC) AddSegment(s *Segment) {
method AddSection (line 56) | func (t *FileTOC) AddSection(s *Section) {
method DerivedCopy (line 332) | func (t *FileTOC) DerivedCopy(Type HdrType, Flags HdrFlags) *FileTOC {
method TOCSize (line 343) | func (t *FileTOC) TOCSize() uint32 {
method LoadAlign (line 349) | func (t *FileTOC) LoadAlign() uint64 {
method SymbolSize (line 357) | func (t *FileTOC) SymbolSize() uint32 {
method HdrSize (line 366) | func (t *FileTOC) HdrSize() uint32 {
method LoadSize (line 381) | func (t *FileTOC) LoadSize() uint32 {
method FileSize (line 393) | func (t *FileTOC) FileSize() uint64 {
method Put (line 409) | func (t *FileTOC) Put(buffer []byte) int {
type Load (line 72) | type Load interface
type LoadBytes (line 109) | type LoadBytes
method String (line 505) | func (b LoadBytes) String() string {
method Raw (line 522) | func (b LoadBytes) Raw() []byte { return b }
method Copy (line 523) | func (b LoadBytes) Copy() LoadBytes { return LoadBytes(slic...
method LoadSize (line 524) | func (b LoadBytes) LoadSize(t *FileTOC) uint32 { return uint32(len(b)) }
type SegmentHeader (line 112) | type SegmentHeader struct
method String (line 537) | func (s *SegmentHeader) String() string {
type Segment (line 128) | type Segment struct
method Put32 (line 141) | func (s *Segment) Put32(b []byte, o binary.ByteOrder) int {
method Put64 (line 156) | func (s *Segment) Put64(b []byte, o binary.ByteOrder) int {
method UncompressedSize (line 439) | func (s *Segment) UncompressedSize(t *FileTOC, align uint64) uint64 {
method String (line 543) | func (s *Segment) String() string {
method Data (line 550) | func (s *Segment) Data() ([]byte, error) {
method Copy (line 559) | func (s *Segment) Copy() *Segment {
method CopyZeroed (line 563) | func (s *Segment) CopyZeroed() *Segment {
method LoadSize (line 577) | func (s *Segment) LoadSize(t *FileTOC) uint32 {
method Open (line 585) | func (s *Segment) Open() io.ReadSeeker { return io.NewSectionReader(s....
type LoadCmdBytes (line 175) | type LoadCmdBytes struct
method String (line 530) | func (s LoadCmdBytes) String() string {
method Copy (line 533) | func (s LoadCmdBytes) Copy() LoadCmdBytes {
type SectionHeader (line 180) | type SectionHeader struct
type Reloc (line 196) | type Reloc struct
type Section (line 209) | type Section struct
method Put32 (line 223) | func (s *Section) Put32(b []byte, o binary.ByteOrder) int {
method Put64 (line 239) | func (s *Section) Put64(b []byte, o binary.ByteOrder) int {
method PutRelocs (line 256) | func (s *Section) PutRelocs(b []byte, o binary.ByteOrder) int {
method UncompressedSize (line 448) | func (s *Section) UncompressedSize() uint64 {
method PutData (line 466) | func (s *Section) PutData(b []byte) {
method PutUncompressedData (line 474) | func (s *Section) PutUncompressedData(b []byte) {
method Data (line 588) | func (s *Section) Data() ([]byte, error) {
method Copy (line 597) | func (s *Section) Copy() *Section {
method Open (line 602) | func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s....
function putAtMost16Bytes (line 289) | func putAtMost16Bytes(b []byte, n string) {
type Symbol (line 299) | type Symbol struct
type FormatError (line 313) | type FormatError struct
method Error (line 322) | func (e *FormatError) Error() string {
method String (line 326) | func (e *FormatError) String() string {
function formatError (line 318) | func formatError(off int64, format string, data ...any) *FormatError {
method Put (line 526) | func (lc LoadCmd) Put(b []byte, o binary.ByteOrder) int {
type Dylib (line 605) | type Dylib struct
method String (line 613) | func (s *Dylib) String() string { return "Dylib " + s.Name }
method Copy (line 614) | func (s *Dylib) Copy() *Dylib {
method LoadSize (line 618) | func (s *Dylib) LoadSize(t *FileTOC) uint32 {
type Dylinker (line 622) | type Dylinker struct
method String (line 627) | func (s *Dylinker) String() string { return s.DylinkerCmd.LoadCmd.Stri...
method Copy (line 628) | func (s *Dylinker) Copy() *Dylinker {
method LoadSize (line 631) | func (s *Dylinker) LoadSize(t *FileTOC) uint32 {
type Symtab (line 636) | type Symtab struct
method Put (line 641) | func (s *Symtab) Put(b []byte, o binary.ByteOrder) int {
method String (line 651) | func (s *Symtab) String() string { return fmt.Sprintf("Symtab %#v", s....
method Copy (line 652) | func (s *Symtab) Copy() *Symtab {
method LoadSize (line 655) | func (s *Symtab) LoadSize(t *FileTOC) uint32 {
type LinkEditData (line 659) | type LinkEditData struct
method String (line 663) | func (s *LinkEditData) String() string { return "LinkEditData " + s.Lo...
method Copy (line 664) | func (s *LinkEditData) Copy() *LinkEditData {
method LoadSize (line 667) | func (s *LinkEditData) LoadSize(t *FileTOC) uint32 {
type Uuid (line 671) | type Uuid struct
method String (line 675) | func (s *Uuid) String() string {
method Copy (line 679) | func (s *Uuid) Copy() *Uuid {
method LoadSize (line 682) | func (s *Uuid) LoadSize(t *FileTOC) uint32 {
method Put (line 685) | func (s *Uuid) Put(b []byte, o binary.ByteOrder) int {
type DyldInfo (line 692) | type DyldInfo struct
method String (line 696) | func (s *DyldInfo) String() string { return "DyldInfo " + s.LoadCmd.St...
method Copy (line 697) | func (s *DyldInfo) Copy() *DyldInfo {
method LoadSize (line 700) | func (s *DyldInfo) LoadSize(t *FileTOC) uint32 {
type EncryptionInfo (line 704) | type EncryptionInfo struct
method String (line 708) | func (s *EncryptionInfo) String() string { return "EncryptionInfo " + ...
method Copy (line 709) | func (s *EncryptionInfo) Copy() *EncryptionInfo {
method LoadSize (line 712) | func (s *EncryptionInfo) LoadSize(t *FileTOC) uint32 {
type Dysymtab (line 717) | type Dysymtab struct
method String (line 722) | func (s *Dysymtab) String() string { return fmt.Sprintf("Dysymtab %#v"...
method Copy (line 723) | func (s *Dysymtab) Copy() *Dysymtab {
method LoadSize (line 726) | func (s *Dysymtab) LoadSize(t *FileTOC) uint32 {
type Rpath (line 731) | type Rpath struct
method String (line 736) | func (s *Rpath) String() string { return "Rpath " + s.Path }
method Command (line 737) | func (s *Rpath) Command() LoadCmd { return LcRpath }
method Copy (line 738) | func (s *Rpath) Copy() *Rpath {
method LoadSize (line 741) | func (s *Rpath) LoadSize(t *FileTOC) uint32 {
function Open (line 746) | func Open(name string) (*File, error) {
function NewFile (line 774) | func NewFile(r io.ReaderAt) (*File, error) {
type relocInfo (line 1101) | type relocInfo struct
function cstring (line 1162) | func cstring(b []byte) string {
function RoundUp (line 1303) | func RoundUp(x, align uint64) uint64 {
FILE: cmd/splitdwarf/internal/macho/file_test.go
type fileTest (line 13) | type fileTest struct
function TestOpen (line 225) | func TestOpen(t *testing.T) {
function TestOpenFailure (line 313) | func TestOpenFailure(t *testing.T) {
function TestOpenFat (line 321) | func TestOpenFat(t *testing.T) {
function TestOpenFatFailure (line 348) | func TestOpenFatFailure(t *testing.T) {
function TestRelocTypeString (line 373) | func TestRelocTypeString(t *testing.T) {
function TestTypeString (line 382) | func TestTypeString(t *testing.T) {
FILE: cmd/splitdwarf/internal/macho/macho.go
type FileHeader (line 16) | type FileHeader struct
method Put (line 26) | func (h *FileHeader) Put(b []byte, o binary.ByteOrder) int {
constant fileHeaderSize32 (line 42) | fileHeaderSize32 = 7 * 4
constant fileHeaderSize64 (line 43) | fileHeaderSize64 = 8 * 4
constant Magic32 (line 47) | Magic32 uint32 = 0xfeedface
constant Magic64 (line 48) | Magic64 uint32 = 0xfeedfacf
constant MagicFat (line 49) | MagicFat uint32 = 0xcafebabe
type HdrFlags (line 52) | type HdrFlags
type SegFlags (line 53) | type SegFlags
type SecFlags (line 54) | type SecFlags
type HdrType (line 57) | type HdrType
method String (line 76) | func (t HdrType) String() string { return stringName(uint32(t), type...
method GoString (line 77) | func (t HdrType) GoString() string { return stringName(uint32(t), type...
constant MhObject (line 60) | MhObject HdrType = 1
constant MhExecute (line 61) | MhExecute HdrType = 2
constant MhCore (line 62) | MhCore HdrType = 4
constant MhDylib (line 63) | MhDylib HdrType = 6
constant MhBundle (line 64) | MhBundle HdrType = 8
constant MhDsym (line 65) | MhDsym HdrType = 0xa
type Cpu (line 80) | type Cpu
method String (line 102) | func (i Cpu) String() string { return stringName(uint32(i), cpuStrin...
method GoString (line 103) | func (i Cpu) GoString() string { return stringName(uint32(i), cpuStrin...
constant cpuArch64 (line 82) | cpuArch64 = 0x01000000
constant Cpu386 (line 85) | Cpu386 Cpu = 7
constant CpuAmd64 (line 86) | CpuAmd64 Cpu = Cpu386 | cpuArch64
constant CpuArm (line 87) | CpuArm Cpu = 12
constant CpuArm64 (line 88) | CpuArm64 Cpu = CpuArm | cpuArch64
constant CpuPpc (line 89) | CpuPpc Cpu = 18
constant CpuPpc64 (line 90) | CpuPpc64 Cpu = CpuPpc | cpuArch64
type LoadCmd (line 106) | type LoadCmd
method Command (line 108) | func (c LoadCmd) Command() LoadCmd { return c }
method String (line 163) | func (i LoadCmd) String() string { return stringName(uint32(i), cmdS...
method GoString (line 164) | func (i LoadCmd) GoString() string { return stringName(uint32(i), cmdS...
constant LcSegment (line 112) | LcSegment LoadCmd = 0x1
constant LcSymtab (line 113) | LcSymtab LoadCmd = 0x2
constant LcThread (line 114) | LcThread LoadCmd = 0x4
constant LcUnixthread (line 115) | LcUnixthread LoadCmd = 0x5
constant LcDysymtab (line 116) | LcDysymtab LoadCmd = 0xb
constant LcDylib (line 117) | LcDylib LoadCmd = 0xc
constant LcIdDylib (line 118) | LcIdDylib LoadCmd = 0xd
constant LcLoadDylinker (line 119) | LcLoadDylinker LoadCmd = 0xe
constant LcIdDylinker (line 120) | LcIdDylinker LoadCmd = 0xf
constant LcSegment64 (line 121) | LcSegment64 LoadCmd = 0x19
constant LcUuid (line 122) | LcUuid LoadCmd = 0x1b
constant LcCodeSignature (line 123) | LcCodeSignature LoadCmd = 0x1d
constant LcSegmentSplitInfo (line 124) | LcSegmentSplitInfo LoadCmd = 0x1e
constant LcRpath (line 125) | LcRpath LoadCmd = 0x8000001c
constant LcEncryptionInfo (line 126) | LcEncryptionInfo LoadCmd = 0x21
constant LcDyldInfo (line 127) | LcDyldInfo LoadCmd = 0x22
constant LcDyldInfoOnly (line 128) | LcDyldInfoOnly LoadCmd = 0x80000022
constant LcVersionMinMacosx (line 129) | LcVersionMinMacosx LoadCmd = 0x24
constant LcVersionMinIphoneos (line 130) | LcVersionMinIphoneos LoadCmd = 0x25
constant LcFunctionStarts (line 131) | LcFunctionStarts LoadCmd = 0x26
constant LcDyldEnvironment (line 132) | LcDyldEnvironment LoadCmd = 0x27
constant LcMain (line 133) | LcMain LoadCmd = 0x80000028
constant LcDataInCode (line 134) | LcDataInCode LoadCmd = 0x29
constant LcSourceVersion (line 135) | LcSourceVersion LoadCmd = 0x2a
constant LcDylibCodeSignDrs (line 136) | LcDylibCodeSignDrs LoadCmd = 0x2b
constant LcEncryptionInfo64 (line 137) | LcEncryptionInfo64 LoadCmd = 0x2c
constant LcVersionMinTvos (line 138) | LcVersionMinTvos LoadCmd = 0x2f
constant LcVersionMinWatchos (line 139) | LcVersionMinWatchos LoadCmd = 0x30
type Segment32 (line 168) | type Segment32 struct
type Segment64 (line 183) | type Segment64 struct
type SymtabCmd (line 198) | type SymtabCmd struct
type DysymtabCmd (line 208) | type DysymtabCmd struct
type DylibCmd (line 232) | type DylibCmd struct
type DylinkerCmd (line 242) | type DylinkerCmd struct
type RpathCmd (line 249) | type RpathCmd struct
type Thread (line 256) | type Thread struct
type DyldInfoCmd (line 264) | type DyldInfoCmd struct
type LinkEditDataCmd (line 275) | type LinkEditDataCmd struct
type EncryptionInfoCmd (line 282) | type EncryptionInfoCmd struct
type UuidCmd (line 289) | type UuidCmd struct
type EntryPointCmd (line 297) | type EntryPointCmd struct
type NoteCmd (line 304) | type NoteCmd struct
constant FlagNoUndefs (line 313) | FlagNoUndefs HdrFlags = 0x1
constant FlagIncrLink (line 314) | FlagIncrLink HdrFlags = 0x2
constant FlagDyldLink (line 315) | FlagDyldLink HdrFlags = 0x4
constant FlagBindAtLoad (line 316) | FlagBindAtLoad HdrFlags = 0x8
constant FlagPrebound (line 317) | FlagPrebound HdrFlags = 0x10
constant FlagSplitSegs (line 318) | FlagSplitSegs HdrFlags = 0x20
constant FlagLazyInit (line 319) | FlagLazyInit HdrFlags = 0x40
constant FlagTwoLevel (line 320) | FlagTwoLevel HdrFlags = 0x80
constant FlagForceFlat (line 321) | FlagForceFlat HdrFlags = 0x100
constant FlagNoMultiDefs (line 322) | FlagNoMultiDefs HdrFlags = 0x200
constant FlagNoFixPrebinding (line 323) | FlagNoFixPrebinding HdrFlags = 0x400
constant FlagPrebindable (line 324) | FlagPrebindable HdrFlags = 0x800
constant FlagAllModsBound (line 325) | FlagAllModsBound HdrFlags = 0x1000
constant FlagSubsectionsViaSymbols (line 326) | FlagSubsectionsViaSymbols HdrFlags = 0x2000
constant FlagCanonical (line 327) | FlagCanonical HdrFlags = 0x4000
constant FlagWeakDefines (line 328) | FlagWeakDefines HdrFlags = 0x8000
constant FlagBindsToWeak (line 329) | FlagBindsToWeak HdrFlags = 0x10000
constant FlagAllowStackExecution (line 330) | FlagAllowStackExecution HdrFlags = 0x20000
constant FlagRootSafe (line 331) | FlagRootSafe HdrFlags = 0x40000
constant FlagSetuidSafe (line 332) | FlagSetuidSafe HdrFlags = 0x80000
constant FlagNoReexportedDylibs (line 333) | FlagNoReexportedDylibs HdrFlags = 0x100000
constant FlagPIE (line 334) | FlagPIE HdrFlags = 0x200000
constant FlagDeadStrippableDylib (line 335) | FlagDeadStrippableDylib HdrFlags = 0x400000
constant FlagHasTLVDescriptors (line 336) | FlagHasTLVDescriptors HdrFlags = 0x800000
constant FlagNoHeapExecution (line 337) | FlagNoHeapExecution HdrFlags = 0x1000000
constant FlagAppExtensionSafe (line 338) | FlagAppExtensionSafe HdrFlags = 0x2000000
type Section32 (line 342) | type Section32 struct
type Section64 (line 357) | type Section64 struct
type Nlist32 (line 373) | type Nlist32 struct
type Nlist64 (line 382) | type Nlist64 struct
method Put64 (line 390) | func (n *Nlist64) Put64(b []byte, o binary.ByteOrder) uint32 {
method Put32 (line 399) | func (n *Nlist64) Put32(b []byte, o binary.ByteOrder) uint32 {
type Regs386 (line 409) | type Regs386 struct
type RegsAMD64 (line 429) | type RegsAMD64 struct
type intName (line 453) | type intName struct
function stringName (line 458) | func stringName(i uint32, names []intName, goSyntax bool) string {
FILE: cmd/splitdwarf/internal/macho/reloctype.go
type RelocTypeGeneric (line 9) | type RelocTypeGeneric
method GoString (line 20) | func (r RelocTypeGeneric) GoString() string { return "macho." + r.Stri...
constant GENERIC_RELOC_VANILLA (line 12) | GENERIC_RELOC_VANILLA RelocTypeGeneric = 0
constant GENERIC_RELOC_PAIR (line 13) | GENERIC_RELOC_PAIR RelocTypeGeneric = 1
constant GENERIC_RELOC_SECTDIFF (line 14) | GENERIC_RELOC_SECTDIFF RelocTypeGeneric = 2
constant GENERIC_RELOC_PB_LA_PTR (line 15) | GENERIC_RELOC_PB_LA_PTR RelocTypeGeneric = 3
constant GENERIC_RELOC_LOCAL_SECTDIFF (line 16) | GENERIC_RELOC_LOCAL_SECTDIFF RelocTypeGeneric = 4
constant GENERIC_RELOC_TLV (line 17) | GENERIC_RELOC_TLV RelocTypeGeneric = 5
type RelocTypeX86_64 (line 22) | type RelocTypeX86_64
method GoString (line 37) | func (r RelocTypeX86_64) GoString() string { return "macho." + r.Strin...
constant X86_64_RELOC_UNSIGNED (line 25) | X86_64_RELOC_UNSIGNED RelocTypeX86_64 = 0
constant X86_64_RELOC_SIGNED (line 26) | X86_64_RELOC_SIGNED RelocTypeX86_64 = 1
constant X86_64_RELOC_BRANCH (line 27) | X86_64_RELOC_BRANCH RelocTypeX86_64 = 2
constant X86_64_RELOC_GOT_LOAD (line 28) | X86_64_RELOC_GOT_LOAD RelocTypeX86_64 = 3
constant X86_64_RELOC_GOT (line 29) | X86_64_RELOC_GOT RelocTypeX86_64 = 4
constant X86_64_RELOC_SUBTRACTOR (line 30) | X86_64_RELOC_SUBTRACTOR RelocTypeX86_64 = 5
constant X86_64_RELOC_SIGNED_1 (line 31) | X86_64_RELOC_SIGNED_1 RelocTypeX86_64 = 6
constant X86_64_RELOC_SIGNED_2 (line 32) | X86_64_RELOC_SIGNED_2 RelocTypeX86_64 = 7
constant X86_64_RELOC_SIGNED_4 (line 33) | X86_64_RELOC_SIGNED_4 RelocTypeX86_64 = 8
constant X86_64_RELOC_TLV (line 34) | X86_64_RELOC_TLV RelocTypeX86_64 = 9
type RelocTypeARM (line 39) | type RelocTypeARM
method GoString (line 54) | func (r RelocTypeARM) GoString() string { return "macho." + r.String() }
constant ARM_RELOC_VANILLA (line 42) | ARM_RELOC_VANILLA RelocTypeARM = 0
constant ARM_RELOC_PAIR (line 43) | ARM_RELOC_PAIR RelocTypeARM = 1
constant ARM_RELOC_SECTDIFF (line 44) | ARM_RELOC_SECTDIFF RelocTypeARM = 2
constant ARM_RELOC_LOCAL_SECTDIFF (line 45) | ARM_RELOC_LOCAL_SECTDIFF RelocTypeARM = 3
constant ARM_RELOC_PB_LA_PTR (line 46) | ARM_RELOC_PB_LA_PTR RelocTypeARM = 4
constant ARM_RELOC_BR24 (line 47) | ARM_RELOC_BR24 RelocTypeARM = 5
constant ARM_THUMB_RELOC_BR22 (line 48) | ARM_THUMB_RELOC_BR22 RelocTypeARM = 6
constant ARM_THUMB_32BIT_BRANCH (line 49) | ARM_THUMB_32BIT_BRANCH RelocTypeARM = 7
constant ARM_RELOC_HALF (line 50) | ARM_RELOC_HALF RelocTypeARM = 8
constant ARM_RELOC_HALF_SECTDIFF (line 51) | ARM_RELOC_HALF_SECTDIFF RelocTypeARM = 9
type RelocTypeARM64 (line 56) | type RelocTypeARM64
method GoString (line 72) | func (r RelocTypeARM64) GoString() string { return "macho." + r.String...
constant ARM64_RELOC_UNSIGNED (line 59) | ARM64_RELOC_UNSIGNED RelocTypeARM64 = 0
constant ARM64_RELOC_SUBTRACTOR (line 60) | ARM64_RELOC_SUBTRACTOR RelocTypeARM64 = 1
constant ARM64_RELOC_BRANCH26 (line 61) | ARM64_RELOC_BRANCH26 RelocTypeARM64 = 2
constant ARM64_RELOC_PAGE21 (line 62) | ARM64_RELOC_PAGE21 RelocTypeARM64 = 3
constant ARM64_RELOC_PAGEOFF12 (line 63) | ARM64_RELOC_PAGEOFF12 RelocTypeARM64 = 4
constant ARM64_RELOC_GOT_LOAD_PAGE21 (line 64) | ARM64_RELOC_GOT_LOAD_PAGE21 RelocTypeARM64 = 5
constant ARM64_RELOC_GOT_LOAD_PAGEOFF12 (line 65) | ARM64_RELOC_GOT_LOAD_PAGEOFF12 RelocTypeARM64 = 6
constant ARM64_RELOC_POINTER_TO_GOT (line 66) | ARM64_RELOC_POINTER_TO_GOT RelocTypeARM64 = 7
constant ARM64_RELOC_TLVP_LOAD_PAGE21 (line 67) | ARM64_RELOC_TLVP_LOAD_PAGE21 RelocTypeARM64 = 8
constant ARM64_RELOC_TLVP_LOAD_PAGEOFF12 (line 68) | ARM64_RELOC_TLVP_LOAD_PAGEOFF12 RelocTypeARM64 = 9
constant ARM64_RELOC_ADDEND (line 69) | ARM64_RELOC_ADDEND RelocTypeARM64 = 10
FILE: cmd/splitdwarf/internal/macho/reloctype_string.go
function _ (line 7) | func _() {
constant _RelocTypeGeneric_name (line 19) | _RelocTypeGeneric_name = "GENERIC_RELOC_VANILLAGENERIC_RELOC_PAIRGENERIC...
method String (line 23) | func (i RelocTypeGeneric) String() string {
function _ (line 29) | func _() {
constant _RelocTypeX86_64_name (line 45) | _RelocTypeX86_64_name = "X86_64_RELOC_UNSIGNEDX86_64_RELOC_SIGNEDX86_64_...
method String (line 49) | func (i RelocTypeX86_64) String() string {
function _ (line 55) | func _() {
constant _RelocTypeARM_name (line 71) | _RelocTypeARM_name = "ARM_RELOC_VANILLAARM_RELOC_PAIRARM_RELOC_SECTDIFFA...
method String (line 75) | func (i RelocTypeARM) String() string {
function _ (line 81) | func _() {
constant _RelocTypeARM64_name (line 98) | _RelocTypeARM64_name = "ARM64_RELOC_UNSIGNEDARM64_RELOC_SUBTRACTORARM64_...
method String (line 102) | func (i RelocTypeARM64) String() string {
FILE: cmd/splitdwarf/internal/macho/testdata/hello.c
function main (line 3) | int
FILE: cmd/splitdwarf/splitdwarf.go
constant pageAlign (line 34) | pageAlign = 12
function note (line 37) | func note(format string, why ...any) {
function fail (line 41) | func fail(format string, why ...any) {
function main (line 47) | func main() {
function CreateMmapFile (line 344) | func CreateMmapFile(outDwarf string, size int64) (*os.File, []byte) {
function describe (line 361) | func describe(exem *macho.FileTOC) {
function contentuuid (line 390) | func contentuuid(exem *macho.FileTOC) []byte {
FILE: cmd/ssadump/main.go
function init (line 44) | func init() {
constant usage (line 49) | usage = `SSA builder and interpreter.
function main (line 64) | func main() {
function doMain (line 71) | func doMain() error {
type stringListValue (line 191) | type stringListValue
method Get (line 193) | func (ss *stringListValue) Get() any { return []string(*ss) }
method String (line 195) | func (ss *stringListValue) String() string { return fmt.Sprintf("%q", ...
method Set (line 197) | func (ss *stringListValue) Set(s string) error { *ss = append(*ss, s);...
FILE: cmd/stress/stress.go
function init (line 44) | func init() {
function defaultPrefix (line 57) | func defaultPrefix() string {
function main (line 62) | func main() {
FILE: cmd/stringer/endtoend_test.go
function TestMain (line 33) | func TestMain(m *testing.M) {
function TestEndToEnd (line 52) | func TestEndToEnd(t *testing.T) {
function typeName (line 90) | func typeName(fname string) string {
function TestTags (line 97) | func TestTags(t *testing.T) {
function TestConstValueChange (line 144) | func TestConstValueChange(t *testing.T) {
function TestTestFiles (line 231) | func TestTestFiles(t *testing.T) {
function TestCollidingOutput (line 290) | func TestCollidingOutput(t *testing.T) {
function stringerPath (line 316) | func stringerPath(t *testing.T) string {
function stringerCompileAndRun (line 330) | func stringerCompileAndRun(t *testing.T, dir, stringer, typeName, fileNa...
function copy (line 351) | func copy(to, from string) error {
function run (line 368) | func run(t testing.TB, name string, arg ...string) error {
function runInDir (line 375) | func runInDir(t testing.TB, dir, name string, arg ...string) error {
FILE: cmd/stringer/golden_test.go
type Golden (line 22) | type Golden struct
constant day_in (line 46) | day_in = `type Day int
constant day_out (line 58) | day_out = `func _() {
constant offset_in (line 86) | offset_in = `type Number int
constant offset_out (line 96) | offset_out = `func _() {
constant gap_in (line 119) | gap_in = `type Gap int
constant gap_out (line 132) | gap_out = `func _() {
constant num_in (line 174) | num_in = `type Num int
constant num_out (line 184) | num_out = `func _() {
constant unum_in (line 209) | unum_in = `type Unum uint
constant unum_out (line 222) | unum_out = `func _() {
constant unumpos_in (line 257) | unumpos_in = `type Unumpos uint
constant unumpos_out (line 270) | unumpos_out = `func _() {
constant prime_in (line 307) | prime_in = `type Prime int
constant prime_out (line 326) | prime_out = `func _() {
constant prefix_in (line 372) | prefix_in = `type Type int
constant prefix_out (line 384) | prefix_out = `func _() {
constant tokens_in (line 410) | tokens_in = `type Token int
constant tokens_out (line 427) | tokens_out = `func _() {
constant overflow8_in (line 455) | overflow8_in = `type Overflow8 int8
constant overflow8_out (line 716) | overflow8_out = `func _() {
function TestGolden (line 991) | func TestGolden(t *testing.T) {
FILE: cmd/stringer/multifile_test.go
function expectFooString (line 31) | func expectFooString(pkg string) []byte {
function TestMultifileStringer (line 61) | func TestMultifileStringer(t *testing.T) {
function dirContent (line 442) | func dirContent(t *testing.T, dir string) map[string]bool {
function trimHeader (line 457) | func trimHeader(s []byte) []byte {
FILE: cmd/stringer/stringer.go
function Usage (line 106) | func Usage() {
function main (line 116) | func main() {
function baseName (line 228) | func baseName(pkg *Package, typename string) string {
function isDirectory (line 237) | func isDirectory(name string) bool {
type Generator (line 247) | type Generator struct
method Printf (line 254) | func (g *Generator) Printf(format string, args ...any) {
method generate (line 351) | func (g *Generator) generate(typeName string, values []Value) {
method format (line 417) | func (g *Generator) format() []byte {
method declareIndexAndNameVars (line 575) | func (g *Generator) declareIndexAndNameVars(runs [][]Value, typeName s...
method declareIndexAndNameVar (line 600) | func (g *Generator) declareIndexAndNameVar(run []Value, typeName strin...
method createIndexAndNameDecl (line 607) | func (g *Generator) createIndexAndNameDecl(run []Value, typeName strin...
method declareNameVars (line 629) | func (g *Generator) declareNameVars(runs [][]Value, typeName string, s...
method buildOneRun (line 640) | func (g *Generator) buildOneRun(runs [][]Value, typeName string) {
method buildMultipleRuns (line 662) | func (g *Generator) buildMultipleRuns(runs [][]Value, typeName string) {
method buildMap (line 693) | func (g *Generator) buildMap(runs [][]Value, typeName string) {
type File (line 259) | type File struct
method genDecl (line 462) | func (f *File) genDecl(node ast.Node) bool {
type Package (line 270) | type Package struct
function loadPackages (line 283) | func loadPackages(
function findValues (line 336) | func findValues(typeName string, pkg *Package) []Value {
function splitIntoRuns (line 387) | func splitIntoRuns(values []Value) [][]Value {
type Value (line 430) | type Value struct
method String (line 443) | func (v *Value) String() string {
type byValue (line 450) | type byValue
method Len (line 452) | func (b byValue) Len() int { return len(b) }
method Swap (line 453) | func (b byValue) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
method Less (line 454) | func (b byValue) Less(i, j int) bool {
function usize (line 561) | func usize(n int) int {
constant stringOneRun (line 651) | stringOneRun = `func (i %[1]s) String() string {
constant stringMap (line 709) | stringMap = `func (i %[1]s) String() string {
FILE: cmd/stringer/testdata/cgo.go
type Cgo (line 16) | type Cgo
constant MustScanSubDirs (line 20) | MustScanSubDirs Cgo = 1 << iota
function main (line 23) | func main() {
function ck (line 28) | func ck(day Cgo, str string) {
FILE: cmd/stringer/testdata/conv.go
type Other (line 11) | type Other
constant alpha (line 14) | alpha Other = iota
constant beta (line 15) | beta
constant gamma (line 16) | gamma
constant delta (line 17) | delta
type Conv (line 20) | type Conv
constant Alpha (line 23) | Alpha = Conv(alpha)
constant Beta (line 24) | Beta = Conv(beta)
constant Gamma (line 25) | Gamma = Conv(gamma)
constant Delta (line 26) | Delta = Conv(delta)
function main (line 29) | func main() {
function ck (line 37) | func ck(c Conv, str string) {
FILE: cmd/stringer/testdata/conv2.go
type Other (line 15) | type Other
constant alpha (line 19) | alpha Other = iota
constant beta (line 20) | beta
constant gamma (line 21) | gamma
constant delta (line 22) | delta
type Conv2 (line 26) | type Conv2
constant Alpha (line 29) | Alpha = Conv2(alpha)
constant Beta (line 30) | Beta = Conv2(beta)
constant Gamma (line 31) | Gamma = Conv2(gamma)
constant Delta (line 32) | Delta = Conv2(delta)
function main (line 35) | func main() {
function ck (line 43) | func ck(c Conv2, str string) {
FILE: cmd/stringer/testdata/day.go
type Day (line 11) | type Day
constant Monday (line 14) | Monday Day = iota
constant Tuesday (line 15) | Tuesday
constant Wednesday (line 16) | Wednesday
constant Thursday (line 17) | Thursday
constant Friday (line 18) | Friday
constant Saturday (line 19) | Saturday
constant Sunday (line 20) | Sunday
function main (line 23) | func main() {
function ck (line 35) | func ck(day Day, str string) {
FILE: cmd/stringer/testdata/gap.go
type Gap (line 11) | type Gap
constant Two (line 14) | Two Gap = 2
constant Three (line 15) | Three Gap = 3
constant Five (line 16) | Five Gap = 5
constant Six (line 17) | Six Gap = 6
constant Seven (line 18) | Seven Gap = 7
constant Eight (line 19) | Eight Gap = 8
constant Nine (line 20) | Nine Gap = 9
constant Eleven (line 21) | Eleven Gap = 11
function main (line 24) | func main() {
function ck (line 40) | func ck(gap Gap, str string) {
FILE: cmd/stringer/testdata/int8overflow.go
type Int8overflow (line 14) | type Int8overflow
constant I_128 (line 17) | I_128 Int8overflow = -128
constant I_127 (line 18) | I_127 Int8overflow = -127
constant I_126 (line 19) | I_126 Int8overflow = -126
constant I_125 (line 20) | I_125 Int8overflow = -125
constant I_124 (line 21) | I_124 Int8overflow = -124
constant I_123 (line 22) | I_123 Int8overflow = -123
constant I_122 (line 23) | I_122 Int8overflow = -122
constant I_121 (line 24) | I_121 Int8overflow = -121
constant I_120 (line 25) | I_120 Int8overflow = -120
constant I_119 (line 26) | I_119 Int8overflow = -119
constant I_118 (line 27) | I_118 Int8overflow = -118
constant I_117 (line 28) | I_117 Int8overflow = -117
constant I_116 (line 29) | I_116 Int8overflow = -116
constant I_115 (line 30) | I_115 Int8overflow = -115
constant I_114 (line 31) | I_114 Int8overflow = -114
constant I_113 (line 32) | I_113 Int8overflow = -113
constant I_112 (line 33) | I_112 Int8overflow = -112
constant I_111 (line 34) | I_111 Int8overflow = -111
constant I_110 (line 35) | I_110 Int8overflow = -110
constant I_109 (line 36) | I_109 Int8overflow = -109
constant I_108 (line 37) | I_108 Int8overflow = -108
constant I_107 (line 38) | I_107 Int8overflow = -107
constant I_106 (line 39) | I_106 Int8overflow = -106
constant I_105 (line 40) | I_105 Int8overflow = -105
constant I_104 (line 41) | I_104 Int8overflow = -104
constant I_103 (line 42) | I_103 Int8overflow = -103
constant I_102 (line 43) | I_102 Int8overflow = -102
constant I_101 (line 44) | I_101 Int8overflow = -101
constant I_100 (line 45) | I_100 Int8overflow = -100
constant I_99 (line 46) | I_99 Int8overflow = -99
constant I_98 (line 47) | I_98 Int8overflow = -98
constant I_97 (line 48) | I_97 Int8overflow = -97
constant I_96 (line 49) | I_96 Int8overflow = -96
constant I_95 (line 50) | I_95 Int8overflow = -95
constant I_94 (line 51) | I_94 Int8overflow = -94
constant I_93 (line 52) | I_93 Int8overflow = -93
constant I_92 (line 53) | I_92 Int8overflow = -92
constant I_91 (line 54) | I_91 Int8overflow = -91
constant I_90 (line 55) | I_90 Int8overflow = -90
constant I_89 (line 56) | I_89 Int8overflow = -89
constant I_88 (line 57) | I_88 Int8overflow = -88
constant I_87 (line 58) | I_87 Int8overflow = -87
constant I_86 (line 59) | I_86 Int8overflow = -86
constant I_85 (line 60) | I_85 Int8overflow = -85
constant I_84 (line 61) | I_84 Int8overflow = -84
constant I_83 (line 62) | I_83 Int8overflow = -83
constant I_82 (line 63) | I_82 Int8overflow = -82
constant I_81 (line 64) | I_81 Int8overflow = -81
constant I_80 (line 65) | I_80 Int8overflow = -80
constant I_79 (line 66) | I_79 Int8overflow = -79
constant I_78 (line 67) | I_78 Int8overflow = -78
constant I_77 (line 68) | I_77 Int8overflow = -77
constant I_76 (line 69) | I_76 Int8overflow = -76
constant I_75 (line 70) | I_75 Int8overflow = -75
constant I_74 (line 71) | I_74 Int8overflow = -74
constant I_73 (line 72) | I_73 Int8overflow = -73
constant I_72 (line 73) | I_72 Int8overflow = -72
constant I_71 (line 74) | I_71 Int8overflow = -71
constant I_70 (line 75) | I_70 Int8overflow = -70
constant I_69 (line 76) | I_69 Int8overflow = -69
constant I_68 (line 77) | I_68 Int8overflow = -68
constant I_67 (line 78) | I_67 Int8overflow = -67
constant I_66 (line 79) | I_66 Int8overflow = -66
constant I_65 (line 80) | I_65 Int8overflow = -65
constant I_64 (line 81) | I_64 Int8overflow = -64
constant I_63 (line 82) | I_63 Int8overflow = -63
constant I_62 (line 83) | I_62 Int8overflow = -62
constant I_61 (line 84) | I_61 Int8overflow = -61
constant I_60 (line 85) | I_60 Int8overflow = -60
constant I_59 (line 86) | I_59 Int8overflow = -59
constant I_58 (line 87) | I_58 Int8overflow = -58
constant I_57 (line 88) | I_57 Int8overflow = -57
constant I_56 (line 89) | I_56 Int8overflow = -56
constant I_55 (line 90) | I_55 Int8overflow = -55
constant I_54 (line 91) | I_54 Int8overflow = -54
constant I_53 (line 92) | I_53 Int8overflow = -53
constant I_52 (line 93) | I_52 Int8overflow = -52
constant I_51 (line 94) | I_51 Int8overflow = -51
constant I_50 (line 95) | I_50 Int8overflow = -50
constant I_49 (line 96) | I_49 Int8overflow = -49
constant I_48 (line 97) | I_48 Int8overflow = -48
constant I_47 (line 98) | I_47 Int8overflow = -47
constant I_46 (line 99) | I_46 Int8overflow = -46
constant I_45 (line 100) | I_45 Int8overflow = -45
constant I_44 (line 101) | I_44 Int8overflow = -44
constant I_43 (line 102) | I_43 Int8overflow = -43
constant I_42 (line 103) | I_42 Int8overflow = -42
constant I_41 (line 104) | I_41 Int8overflow = -41
constant I_40 (line 105) | I_40 Int8overflow = -40
constant I_39 (line 106) | I_39 Int8overflow = -39
constant I_38 (line 107) | I_38 Int8overflow = -38
constant I_37 (line 108) | I_37 Int8overflow = -37
constant I_36 (line 109) | I_36 Int8overflow = -36
constant I_35 (line 110) | I_35 Int8overflow = -35
constant I_34 (line 111) | I_34 Int8overflow = -34
constant I_33 (line 112) | I_33 Int8overflow = -33
constant I_32 (line 113) | I_32 Int8overflow = -32
constant I_31 (line 114) | I_31 Int8overflow = -31
constant I_30 (line 115) | I_30 Int8overflow = -30
constant I_29 (line 116) | I_29 Int8overflow = -29
constant I_28 (line 117) | I_28 Int8overflow = -28
constant I_27 (line 118) | I_27 Int8overflow = -27
constant I_26 (line 119) | I_26 Int8overflow = -26
constant I_25 (line 120) | I_25 Int8overflow = -25
constant I_24 (line 121) | I_24 Int8overflow = -24
constant I_23 (line 122) | I_23 Int8overflow = -23
constant I_22 (line 123) | I_22 Int8overflow = -22
constant I_21 (line 124) | I_21 Int8overflow = -21
constant I_20 (line 125) | I_20 Int8overflow = -20
constant I_19 (line 126) | I_19 Int8overflow = -19
constant I_18 (line 127) | I_18 Int8overflow = -18
constant I_17 (line 128) | I_17 Int8overflow = -17
constant I_16 (line 129) | I_16 Int8overflow = -16
constant I_15 (line 130) | I_15 Int8overflow = -15
constant I_14 (line 131) | I_14 Int8overflow = -14
constant I_13 (line 132) | I_13 Int8overflow = -13
constant I_12 (line 133) | I_12 Int8overflow = -12
constant I_11 (line 134) | I_11 Int8overflow = -11
constant I_10 (line 135) | I_10 Int8overflow = -10
constant I_9 (line 136) | I_9 Int8overflow = -9
constant I_8 (line 137) | I_8 Int8overflow = -8
constant I_7 (line 138) | I_7 Int8overflow = -7
constant I_6 (line 139) | I_6 Int8overflow = -6
constant I_5 (line 140) | I_5 Int8overflow = -5
constant I_4 (line 141) | I_4 Int8overflow = -4
constant I_3 (line 142) | I_3 Int8overflow = -3
constant I_2 (line 143) | I_2 Int8overflow = -2
constant I_1 (line 144) | I_1 Int8overflow = -1
constant I0 (line 145) | I0 Int8overflow = 0
constant I1 (line 146) | I1 Int8overflow = 1
constant I2 (line 147) | I2 Int8overflow = 2
constant I3 (line 148) | I3 Int8overflow = 3
constant I4 (line 149) | I4 Int8overflow = 4
constant I5 (line 150) | I5 Int8overflow = 5
constant I6 (line 151) | I6 Int8overflow = 6
constant I7 (line 152) | I7 Int8overflow = 7
constant I8 (line 153) | I8 Int8overflow = 8
constant I9 (line 154) | I9 Int8overflow = 9
constant I10 (line 155) | I10 Int8overflow = 10
constant I11 (line 156) | I11 Int8overflow = 11
constant I12 (line 157) | I12 Int8overflow = 12
constant I13 (line 158) | I13 Int8overflow = 13
constant I14 (line 159) | I14 Int8overflow = 14
constant I15 (line 160) | I15 Int8overflow = 15
constant I16 (line 161) | I16 Int8overflow = 16
constant I17 (line 162) | I17 Int8overflow = 17
constant I18 (line 163) | I18 Int8overflow = 18
constant I19 (line 164) | I19 Int8overflow = 19
constant I20 (line 165) | I20 Int8overflow = 20
constant I21 (line 166) | I21 Int8overflow = 21
constant I22 (line 167) | I22 Int8overflow = 22
constant I23 (line 168) | I23 Int8overflow = 23
constant I24 (line 169) | I24 Int8overflow = 24
constant I25 (line 170) | I25 Int8overflow = 25
constant I26 (line 171) | I26 Int8overflow = 26
constant I27 (line 172) | I27 Int8overflow = 27
constant I28 (line 173) | I28 Int8overflow = 28
constant I29 (line 174) | I29 Int8overflow = 29
constant I30 (line 175) | I30 Int8overflow = 30
constant I31 (line 176) | I31 Int8overflow = 31
constant I32 (line 177) | I32 Int8overflow = 32
constant I33 (line 178) | I33 Int8overflow = 33
constant I34 (line 179) | I34 Int8overflow = 34
constant I35 (line 180) | I35 Int8overflow = 35
constant I36 (line 181) | I36 Int8overflow = 36
constant I37 (line 182) | I37 Int8overflow = 37
constant I38 (line 183) | I38 Int8overflow = 38
constant I39 (line 184) | I39 Int8overflow = 39
constant I40 (line 185) | I40 Int8overflow = 40
constant I41 (line 186) | I41 Int8overflow = 41
constant I42 (line 187) | I42 Int8overflow = 42
constant I43 (line 188) | I43 Int8overflow = 43
constant I44 (line 189) | I44 Int8overflow = 44
constant I45 (line 190) | I45 Int8overflow = 45
constant I46 (line 191) | I46 Int8overflow = 46
constant I47 (line 192) | I47 Int8overflow = 47
constant I48 (line 193) | I48 Int8overflow = 48
constant I49 (line 194) | I49 Int8overflow = 49
constant I50 (line 195) | I50 Int8overflow = 50
constant I51 (line 196) | I51 Int8overflow = 51
constant I52 (line 197) | I52 Int8overflow = 52
constant I53 (line 198) | I53 Int8overflow = 53
constant I54 (line 199) | I54 Int8overflow = 54
constant I55 (line 200) | I55 Int8overflow = 55
constant I56 (line 201) | I56 Int8overflow = 56
constant I57 (line 202) | I57 Int8overflow = 57
constant I58 (line 203) | I58 Int8overflow = 58
constant I59 (line 204) | I59 Int8overflow = 59
constant I60 (line 205) | I60 Int8overflow = 60
constant I61 (line 206) | I61 Int8overflow = 61
constant I62 (line 207) | I62 Int8overflow = 62
constant I63 (line 208) | I63 Int8overflow = 63
constant I64 (line 209) | I64 Int8overflow = 64
constant I65 (line 210) | I65 Int8overflow = 65
constant I66 (line 211) | I66 Int8overflow = 66
constant I67 (line 212) | I67 Int8overflow = 67
constant I68 (line 213) | I68 Int8overflow = 68
constant I69 (line 214) | I69 Int8overflow = 69
constant I70 (line 215) | I70 Int8overflow = 70
constant I71 (line 216) | I71 Int8overflow = 71
constant I72 (line 217) | I72 Int8overflow = 72
constant I73 (line 218) | I73 Int8overflow = 73
constant I74 (line 219) | I74 Int8overflow = 74
constant I75 (line 220) | I75 Int8overflow = 75
constant I76 (line 221) | I76 Int8overflow = 76
constant I77 (line 222) | I77 Int8overflow = 77
constant I78 (line 223) | I78 Int8overflow = 78
constant I79 (line 224) | I79 Int8overflow = 79
constant I80 (line 225) | I80 Int8overflow = 80
constant I81 (line 226) | I81 Int8overflow = 81
constant I82 (line 227) | I82 Int8overflow = 82
constant I83 (line 228) | I83 Int8overflow = 83
constant I84 (line 229) | I84 Int8overflow = 84
constant I85 (line 230) | I85 Int8overflow = 85
constant I86 (line 231) | I86 Int8overflow = 86
constant I87 (line 232) | I87 Int8overflow = 87
constant I88 (line 233) | I88 Int8overflow = 88
constant I89 (line 234) | I89 Int8overflow = 89
constant I90 (line 235) | I90 Int8overflow = 90
constant I91 (line 236) | I91 Int8overflow = 91
constant I92 (line 237) | I92 Int8overflow = 92
constant I93 (line 238) | I93 Int8overflow = 93
constant I94 (line 239) | I94 Int8overflow = 94
constant I95 (line 240) | I95 Int8overflow = 95
constant I96 (line 241) | I96 Int8overflow = 96
constant I97 (line 242) | I97 Int8overflow = 97
constant I98 (line 243) | I98 Int8overflow = 98
constant I99 (line 244) | I99 Int8overflow = 99
constant I100 (line 245) | I100 Int8overflow = 100
constant I101 (line 246) | I101 Int8overflow = 101
constant I102 (line 247) | I102 Int8overflow = 102
constant I103 (line 248) | I103 Int8overflow = 103
constant I104 (line 249) | I104 Int8overflow = 104
constant I105 (line 250) | I105 Int8overflow = 105
constant I106 (line 251) | I106 Int8overflow = 106
constant I107 (line 252) | I107 Int8overflow = 107
constant I108 (line 253) | I108 Int8overflow = 108
constant I109 (line 254) | I109 Int8overflow = 109
constant I110 (line 255) | I110 Int8overflow = 110
constant I111 (line 256) | I111 Int8overflow = 111
constant I112 (line 257) | I112 Int8overflow = 112
constant I113 (line 258) | I113 Int8overflow = 113
constant I114 (line 259) | I114 Int8overflow = 114
constant I115 (line 260) | I115 Int8overflow = 115
constant I116 (line 261) | I116 Int8overflow = 116
constant I117 (line 262) | I117 Int8overflow = 117
constant I118 (line 263) | I118 Int8overflow = 118
constant I119 (line 264) | I119 Int8overflow = 119
constant I120 (line 265) | I120 Int8overflow = 120
constant I121 (line 266) | I121 Int8overflow = 121
constant I122 (line 267) | I122 Int8overflow = 122
constant I123 (line 268) | I123 Int8overflow = 123
constant I124 (line 269) | I124 Int8overflow = 124
constant I125 (line 270) | I125 Int8overflow = 125
constant I126 (line 271) | I126 Int8overflow = 126
constant I127 (line 272) | I127 Int8overflow = 127
function main (line 275) | func main() {
FILE: cmd/stringer/testdata/num.go
type Num (line 11) | type Num
constant m_2 (line 14) | m_2 Num = -2 + iota
constant m_1 (line 15) | m_1
constant m0 (line 16) | m0
constant m1 (line 17) | m1
constant m2 (line 18) | m2
function main (line 21) | func main() {
function ck (line 31) | func ck(num Num, str string) {
FILE: cmd/stringer/testdata/number.go
type Number (line 12) | type Number
constant _ (line 15) | _ Number = iota
constant One (line 16) | One
constant Two (line 17) | Two
constant Three (line 18) | Three
constant AnotherOne (line 19) | AnotherOne = One
function main (line 22) | func main() {
function ck (line 30) | func ck(num Number, str string) {
FILE: cmd/stringer/testdata/prime.go
type Prime (line 12) | type Prime
constant p2 (line 15) | p2 Prime = 2
constant p3 (line 16) | p3 Prime = 3
constant p5 (line 17) | p5 Prime = 5
constant p7 (line 18) | p7 Prime = 7
constant p77 (line 19) | p77 Prime = 7
constant p11 (line 20) | p11 Prime = 11
constant p13 (line 21) | p13 Prime = 13
constant p17 (line 22) | p17 Prime = 17
constant p19 (line 23) | p19 Prime = 19
constant p23 (line 24) | p23 Prime = 23
constant p29 (line 25) | p29 Prime = 29
constant p37 (line 26) | p37 Prime = 31
constant p41 (line 27) | p41 Prime = 41
constant p43 (line 28) | p43 Prime = 43
function main (line 31) | func main() {
function ck (line 52) | func ck(prime Prime, str string) {
FILE: cmd/stringer/testdata/prime2.go
type Likeint (line 16) | type Likeint
type Prime2 (line 19) | type Prime2
constant p2 (line 22) | p2 Prime2 = 2
constant p3 (line 23) | p3 Prime2 = 3
constant p5 (line 24) | p5 Prime2 = 5
constant p7 (line 25) | p7 Prime2 = 7
constant p77 (line 26) | p77 Prime2 = 7
constant p11 (line 27) | p11 Prime2 = 11
constant p13 (line 28) | p13 Prime2 = 13
constant p17 (line 29) | p17 Prime2 = 17
constant p19 (line 30) | p19 Prime2 = 19
constant p23 (line 31) | p23 Prime2 = 23
constant p29 (line 32) | p29 Prime2 = 29
constant p37 (line 33) | p37 Prime2 = 31
constant p41 (line 34) | p41 Prime2 = 41
constant p43 (line 35) | p43 Prime2 = 43
function main (line 38) | func main() {
function ck (line 59) | func ck(prime Prime2, str string) {
FILE: cmd/stringer/testdata/tag_main.go
type Const (line 5) | type Const
constant A (line 8) | A Const = iota
constant B (line 9) | B
constant C (line 10) | C
FILE: cmd/stringer/testdata/tag_tag.go
constant TagProtected (line 7) | TagProtected Const = C + 1
FILE: cmd/stringer/testdata/unum.go
type Unum (line 11) | type Unum
constant m_2 (line 14) | m_2 Unum = iota + 253
constant m_1 (line 15) | m_1
constant m0 (line 19) | m0 Unum = iota
constant m1 (line 20) | m1
constant m2 (line 21) | m2
function main (line 24) | func main() {
function ck (line 34) | func ck(unum Unum, str string) {
FILE: cmd/stringer/testdata/unum2.go
type Unum2 (line 11) | type Unum2
constant Zero (line 14) | Zero Unum2 = iota
constant One (line 15) | One
constant Two (line 16) | Two
function main (line 19) | func main() {
function ck (line 27) | func ck(unum Unum2, str string) {
FILE: cmd/stringer/testdata/vary_day.go
type Day (line 11) | type Day
constant Sunday (line 14) | Sunday Day = iota
constant Monday (line 15) | Monday
constant Tuesday (line 16) | Tuesday
constant Wednesday (line 17) | Wednesday
constant Thursday (line 18) | Thursday
constant Friday (line 19) | Friday
constant Saturday (line 20) | Saturday
function main (line 23) | func main() {
function ck (line 35) | func ck(day Day, str string) {
FILE: cmd/stringer/util_test.go
type u (line 15) | type u
type uu (line 16) | type uu
type SplitTest (line 18) | type SplitTest struct
function TestSplitIntoRuns (line 52) | func TestSplitIntoRuns(t *testing.T) {
FILE: cmd/toolstash/cmp.go
function compareLogs (line 43) | func compareLogs(outfile string) string {
FILE: cmd/toolstash/main.go
function usage (line 151) | func usage() {
function canCmp (line 175) | func canCmp(name string, args []string) bool {
function isBinTool (line 189) | func isBinTool(name string) bool {
function main (line 193) | func main() {
function compareTool (line 265) | func compareTool() {
function injectflags (line 328) | func injectflags(cmd []string, extra []string, addDashN bool) []string {
function cmpRun (line 338) | func cmpRun(keepLog bool, cmd []string) (outfile string, match bool) {
function sameObject (line 390) | func sameObject(file1, file2 string) bool {
function skipVersion (line 440) | func skipVersion(b1, b2 *bufio.Reader, file1, file2 string) bool {
function runCmd (line 521) | func runCmd(cmd []string, keepLog bool, logName string) (output []byte, ...
function save (line 549) | func save() {
function restore (line 584) | func restore() {
function shouldSave (line 607) | func shouldSave(name string) bool {
function checkShouldSave (line 621) | func checkShouldSave() {
function cp (line 633) | func cp(src, dst string) {
function exeName (line 646) | func exeName(name string) string {
FILE: container/intsets/export_test.go
method Check (line 8) | func (s *Sparse) Check() error { return s.check() }
FILE: container/intsets/sparse.go
type Sparse (line 39) | type Sparse struct
method init (line 257) | func (s *Sparse) init() {
method first (line 274) | func (s *Sparse) first() *block {
method next (line 283) | func (s *Sparse) next(b *block) *block {
method IsEmpty (line 291) | func (s *Sparse) IsEmpty() bool {
method Len (line 296) | func (s *Sparse) Len() int {
method Max (line 305) | func (s *Sparse) Max() int {
method Min (line 313) | func (s *Sparse) Min() int {
method LowerBound (line 322) | func (s *Sparse) LowerBound(x int) int {
method block (line 340) | func (s *Sparse) block(offset int) *block {
method Insert (line 350) | func (s *Sparse) Insert(x int) bool {
method removeBlock (line 368) | func (s *Sparse) removeBlock(b *block) *block {
method Remove (line 398) | func (s *Sparse) Remove(x int) bool {
method Clear (line 413) | func (s *Sparse) Clear() {
method TakeMin (line 429) | func (s *Sparse) TakeMin(p *int) bool {
method Has (line 441) | func (s *Sparse) Has(x int) bool {
method forEach (line 454) | func (s *Sparse) forEach(f func(int)) {
method Copy (line 461) | func (s *Sparse) Copy(x *Sparse) {
method insertBlockBefore (line 483) | func (s *Sparse) insertBlockBefore(next *block) *block {
method discardTail (line 520) | func (s *Sparse) discardTail(b *block) {
method IntersectionWith (line 532) | func (s *Sparse) IntersectionWith(x *Sparse) {
method Intersection (line 568) | func (s *Sparse) Intersection(x, y *Sparse) {
method Intersects (line 619) | func (s *Sparse) Intersects(x *Sparse) bool {
method UnionWith (line 642) | func (s *Sparse) UnionWith(x *Sparse) bool {
method Union (line 674) | func (s *Sparse) Union(x, y *Sparse) {
method DifferenceWith (line 720) | func (s *Sparse) DifferenceWith(x *Sparse) {
method Difference (line 754) | func (s *Sparse) Difference(x, y *Sparse) {
method SymmetricDifferenceWith (line 825) | func (s *Sparse) SymmetricDifferenceWith(x *Sparse) {
method SymmetricDifference (line 868) | func (s *Sparse) SymmetricDifference(x, y *Sparse) {
method SubsetOf (line 939) | func (s *Sparse) SubsetOf(x *Sparse) bool {
method Equals (line 966) | func (s *Sparse) Equals(t *Sparse) bool {
method String (line 990) | func (s *Sparse) String() string {
method BitString (line 1013) | func (s *Sparse) BitString() string {
method GoString (line 1047) | func (s *Sparse) GoString() string {
method AppendTo (line 1062) | func (s *Sparse) AppendTo(slice []int) []int {
method check (line 1073) | func (s *Sparse) check() error {
type word (line 50) | type word
constant _m (line 53) | _m = ^word(0)
constant bitsPerWord (line 54) | bitsPerWord = 8 << (_m>>8&1 + _m>>16&1 + _m>>32&1)
constant bitsPerBlock (line 55) | bitsPerBlock = 256
constant wordsPerBlock (line 56) | wordsPerBlock = bitsPerBlock / bitsPerWord
constant MaxInt (line 61) | MaxInt = int(^uint(0) >> 1)
constant MinInt (line 62) | MinInt = -MaxInt - 1
function popcount (line 66) | func popcount(x word) int {
function nlz (line 76) | func nlz(x word) int {
function ntz (line 86) | func ntz(x word) int {
type block (line 106) | type block struct
method insert (line 122) | func (b *block) insert(i uint) bool {
method remove (line 134) | func (b *block) remove(i uint) bool {
method has (line 144) | func (b *block) has(i uint) bool {
method empty (line 150) | func (b *block) empty() bool {
method len (line 160) | func (b *block) len() int {
method max (line 170) | func (b *block) max() int {
method min (line 186) | func (b *block) min(take bool) int {
method lowerBound (line 202) | func (b *block) lowerBound(i uint) (int, bool) {
method forEach (line 221) | func (b *block) forEach(f func(int)) {
function wordMask (line 114) | func wordMask(i uint) (w uint, mask word) {
function offsetAndBitIndex (line 236) | func offsetAndBitIndex(x int) (int, uint) {
type to_copy_a_sparse_you_must_call_its_Copy_method (line 254) | type to_copy_a_sparse_you_must_call_its_Copy_method struct
FILE: container/intsets/sparse_test.go
function TestBasics (line 18) | func TestBasics(t *testing.T) {
function TestMoreBasics (line 62) | func TestMoreBasics(t *testing.T) {
function TestTakeMin (line 97) | func TestTakeMin(t *testing.T) {
function TestMinAndMax (line 117) | func TestMinAndMax(t *testing.T) {
function TestEquals (line 146) | func TestEquals(t *testing.T) {
type pset (line 184) | type pset struct
method add (line 193) | func (set *pset) add(n int) {
method remove (line 205) | func (set *pset) remove(n int) {
method check (line 217) | func (set *pset) check(t *testing.T, msg string) {
function makePset (line 189) | func makePset() *pset {
function randomPset (line 236) | func randomPset(prng *rand.Rand, maxSize int) *pset {
function TestRandomMutations (line 250) | func TestRandomMutations(t *testing.T) {
function TestLowerBound (line 278) | func TestLowerBound(t *testing.T) {
function TestSetOperations (line 298) | func TestSetOperations(t *testing.T) {
function TestUnionWithChanged (line 464) | func TestUnionWithChanged(t *testing.T) {
function TestIntersectionWith (line 498) | func TestIntersectionWith(t *testing.T) {
function TestIntersects (line 515) | func TestIntersects(t *testing.T) {
function TestSubsetOf (line 554) | func TestSubsetOf(t *testing.T) {
function TestBitString (line 591) | func TestBitString(t *testing.T) {
function TestFailFastOnShallowCopy (line 613) | func TestFailFastOnShallowCopy(t *testing.T) {
function benchmarkInsertProbeSparse (line 636) | func benchmarkInsertProbeSparse(b *testing.B, size, spread int) {
function BenchmarkInsertProbeSparse_2_10 (line 668) | func BenchmarkInsertProbeSparse_2_10(b *testing.B) {
function BenchmarkInsertProbeSparse_10_10 (line 672) | func BenchmarkInsertProbeSparse_10_10(b *testing.B) {
function BenchmarkInsertProbeSparse_10_1000 (line 676) | func BenchmarkInsertProbeSparse_10_1000(b *testing.B) {
function BenchmarkInsertProbeSparse_100_100 (line 680) | func BenchmarkInsertProbeSparse_100_100(b *testing.B) {
function BenchmarkInsertProbeSparse_100_10000 (line 684) | func BenchmarkInsertProbeSparse_100_10000(b *testing.B) {
function BenchmarkUnionDifferenceSparse (line 688) | func BenchmarkUnionDifferenceSparse(b *testing.B) {
function BenchmarkUnionDifferenceHashTable (line 705) | func BenchmarkUnionDifferenceHashTable(b *testing.B) {
function BenchmarkAppendTo (line 734) | func BenchmarkAppendTo(b *testing.B) {
FILE: copyright/copyright.go
function checkCopyright (line 20) | func checkCopyright(dir string) ([]string, error) {
function checkFile (line 54) | func checkFile(toolsDir, filename string) (bool, error) {
FILE: copyright/copyright_test.go
function TestToolsCopyright (line 12) | func TestToolsCopyright(t *testing.T) {
FILE: cover/profile.go
type Profile (line 22) | type Profile struct
method Boundaries (line 206) | func (p *Profile) Boundaries(src []byte) (boundaries []Boundary) {
type ProfileBlock (line 29) | type ProfileBlock struct
type byFileName (line 35) | type byFileName
method Len (line 37) | func (p byFileName) Len() int { return len(p) }
method Less (line 38) | func (p byFileName) Less(i, j int) bool { return p[i].FileName < p[j]....
method Swap (line 39) | func (p byFileName) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
function ParseProfiles (line 43) | func ParseProfiles(fileName string) ([]*Profile, error) {
function ParseProfilesFromReader (line 54) | func ParseProfilesFromReader(rd io.Reader) ([]*Profile, error) {
function parseLine (line 129) | func parseLine(l string) (fileName string, block ProfileBlock, err error) {
function seekBack (line 167) | func seekBack(l string, sep byte, end int, what string) (value int, next...
type blocksByStart (line 185) | type blocksByStart
method Len (line 187) | func (b blocksByStart) Len() int { return len(b) }
method Swap (line 188) | func (b blocksByStart) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
method Less (line 189) | func (b blocksByStart) Less(i, j int) bool {
type Boundary (line 197) | type Boundary struct
type boundariesByPos (line 255) | type boundariesByPos
method Len (line 257) | func (b boundariesByPos) Len() int { return len(b) }
method Swap (line 258) | func (b boundariesByPos) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
method Less (line 259) | func (b boundariesByPos) Less(i, j int) bool {
FILE: cover/profile_test.go
function TestParseProfiles (line 15) | func TestParseProfiles(t *testing.T) {
function stringifyProfileArray (line 233) | func stringifyProfileArray(profiles []*Profile) string {
function BenchmarkParseLine (line 241) | func BenchmarkParseLine(b *testing.B) {
FILE: go/analysis/analysis.go
type Analyzer (line 18) | type Analyzer struct
method String (line 80) | func (a *Analyzer) String() string { return a.Name }
type Pass (line 91) | type Pass struct
method Reportf (line 190) | func (pass *Pass) Reportf(pos token.Pos, format string, args ...any) {
method ReportRangef (line 205) | func (pass *Pass) ReportRangef(rng Range, format string, args ...any) {
method String (line 210) | func (pass *Pass) String() string {
type PackageFact (line 177) | type PackageFact struct
type ObjectFact (line 183) | type ObjectFact struct
type Range (line 197) | type Range interface
type Fact (line 248) | type Fact interface
type Module (line 253) | type Module struct
type ModuleError (line 267) | type ModuleError struct
FILE: go/analysis/analysistest/analysistest.go
function WriteFiles (line 48) | func WriteFiles(filemap map[string]string) (dir string, cleanup func(), ...
type Testing (line 80) | type Testing interface
function RunWithSuggestedFixes (line 145) | func RunWithSuggestedFixes(t Testing, dir string, a *analysis.Analyzer, ...
function applyDiffsAndCompare (line 307) | func applyDiffsAndCompare(pkg *types.Package, filename string, original,...
function Run (line 400) | func Run(t Testing, dir string, a *analysis.Analyzer, patterns ...string...
type Result (line 471) | type Result struct
function loadPackages (line 486) | func loadPackages(dir string, patterns ...string) ([]*packages.Package, ...
function check (line 539) | func check(t Testing, gopath string, act *checker.Action) {
type expectation (line 717) | type expectation struct
method String (line 723) | func (ex expectation) String() string {
function parseExpectations (line 730) | func parseExpectations(text string) (lineDelta int, expects []expectatio...
function sanitize (line 791) | func sanitize(gopath, filename string) string {
FILE: go/analysis/analysistest/analysistest_test.go
function init (line 24) | func init() {
function TestTheTest (line 33) | func TestTheTest(t *testing.T) {
function TestNoEnd (line 164) | func TestNoEnd(t *testing.T) {
function TestModule (line 207) | func TestModule(t *testing.T) {
type errorfunc (line 263) | type errorfunc
method Errorf (line 265) | func (f errorfunc) Errorf(format string, args ...any) {
FILE: go/analysis/checker/checker.go
type Options (line 53) | type Options struct
type Graph (line 68) | type Graph struct
method All (line 97) | func (g *Graph) All() iter.Seq[*Action] {
type Action (line 115) | type Action struct
method String (line 132) | func (act *Action) String() string {
method exec (line 258) | func (act *Action) exec() { act.once.Do(act.execOnce) }
method execOnce (line 260) | func (act *Action) execOnce() {
method ObjectFact (line 511) | func (act *Action) ObjectFact(obj types.Object, ptr analysis.Fact) bool {
method exportObjectFact (line 524) | func (act *Action) exportObjectFact(obj types.Object, fact analysis.Fa...
method AllObjectFacts (line 547) | func (act *Action) AllObjectFacts() []analysis.ObjectFact {
method PackageFact (line 559) | func (act *Action) PackageFact(pkg *types.Package, ptr analysis.Fact) ...
method exportPackageFact (line 572) | func (act *Action) exportPackageFact(fact analysis.Fact) {
method AllPackageFacts (line 597) | func (act *Action) AllPackageFacts() []analysis.PackageFact {
function Analyze (line 147) | func Analyze(analyzers []*analysis.Analyzer, pkgs []*packages.Package, o...
function init (line 224) | func init() {
type objectFactKey (line 231) | type objectFactKey struct
type packageFactKey (line 236) | type packageFactKey struct
function execAll (line 241) | func execAll(actions []*Action) {
function inheritFacts (line 387) | func inheritFacts(act, dep *Action) {
function codeFact (line 452) | func codeFact(fact analysis.Fact) (analysis.Fact, error) {
function exportedFrom (line 486) | func exportedFrom(obj types.Object, pkg *types.Package) bool {
function factType (line 585) | func factType(fact analysis.Fact) reflect.Type {
function forEach (line 609) | func forEach(roots []*Action, f func(*Action) error) error {
function analysisModuleFromPackagesModule (line 629) | func analysisModuleFromPackagesModule(mod *packages.Module) *analysis.Mo...
FILE: go/analysis/checker/checker_test.go
function TestPassModule (line 21) | func TestPassModule(t *testing.T) {
FILE: go/analysis/checker/example_test.go
constant testdata (line 23) | testdata = `
function Example (line 60) | func Example() {
type pkgdeclsFact (line 139) | type pkgdeclsFact struct
method AFact (line 141) | func (*pkgdeclsFact) AFact() {}
function run (line 143) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/checker/print.go
method PrintText (line 25) | func (g *Graph) PrintText(w io.Writer, contextLines int) error {
function writeTextDiagnostics (line 29) | func writeTextDiagnostics(w io.Writer, roots []*Action, contextLines int...
method PrintJSON (line 73) | func (g *Graph) PrintJSON(w io.Writer) error {
function writeJSONDiagnostics (line 77) | func writeJSONDiagnostics(w io.Writer, roots []*Action) error {
FILE: go/analysis/diagnostic.go
type Diagnostic (line 18) | type Diagnostic struct
type RelatedInformation (line 59) | type RelatedInformation struct
type SuggestedFix (line 72) | type SuggestedFix struct
type TextEdit (line 83) | type TextEdit struct
FILE: go/analysis/internal/analysisflags/flags.go
function Parse (line 44) | func Parse(analyzers []*analysis.Analyzer, multi bool) []*analysis.Analy...
function expand (line 149) | func expand(analyzers []*analysis.Analyzer) map[*analysis.Analyzer]bool {
function printFlags (line 164) | func printFlags() {
function addVersionFlag (line 197) | func addVersionFlag() {
type versionFlag (line 204) | type versionFlag struct
method IsBoolFlag (line 206) | func (versionFlag) IsBoolFlag() bool { return true }
method Get (line 207) | func (versionFlag) Get() any { return nil }
method String (line 208) | func (versionFlag) String() string { return "" }
method Set (line 209) | func (versionFlag) Set(s string) error {
type triState (line 248) | type triState
method Get (line 258) | func (ts *triState) Get() any {
method Set (line 262) | func (ts *triState) Set(value string) error {
method String (line 277) | func (ts *triState) String() string {
method IsBoolFlag (line 289) | func (ts triState) IsBoolFlag() bool {
constant unset (line 251) | unset triState = iota
constant setTrue (line 252) | setTrue
constant setFalse (line 253) | setFalse
FILE: go/analysis/internal/analysisflags/flags_test.go
function main (line 19) | func main() {
function TestExec (line 29) | func TestExec(t *testing.T) {
FILE: go/analysis/internal/analysisflags/help.go
constant help (line 18) | help = `PROGNAME is a tool for static analysis of Go programs.
function Help (line 45) | func Help(progname string, analyzers []*analysis.Analyzer, args []string) {
FILE: go/analysis/internal/checker/checker.go
function RegisterFlags (line 57) | func RegisterFlags() {
function Run (line 82) | func Run(args []string, analyzers []*analysis.Analyzer) (exitcode int) {
function printDiagnostics (line 234) | func printDiagnostics(graph *checker.Graph) (exitcode int) {
function load (line 301) | func load(patterns []string, allSyntax bool) ([]*packages.Package, error) {
function needFacts (line 326) | func needFacts(analyzers []*analysis.Analyzer) bool {
function dbg (line 344) | func dbg(b byte) bool { return strings.IndexByte(Debug, b) >= 0 }
FILE: go/analysis/internal/checker/checker_test.go
function TestApplyFixes (line 24) | func TestApplyFixes(t *testing.T) {
function TestRunDespiteErrors (line 71) | func TestRunDespiteErrors(t *testing.T) {
type EmptyFact (line 174) | type EmptyFact struct
method AFact (line 176) | func (f *EmptyFact) AFact() {}
function TestURL (line 178) | func TestURL(t *testing.T) {
function TestPassReadFile (line 218) | func TestPassReadFile(t *testing.T) {
FILE: go/analysis/internal/checker/fix_test.go
function TestMain (line 36) | func TestMain(m *testing.M) {
constant exitCodeSuccess (line 56) | exitCodeSuccess = 0
constant exitCodeFailed (line 57) | exitCodeFailed = 1
constant exitCodeDiagnostics (line 58) | exitCodeDiagnostics = 3
function TestReportInvalidDiagnostic (line 64) | func TestReportInvalidDiagnostic(t *testing.T) {
function TestScript (line 198) | func TestScript(t *testing.T) {
constant badMarker (line 383) | badMarker = "[bad marker]"
function markerEdit (line 473) | func markerEdit(tokFile *token.File, content []byte, note *expect.Note) ...
function panics (line 611) | func panics(t *testing.T, want string, f func()) {
function section (line 625) | func section(ar *txtar.Archive, name string) *txtar.File {
FILE: go/analysis/internal/checker/start_test.go
function TestStartFixes (line 24) | func TestStartFixes(t *testing.T) {
function commentRun (line 66) | func commentRun(pass *analysis.Pass) (any, error) {
FILE: go/analysis/internal/versiontest/version_test.go
function init (line 35) | func init() {
function testDir (line 46) | func testDir(t *testing.T) (dir string) {
function TestAnalysistest (line 59) | func TestAnalysistest(t *testing.T) {
function TestMultichecker (line 63) | func TestMultichecker(t *testing.T) {
function TestSinglechecker (line 79) | func TestSinglechecker(t *testing.T) {
function TestVettool (line 95) | func TestVettool(t *testing.T) {
FILE: go/analysis/multichecker/multichecker.go
function Main (line 24) | func Main(analyzers ...*analysis.Analyzer) {
FILE: go/analysis/multichecker/multichecker_test.go
function main (line 22) | func main() {
function TestExitCode (line 38) | func TestExitCode(t *testing.T) {
FILE: go/analysis/passes/appends/appends.go
function run (line 32) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/appends/appends_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/appends/testdata/src/a/a.go
function badAppendSlice1 (line 9) | func badAppendSlice1() {
function badAppendSlice2 (line 14) | func badAppendSlice2() {
function goodAppendSlice1 (line 18) | func goodAppendSlice1() {
function goodAppendSlice2 (line 23) | func goodAppendSlice2() {
function goodAppendSlice3 (line 29) | func goodAppendSlice3() {
FILE: go/analysis/passes/appends/testdata/src/b/b.go
function append (line 9) | func append(args ...interface{}) []int {
function userdefine (line 14) | func userdefine() {
function localvar (line 20) | func localvar() {
FILE: go/analysis/passes/asmdecl/asmdecl.go
constant Doc (line 25) | Doc = "report mismatches between assembly files and Go declarations"
type asmKind (line 36) | type asmKind
constant asmString (line 40) | asmString asmKind = 100 + iota
constant asmSlice (line 41) | asmSlice
constant asmArray (line 42) | asmArray
constant asmInterface (line 43) | asmInterface
constant asmEmptyInterface (line 44) | asmEmptyInterface
constant asmStruct (line 45) | asmStruct
constant asmComplex (line 46) | asmComplex
type asmArch (line 50) | type asmArch struct
type asmFunc (line 70) | type asmFunc struct
type asmVar (line 78) | type asmVar struct
function init (line 121) | func init() {
function run (line 153) | func run(pass *analysis.Pass) (any, error) {
function asmKindForType (line 439) | func asmKindForType(t types.Type, size int) asmKind {
type component (line 468) | type component struct
function newComponent (line 477) | func newComponent(suffix string, kind asmKind, typ string, offset, size ...
function componentsOfType (line 483) | func componentsOfType(arch *asmArch, t types.Type) []component {
function appendComponentsRecursive (line 490) | func appendComponentsRecursive(arch *asmArch, t types.Type, cc []compone...
function asmParseDecl (line 559) | func asmParseDecl(pass *analysis.Pass, decl *ast.FuncDecl) map[string]*a...
function asmCheckVar (line 649) | func asmCheckVar(badf func(string, ...any), fn *asmFunc, line, expr stri...
FILE: go/analysis/passes/asmdecl/asmdecl_test.go
function Test (line 30) | func Test(t *testing.T) {
FILE: go/analysis/passes/asmdecl/testdata/src/a/asm.go
type S (line 9) | type S struct
function arg1 (line 15) | func arg1(x int8, y uint8)
function arg2 (line 16) | func arg2(x int16, y uint16)
function arg4 (line 17) | func arg4(x int32, y uint32)
function arg8 (line 18) | func arg8(x int64, y uint64)
function argint (line 19) | func argint(x int, y uint)
function argptr (line 20) | func argptr(x *byte, y *byte, c chan int, m map[int]int, f func())
function argstring (line 21) | func argstring(x, y string)
function argslice (line 22) | func argslice(x, y []string)
function argiface (line 23) | func argiface(x interface{}, y interface {
function argcomplex (line 26) | func argcomplex(x complex64, y complex128)
function argstruct (line 27) | func argstruct(x S, y struct{})
function argarray (line 28) | func argarray(x [2]S)
function returnint (line 29) | func returnint() int
function returnbyte (line 30) | func returnbyte(x int) byte
function returnnamed (line 31) | func returnnamed(x byte) (r1 int, r2 int16, r3 string, r4 byte)
function returnintmissing (line 32) | func returnintmissing() int
function leaf (line 33) | func leaf(x, y int) int
function noprof (line 35) | func noprof(x int)
function dupok (line 36) | func dupok(x int)
function nosplit (line 37) | func nosplit(x int)
function rodata (line 38) | func rodata(x int)
function noptr (line 39) | func noptr(x int)
function wrapper (line 40) | func wrapper(x int)
function f15271 (line 42) | func f15271() (x uint32)
function f17584 (line 43) | func f17584(x float32, y complex64)
function f29318 (line 44) | func f29318(x [2][2]uint64)
function noframe1 (line 46) | func noframe1(x int32)
function noframe2 (line 47) | func noframe2(x int32)
function fvariadic (line 49) | func fvariadic(int, ...int)
function pickStableABI (line 51) | func pickStableABI(x int)
function pickInternalABI (line 52) | func pickInternalABI(x int)
function pickFutureABI (line 53) | func pickFutureABI(x int)
function returnABIInternal (line 55) | func returnABIInternal() int
function returnmissingABIInternal (line 56) | func returnmissingABIInternal() int
function returnsyscallABIInternal (line 57) | func returnsyscallABIInternal() int
function retjmp (line 59) | func retjmp() int
FILE: go/analysis/passes/assign/assign.go
function run (line 38) | func run(pass *analysis.Pass) (any, error) {
function isMapIndex (line 138) | func isMapIndex(info *types.Info, e ast.Expr) bool {
FILE: go/analysis/passes/assign/assign_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/assign/testdata/src/a/a.go
type ST (line 11) | type ST struct
method SetX (line 16) | func (s *ST) SetX(x int, ch chan int) {
function num (line 43) | func num() int { return 2 }
function Index (line 45) | func Index() {
FILE: go/analysis/passes/assign/testdata/src/typeparams/typeparams.go
type ST (line 11) | type ST struct
method SetX (line 16) | func (s *ST[T]) SetX(x T, ch chan T) {
function num (line 31) | func num() int { return 2 }
FILE: go/analysis/passes/atomic/atomic.go
function run (line 33) | func run(pass *analysis.Pass) (any, error) {
function checkAtomicAddAssignment (line 69) | func checkAtomicAddAssignment(pass *analysis.Pass, left ast.Expr, call *...
FILE: go/analysis/passes/atomic/atomic_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/atomic/testdata/src/a/a.go
type Counter (line 13) | type Counter
function AtomicTests (line 15) | func AtomicTests() {
type T (line 55) | type T struct
method AddUint64 (line 57) | func (T) AddUint64(addr *uint64, delta uint64) uint64 { return 0 }
function NonAtomic (line 59) | func NonAtomic() {
FILE: go/analysis/passes/atomic/testdata/src/typeparams/typeparams.go
type Subtractable (line 13) | type Subtractable interface
function Sub (line 17) | func Sub[T Subtractable](addr *T, delta T) T {
type _S (line 25) | type _S struct
method AddInt64 (line 29) | func (v _S) AddInt64(_ *int64, delta int64) int64 {
function NonAtomicInt64 (line 34) | func NonAtomicInt64() {
FILE: go/analysis/passes/atomicalign/atomicalign.go
constant Doc (line 24) | Doc = "check for non-64-bits-aligned arguments to sync/atomic functions"
function run (line 34) | func run(pass *analysis.Pass) (any, error) {
function check64BitAlignment (line 66) | func check64BitAlignment(pass *analysis.Pass, funcName string, arg ast.E...
FILE: go/analysis/passes/atomicalign/atomicalign_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/atomicalign/testdata/src/a/a.go
function intsAlignment (line 17) | func intsAlignment() {
function floatAlignment (line 33) | func floatAlignment() {
function uintptrAlignment (line 45) | func uintptrAlignment() {
function runeAlignment (line 58) | func runeAlignment() {
function complexAlignment (line 69) | func complexAlignment() {
function channelAlignment (line 82) | func channelAlignment() {
function arrayAlignment (line 94) | func arrayAlignment() {
function anonymousFieldAlignment (line 110) | func anonymousFieldAlignment() {
type ts (line 124) | type ts struct
function typedStructAlignment (line 130) | func typedStructAlignment() {
function aliasAlignment (line 136) | func aliasAlignment() {
function stringAlignment (line 158) | func stringAlignment() {
function sliceAlignment (line 167) | func sliceAlignment() {
function interfaceAlignment (line 179) | func interfaceAlignment() {
function pointerAlignment (line 194) | func pointerAlignment() {
function nonStructFields (line 207) | func nonStructFields() {
function embeddedStructFields (line 219) | func embeddedStructFields() {
FILE: go/analysis/passes/atomicalign/testdata/src/b/b.go
function nonAffectedArchs (line 13) | func nonAffectedArchs() {
FILE: go/analysis/passes/bools/bools.go
constant Doc (line 21) | Doc = "check for common mistakes involving boolean operators"
function run (line 31) | func run(pass *analysis.Pass) (any, error) {
type boolOp (line 64) | type boolOp struct
method commutativeSets (line 80) | func (op boolOp) commutativeSets(info *types.Info, e *ast.BinaryExpr, ...
method checkRedundant (line 104) | func (op boolOp) checkRedundant(pass *analysis.Pass, exprs []ast.Expr) {
method checkSuspect (line 125) | func (op boolOp) checkSuspect(pass *analysis.Pass, exprs []ast.Expr) {
method split (line 170) | func (op boolOp) split(e ast.Expr, seen map[*ast.BinaryExpr]bool) (exp...
FILE: go/analysis/passes/bools/bools_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/bools/testdata/src/a/a.go
type T (line 11) | type T
method Foo (line 13) | func (t T) Foo() int { return int(t) }
type FT (line 15) | type FT
function RatherStupidConditions (line 19) | func RatherStupidConditions() {
function RoyallySuspectConditions (line 97) | func RoyallySuspectConditions() {
FILE: go/analysis/passes/bools/testdata/src/typeparams/typeparams.go
type T (line 9) | type T struct
method Foo (line 13) | func (t T[P]) Foo() int { return int(t.a) }
type FT (line 15) | type FT
function Sink (line 17) | func Sink[Elem any]() chan Elem {
function RedundantConditions (line 21) | func RedundantConditions[P interface{ int }]() {
function SuspectConditions (line 54) | func SuspectConditions[P interface{ ~int }, S interface{ ~string }]() {
FILE: go/analysis/passes/buildssa/buildssa.go
type SSA (line 38) | type SSA struct
function run (line 43) | func run(pass *analysis.Pass) (any, error) {
function allFunctions (line 101) | func allFunctions(pass *analysis.Pass) iter.Seq2[*ast.FuncDecl, *types.F...
FILE: go/analysis/passes/buildssa/buildssa_test.go
function Test (line 16) | func Test(t *testing.T) {
function TestGenericDecls (line 31) | func TestGenericDecls(t *testing.T) {
function TestImporting (line 46) | func TestImporting(t *testing.T) {
FILE: go/analysis/passes/buildssa/testdata/src/a/a.go
function Fib (line 3) | func Fib(x int) int {
type T (line 10) | type T
method fib (line 12) | func (T) fib(x int) int { return Fib(x) }
function _ (line 14) | func _() {
function _ (line 18) | func _() {
FILE: go/analysis/passes/buildssa/testdata/src/b/b.go
type Pointer (line 6) | type Pointer struct
method Load (line 10) | func (x *Pointer[T]) Load() *T {
function Load (line 14) | func Load[T any](x *Pointer[T]) *T {
function LoadPointer (line 18) | func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)
FILE: go/analysis/passes/buildssa/testdata/src/c/c.go
function A (line 10) | func A() {
function B (line 14) | func B() {
FILE: go/analysis/passes/buildtag/buildtag.go
constant Doc (line 20) | Doc = "check //go:build and // +build directives"
function runBuildTag (line 29) | func runBuildTag(pass *analysis.Pass) (any, error) {
function checkGoFile (line 55) | func checkGoFile(pass *analysis.Pass, f *ast.File) {
function checkOtherFile (line 82) | func checkOtherFile(pass *analysis.Pass, filename string) error {
type checker (line 98) | type checker struct
method init (line 110) | func (check *checker) init(pass *analysis.Pass) {
method file (line 117) | func (check *checker) file(pos token.Pos, text string) {
method comment (line 200) | func (check *checker) comment(pos token.Pos, text string) {
method goBuildLine (line 235) | func (check *checker) goBuildLine(pos token.Pos, line string) {
method plusBuildLine (line 274) | func (check *checker) plusBuildLine(pos token.Pos, line string) {
method finish (line 338) | func (check *checker) finish() {
method tags (line 372) | func (check *checker) tags(pos token.Pos, e constraint.Expr) {
function malformedGoTag (line 384) | func malformedGoTag(tag string) bool {
function validGoVersion (line 403) | func validGoVersion(tag string) bool {
FILE: go/analysis/passes/buildtag/buildtag_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/cgocall/cgocall.go
constant debug (line 24) | debug = false
constant Doc (line 26) | Doc = `detect some violations of the cgo pointer passing rules
function run (line 43) | func run(pass *analysis.Pass) (any, error) {
function checkCgo (line 58) | func checkCgo(fset *token.FileSet, f *ast.File, info *types.Info, report...
function typeCheckCgoSourceFiles (line 173) | func typeCheckCgoSourceFiles(fset *token.FileSet, pkg *types.Package, fi...
function cgoBaseType (line 291) | func cgoBaseType(info *types.Info, arg ast.Expr) types.Type {
function typeOKForCgoCall (line 340) | func typeOKForCgoCall(t types.Type, m map[types.Type]bool) bool {
function isUnsafePointer (line 362) | func isUnsafePointer(info *types.Info, e ast.Expr) bool {
type importerFunc (line 367) | type importerFunc
method Import (line 369) | func (f importerFunc) Import(path string) (*types.Package, error) { re...
function imported (line 372) | func imported(info *types.Info, spec *ast.ImportSpec) *types.Package {
FILE: go/analysis/passes/cgocall/cgocall_go120.go
function setGoVersion (line 11) | func setGoVersion(tc *types.Config, pkg *types.Package) {
FILE: go/analysis/passes/cgocall/cgocall_go121.go
function setGoVersion (line 11) | func setGoVersion(tc *types.Config, pkg *types.Package) {
FILE: go/analysis/passes/cgocall/cgocall_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/cgocall/testdata/src/a/cgo.go
function CgoTests (line 14) | func CgoTests() {
type S (line 69) | type S struct
type S2 (line 71) | type S2 struct
FILE: go/analysis/passes/cgocall/testdata/src/a/cgo3.go
constant x (line 11) | x = 1
function F (line 15) | func F() {
function FAD (line 18) | func FAD(int, string) bool {
FILE: go/analysis/passes/cgocall/testdata/src/b/b.go
function init (line 14) | func init() {
FILE: go/analysis/passes/cgocall/testdata/src/typeparams/typeparams.go
function CgoTest (line 14) | func CgoTest[T any]() {
type S (line 35) | type S struct
FILE: go/analysis/passes/composite/composite.go
constant Doc (line 21) | Doc = `check for unkeyed composite literals
function init (line 48) | func init() {
function run (line 54) | func run(pass *analysis.Pass) (any, error) {
function isLocalType (line 147) | func isLocalType(pass *analysis.Pass, typ types.Type) bool {
FILE: go/analysis/passes/composite/composite_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/composite/testdata/src/a/a.go
type MyStruct (line 48) | type MyStruct struct
FILE: go/analysis/passes/composite/testdata/src/a/a_fuzz_test.go
function Fuzz (line 13) | func Fuzz(f *testing.F) {}
FILE: go/analysis/passes/composite/testdata/src/typeparams/lib/lib.go
type Struct (line 7) | type Struct struct
type Slice (line 8) | type Slice
type Map (line 9) | type Map
FILE: go/analysis/passes/composite/testdata/src/typeparams/typeparams.go
type localStruct (line 9) | type localStruct struct
function F (line 11) | func F[
FILE: go/analysis/passes/copylock/copylock.go
constant Doc (line 25) | Doc = `check for locks erroneously passed by value
function run (line 40) | func run(pass *analysis.Pass) (any, error) {
function checkCopyLocksAssign (line 86) | func checkCopyLocksAssign(pass *analysis.Pass, assign *ast.AssignStmt, g...
function checkCopyLocksGenDecl (line 115) | func checkCopyLocksGenDecl(pass *analysis.Pass, gd *ast.GenDecl) {
function checkCopyLocksCompositeLit (line 130) | func checkCopyLocksCompositeLit(pass *analysis.Pass, cl *ast.CompositeLi...
function checkCopyLocksReturnStmt (line 142) | func checkCopyLocksReturnStmt(pass *analysis.Pass, rs *ast.ReturnStmt) {
function checkCopyLocksCallExpr (line 151) | func checkCopyLocksCallExpr(pass *analysis.Pass, ce *ast.CallExpr) {
function checkCopyLocksFunc (line 179) | func checkCopyLocksFunc(pass *analysis.Pass, name string, recv *ast.Fiel...
function checkCopyLocksRange (line 205) | func checkCopyLocksRange(pass *analysis.Pass, r *ast.RangeStmt) {
function checkCopyLocksRangeVar (line 210) | func checkCopyLocksRangeVar(pass *analysis.Pass, rtok token.Token, e ast...
type typePath (line 241) | type typePath
method String (line 244) | func (path typePath) String() string {
function lockPathRhs (line 257) | func lockPathRhs(pass *analysis.Pass, x ast.Expr) typePath {
function lockPath (line 283) | func lockPath(tpkg *types.Package, typ types.Type, seen map[types.Type]b...
function parent (line 374) | func parent(stack []ast.Node) ast.Node {
function init (line 384) | func init() {
FILE: go/analysis/passes/copylock/copylock_test.go
function Test (line 16) | func Test(t *testing.T) {
function TestVersions22 (line 21) | func TestVersions22(t *testing.T) {
function TestVersions21 (line 26) | func TestVersions21(t *testing.T) {
FILE: go/analysis/passes/copylock/main.go
function main (line 16) | func main() { singlechecker.Main(copylock.Analyzer) }
FILE: go/analysis/passes/copylock/testdata/src/a/copylock.go
function OkFunc (line 11) | func OkFunc() {
type Tlock (line 42) | type Tlock struct
function BadFunc (line 46) | func BadFunc() {
function LenAndCapOnLockArrays (line 105) | func LenAndCapOnLockArrays() {
function SizeofMutex (line 119) | func SizeofMutex() {
function OffsetofMutex (line 130) | func OffsetofMutex() {
function AlignofMutex (line 140) | func AlignofMutex() {
function SyncTypesCheck (line 151) | func SyncTypesCheck() {
function AtomicTypesCheck (line 207) | func AtomicTypesCheck() {
function PointerRhsCheck (line 223) | func PointerRhsCheck() {
FILE: go/analysis/passes/copylock/testdata/src/a/copylock_func.go
function OkFunc (line 17) | func OkFunc(*sync.Mutex) {}
function BadFunc (line 18) | func BadFunc(sync.Mutex) {}
function BadFunc2 (line 19) | func BadFunc2(sync.Map) {}
function OkRet (line 20) | func OkRet() *sync.Mutex {}
function BadRet (line 21) | func BadRet() sync.Mutex {}
type EmbeddedRWMutex (line 29) | type EmbeddedRWMutex struct
method OkMeth (line 33) | func (*EmbeddedRWMutex) OkMeth() {}
method BadMeth (line 34) | func (EmbeddedRWMutex) BadMeth() {}
function OkFunc (line 35) | func OkFunc(e *EmbeddedRWMutex) {}
function BadFunc (line 36) | func BadFunc(EmbeddedRWMutex) {}
function OkRet (line 37) | func OkRet() *EmbeddedRWMutex {}
function BadRet (line 38) | func BadRet() EmbeddedRWMutex {}
type FieldMutex (line 40) | type FieldMutex struct
method OkMeth (line 44) | func (*FieldMutex) OkMeth() {}
method BadMeth (line 45) | func (FieldMutex) BadMeth() {}
function OkFunc (line 46) | func OkFunc(*FieldMutex) {}
function BadFunc (line 47) | func BadFunc(FieldMutex, int) {}
type L0 (line 49) | type L0 struct
method Ok (line 61) | func (*L0) Ok() {}
method Bad (line 62) | func (L0) Bad() {}
type L1 (line 53) | type L1 struct
type L2 (line 57) | type L2 struct
type EmbeddedMutexPointer (line 64) | type EmbeddedMutexPointer struct
method Ok (line 68) | func (*EmbeddedMutexPointer) Ok() {}
method AlsoOk (line 69) | func (EmbeddedMutexPointer) AlsoOk() {}
function StillOk (line 70) | func StillOk(EmbeddedMutexPointer) {}
function LookinGood (line 71) | func LookinGood() EmbeddedMutexPointer {}
type EmbeddedLocker (line 73) | type EmbeddedLocker struct
method Ok (line 77) | func (*EmbeddedLocker) Ok() {}
method AlsoOk (line 78) | func (EmbeddedLocker) AlsoOk() {}
type CustomLock (line 80) | type CustomLock struct
method Lock (line 82) | func (*CustomLock) Lock() {}
method Unlock (line 83) | func (*CustomLock) Unlock() {}
function Ok (line 85) | func Ok(*CustomLock) {}
function Bad (line 86) | func Bad(CustomLock) {}
function FuncCallInterfaceArg (line 89) | func FuncCallInterfaceArg(f func(a int, b interface{})) {
function ReturnViaInterface (line 103) | func ReturnViaInterface(x int) (int, interface{}) {
function AcceptedCases (line 121) | func AcceptedCases() {
FILE: go/analysis/passes/copylock/testdata/src/a/copylock_range.go
function rangeMutex (line 12) | func rangeMutex() {
FILE: go/analysis/passes/copylock/testdata/src/a/issue61678.go
type A (line 11) | type A struct
type B (line 16) | type B struct
function okay (line 22) | func okay(x A) {}
function sure (line 23) | func sure() { var x A; nop(x) }
function what (line 27) | func what(x B) {}
function bad (line 28) | func bad() { var x B; nop(x) }
function good (line 29) | func good() { nop(B{}) }
function stillgood (line 30) | func stillgood() { nop(B{b: B{b: B{b: B{}}}}) }
function nope (line 31) | func nope() { nop(B{}.b) }
function nop (line 33) | func nop(any) {}
FILE: go/analysis/passes/copylock/testdata/src/a/newexpr_go126.go
function _ (line 11) | func _(ptr *sync.Mutex)
FILE: go/analysis/passes/copylock/testdata/src/issue67787/issue67787.go
type T (line 5) | type T struct
type T1 (line 6) | type T1 struct
function NewT1 (line 8) | func NewT1() *T1 { return &T1{T} }
FILE: go/analysis/passes/copylock/testdata/src/typeparams/typeparams.go
type R (line 11) | type R struct
function TestNoRecursion (line 13) | func TestNoRecursion(r R) {}
function TestNoTypeParamRecursion (line 17) | func TestNoTypeParamRecursion[T1 ~[]T2, T2 ~[]T1 | string, T3 ~struct{ F...
function OkFunc1 (line 20) | func OkFunc1[Struct ~*struct{ mu sync.Mutex }](s Struct) {
function BadFunc1 (line 23) | func BadFunc1[Struct ~struct{ mu sync.Mutex }](s Struct) { // want `pass...
function OkFunc2 (line 26) | func OkFunc2[MutexPtr *sync.Mutex](m MutexPtr) {
function BadFunc2 (line 39) | func BadFunc2[Mutex sync.Mutex](m Mutex) { // want `passes lock by value...
function ApproximationError (line 52) | func ApproximationError[Mutex interface {
FILE: go/analysis/passes/copylock/testdata/src/unfortunate/local_go123.go
type LocalOnce (line 16) | type LocalOnce
method Bad (line 18) | func (LocalOnce) Bad() {}
type LocalMutex (line 23) | type LocalMutex
method Bad (line 25) | func (LocalMutex) Bad() {}
FILE: go/analysis/passes/copylock/testdata/src/unfortunate/local_go124.go
type LocalOnce (line 13) | type LocalOnce
method Bad (line 15) | func (LocalOnce) Bad() {}
type LocalMutex (line 17) | type LocalMutex
method Bad (line 19) | func (LocalMutex) Bad() {}
FILE: go/analysis/passes/ctrlflow/ctrlflow.go
type noReturn (line 36) | type noReturn struct
method AFact (line 38) | func (*noReturn) AFact() {}
method String (line 40) | func (*noReturn) String() string { return "noReturn" }
type CFGs (line 44) | type CFGs struct
method NoReturn (line 61) | func (c *CFGs) NoReturn(fn *types.Func) bool {
method FuncDecl (line 84) | func (c *CFGs) FuncDecl(decl *ast.FuncDecl) *cfg.CFG {
method FuncLit (line 93) | func (c *CFGs) FuncLit(lit *ast.FuncLit) *cfg.CFG {
method buildDecl (line 169) | func (c *CFGs) buildDecl(fn *types.Func, di *declInfo) {
method callMayReturn (line 203) | func (c *CFGs) callMayReturn(call *ast.CallExpr) (r bool) {
type declInfo (line 71) | type declInfo struct
type litInfo (line 77) | type litInfo struct
function run (line 97) | func run(pass *analysis.Pass) (any, error) {
function knownIntrinsic (line 242) | func knownIntrinsic(fn *types.Func) (noreturn, known bool) {
FILE: go/analysis/passes/ctrlflow/ctrlflow_test.go
function Test (line 15) | func Test(t *testing.T) {
FILE: go/analysis/passes/ctrlflow/testdata/src/a/a.go
function a (line 22) | func a() { // want a:"noReturn"
function b (line 31) | func b() { // want b:"noReturn"
function f (line 35) | func f(x int) { // no fact here
type T (line 45) | type T
method method1 (line 47) | func (T) method1() { // want method1:"noReturn"
method method2 (line 51) | func (T) method2() { // (may return)
function standardFunctions (line 59) | func standardFunctions(x int) { // want standardFunctions:"noReturn"
function panicRecover (line 97) | func panicRecover() {
function noBody (line 102) | func noBody()
function g (line 104) | func g() {
function h (line 108) | func h() { // want h:"noReturn"
function returns (line 112) | func returns() {
function nobody (line 118) | func nobody()
function hasPanic (line 120) | func hasPanic() { // want hasPanic:"noReturn"
function hasSelect (line 126) | func hasSelect() { // want hasSelect:"noReturn"
function infiniteLoop (line 132) | func infiniteLoop() { // want infiniteLoop:"noReturn"
function ifElse (line 139) | func ifElse(cond bool) { // want ifElse:"noReturn"
function swtch (line 149) | func swtch(x int) { // want swtch:"noReturn"
function _if (line 165) | func _if(cond bool) {
function logFatal (line 173) | func logFatal() { // want logFatal:"noReturn"
function testFatal (line 179) | func testFatal(t *testing.T) { // want testFatal:"noReturn"
function goexit (line 185) | func goexit() { // want goexit:"noReturn"
function osexit (line 191) | func osexit() { // want osexit:"noReturn"
function intrinsic (line 197) | func intrinsic() { // (no fact)
FILE: go/analysis/passes/ctrlflow/testdata/src/lib/lib.go
function CanReturn (line 7) | func CanReturn() {}
function NoReturn (line 9) | func NoReturn() {
FILE: go/analysis/passes/ctrlflow/testdata/src/typeparams/typeparams.go
function a (line 13) | func a[A any]() { // want a:"noReturn"
function b (line 23) | func b[B any]() { // want b:"noReturn"
function c (line 27) | func c[A, B any]() { // want c:"noReturn"
function d (line 35) | func d[A, B any]() { // want d:"noReturn"
type I (line 39) | type I interface
function e (line 43) | func e[T any](i I[T], t T) T {
function k (line 47) | func k[T any](i I[T], t T) T { // want k:"noReturn"
type T (line 52) | type T
method method1 (line 54) | func (T[X]) method1() { // want method1:"noReturn"
method method2 (line 58) | func (T[X]) method2() { // (may return)
FILE: go/analysis/passes/deepequalerrors/deepequalerrors.go
constant Doc (line 20) | Doc = `check for calls of reflect.DeepEqual on error values
function run (line 37) | func run(pass *analysis.Pass) (any, error) {
function hasError (line 61) | func hasError(pass *analysis.Pass, e ast.Expr) bool {
function containsError (line 74) | func containsError(typ types.Type) bool {
FILE: go/analysis/passes/deepequalerrors/deepequalerrors_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/deepequalerrors/testdata/src/a/a.go
type myError (line 15) | type myError
method Error (line 17) | func (myError) Error() string { return "" }
function bad (line 19) | func bad() error { return nil }
type s1 (line 21) | type s1 struct
type myError2 (line 26) | type myError2
type s2 (line 28) | type s2 struct
function hasError (line 33) | func hasError() {
function notHasError (line 50) | func notHasError() {
FILE: go/analysis/passes/deepequalerrors/testdata/src/typeparams/typeparams.go
type myError (line 15) | type myError
method Error (line 17) | func (myError) Error() string { return "" }
function bad (line 19) | func bad[T any]() T {
type s1 (line 24) | type s1 struct
type myError2 (line 29) | type myError2
type s2 (line 31) | type s2 struct
function hasError (line 36) | func hasError() {
function notHasError (line 53) | func notHasError() {
FILE: go/analysis/passes/defers/cmd/defers/main.go
function main (line 13) | func main() { singlechecker.Main(defers.Analyzer) }
FILE: go/analysis/passes/defers/defers.go
function run (line 31) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/defers/defers_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/defers/testdata/src/a/a.go
function Since (line 12) | func Since() (t time.Duration) {
function x (line 16) | func x(time.Duration) {}
function x2 (line 17) | func x2(float64) {}
function good (line 19) | func good() {
type y (line 33) | type y struct
method A (line 35) | func (y) A(float64) {}
method B (line 36) | func (*y) B(float64) {}
method C (line 37) | func (y) C(time.Duration) {}
method D (line 38) | func (*y) D(time.Duration) {}
function bad (line 40) | func bad() {
function ugly (line 55) | func ugly() {
FILE: go/analysis/passes/directive/directive.go
constant Doc (line 20) | Doc = `check Go toolchain directives such as //go:debug
function runDirective (line 43) | func runDirective(pass *analysis.Pass) (any, error) {
function checkGoFile (line 69) | func checkGoFile(pass *analysis.Pass, f *ast.File) {
function checkOtherFile (line 86) | func checkOtherFile(pass *analysis.Pass, filename string) error {
type checker (line 99) | type checker struct
method nonGoFile (line 115) | func (check *checker) nonGoFile(pos token.Pos, fullText string) {
method comment (line 160) | func (check *checker) comment(pos token.Pos, line string) {
function newChecker (line 106) | func newChecker(pass *analysis.Pass, filename string, file *ast.File) *c...
function stringsCutPrefix (line 199) | func stringsCutPrefix(s, prefix string) (after string, found bool) {
FILE: go/analysis/passes/directive/directive_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/errorsas/errorsas.go
constant Doc (line 19) | Doc = `report passing non-pointer or non-error values to errors.As
function run (line 32) | func run(pass *analysis.Pass) (any, error) {
function checkAsTarget (line 61) | func checkAsTarget(info *types.Info, e ast.Expr) error {
FILE: go/analysis/passes/errorsas/errorsas_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/errorsas/main.go
function main (line 16) | func main() { singlechecker.Main(errorsas.Analyzer) }
FILE: go/analysis/passes/errorsas/testdata/src/a/a.go
type myError (line 11) | type myError
method Error (line 13) | func (myError) Error() string { return "" }
function perr (line 15) | func perr() *error { return nil }
type iface (line 17) | type iface interface
function two (line 21) | func two() (error, interface{}) { return nil, nil }
function _ (line 23) | func _() {
FILE: go/analysis/passes/errorsas/testdata/src/typeparams/typeparams.go
type myError (line 11) | type myError struct
method Error (line 13) | func (myError[T]) Error() string { return "" }
type twice (line 15) | type twice struct
function perr (line 19) | func perr[T any]() *T { return nil }
function two (line 21) | func two[T any]() (error, *T) { return nil, nil }
function _ (line 23) | func _[E error](e E) {
FILE: go/analysis/passes/fieldalignment/cmd/fieldalignment/main.go
function main (line 11) | func main() { singlechecker.Main(fieldalignment.Analyzer) }
FILE: go/analysis/passes/fieldalignment/fieldalignment.go
constant Doc (line 24) | Doc = `find structs that would use less memory if their fields were sorted
function run (line 69) | func run(pass *analysis.Pass) (any, error) {
function fieldalignment (line 89) | func fieldalignment(pass *analysis.Pass, node *ast.StructType, typ *type...
function optimalOrder (line 166) | func optimalOrder(str *types.Struct, sizes *gcSizes) (*types.Struct, []i...
type gcSizes (line 245) | type gcSizes struct
method Alignof (line 250) | func (s *gcSizes) Alignof(T types.Type) int64 {
method Sizeof (line 297) | func (s *gcSizes) Sizeof(T types.Type) int64 {
method ptrdata (line 345) | func (s *gcSizes) ptrdata(T types.Type) int64 {
function align (line 340) | func align(x, a int64) int64 {
FILE: go/analysis/passes/fieldalignment/fieldalignment_test.go
function TestTest (line 14) | func TestTest(t *testing.T) {
FILE: go/analysis/passes/fieldalignment/testdata/src/a/a.go
type Good (line 3) | type Good struct
type Bad (line 9) | type Bad struct
type ZeroGood (line 15) | type ZeroGood struct
type ZeroBad (line 20) | type ZeroBad struct
type NoNameGood (line 25) | type NoNameGood struct
type NoNameBad (line 32) | type NoNameBad struct
type WithComments (line 39) | type WithComments struct
FILE: go/analysis/passes/fieldalignment/testdata/src/a/a_386.go
type PointerGood (line 3) | type PointerGood struct
type PointerBad (line 8) | type PointerBad struct
type PointerSorta (line 13) | type PointerSorta struct
type PointerSortaBad (line 24) | type PointerSortaBad struct
type MultiField (line 35) | type MultiField struct
FILE: go/analysis/passes/fieldalignment/testdata/src/a/a_amd64.go
type PointerGood (line 3) | type PointerGood struct
type PointerBad (line 8) | type PointerBad struct
type PointerSorta (line 13) | type PointerSorta struct
type PointerSortaBad (line 24) | type PointerSortaBad struct
type MultiField (line 35) | type MultiField struct
type Issue43233 (line 42) | type Issue43233 struct
FILE: go/analysis/passes/findcall/cmd/findcall/main.go
function main (line 13) | func main() { singlechecker.Main(findcall.Analyzer) }
FILE: go/analysis/passes/findcall/findcall.go
constant Doc (line 21) | Doc = `find calls to a particular function
function init (line 37) | func init() {
function run (line 41) | func run(pass *analysis.Pass) (any, error) {
type foundFact (line 96) | type foundFact struct
method String (line 98) | func (*foundFact) String() string { return "found" }
method AFact (line 99) | func (*foundFact) AFact() {}
FILE: go/analysis/passes/findcall/findcall_test.go
function init (line 14) | func init() {
function TestFromStringLiterals (line 22) | func TestFromStringLiterals(t *testing.T) {
function TestFromFileSystem (line 63) | func TestFromFileSystem(t *testing.T) {
FILE: go/analysis/passes/findcall/testdata/src/a/a.go
function main (line 3) | func main() {
function println (line 8) | func println(s string) {}
FILE: go/analysis/passes/framepointer/framepointer.go
constant Doc (line 19) | Doc = "report assembly that clobbers the frame pointer before saving it"
type arch (line 30) | type arch struct
function hasAnyPrefix (line 38) | func hasAnyPrefix(s string, prefixes ...string) bool {
function run (line 83) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/framepointer/framepointer_test.go
function Test (line 15) | func Test(t *testing.T) {
FILE: go/analysis/passes/gofix/gofix.go
function run (line 29) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/gofix/gofix_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/gofix/testdata/src/a/a.go
constant one (line 9) | one = 1
constant in3 (line 13) | in3 = one
constant in4 (line 14) | in4 = one
constant bad1 (line 15) | bad1 = 1
constant in5 (line 19) | in5,
constant a (line 26) | a = iota
constant b (line 27) | b
constant in7 (line 28) | in7 = one
function shadow (line 31) | func shadow() {
type A (line 44) | type A
FILE: go/analysis/passes/hostport/hostport.go
constant Doc (line 24) | Doc = `check format of addresses passed to net.Dial
function run (line 51) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/hostport/hostport_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/hostport/main.go
function main (line 14) | func main() { singlechecker.Main(hostport.Analyzer) }
FILE: go/analysis/passes/hostport/testdata/src/a/a.go
function direct (line 8) | func direct(host string, port int, portStr string) {
function indirect (line 18) | func indirect(host string, port int) {
function _ (line 50) | func _() {
FILE: go/analysis/passes/httpmux/cmd/httpmux/main.go
function main (line 13) | func main() { singlechecker.Main(httpmux.Analyzer) }
FILE: go/analysis/passes/httpmux/httpmux.go
constant Doc (line 23) | Doc = `report using Go 1.22 enhanced ServeMux patterns in older Go versions
function run (line 41) | func run(pass *analysis.Pass) (any, error) {
function isServeMuxRegisterCall (line 76) | func isServeMuxRegisterCall(pass *analysis.Pass, call *ast.CallExpr) bool {
function isMethodNamed (line 96) | func isMethodNamed(f *types.Func, pkgPath string, names ...string) bool {
function stringConstantExpr (line 113) | func stringConstantExpr(pass *analysis.Pass, expr ast.Expr) (string, boo...
function likelyEnhancedPattern (line 127) | func likelyEnhancedPattern(pat string) bool {
function goVersionAfter121 (line 135) | func goVersionAfter121(goVersion string) bool {
function goVersion (line 143) | func goVersion(pkg *types.Package) string {
function versionFromGoVersion (line 162) | func versionFromGoVersion(goVersion string) string {
FILE: go/analysis/passes/httpmux/httpmux_test.go
function Test (line 13) | func Test(t *testing.T) {
function TestGoVersion (line 20) | func TestGoVersion(t *testing.T) {
FILE: go/analysis/passes/httpmux/testdata/src/a/a.go
function _ (line 11) | func _() {
function Handle (line 41) | func Handle(pat string, x any) {}
function HandleFunc (line 42) | func HandleFunc(pat string, x any) {}
type ServeMux (line 44) | type ServeMux struct
method Handle (line 46) | func (*ServeMux) Handle(pat string, x any) {}
method HandleFunc (line 47) | func (*ServeMux) HandleFunc(pat string, x any) {}
FILE: go/analysis/passes/httpresponse/httpresponse.go
constant Doc (line 19) | Doc = `check for mistakes using HTTP responses
function run (line 43) | func run(pass *analysis.Pass) (any, error) {
function isHTTPFuncOrMethodOnClient (line 108) | func isHTTPFuncOrMethodOnClient(info *types.Info, expr *ast.CallExpr) bo...
function restOfBlock (line 145) | func restOfBlock(stack []ast.Node) ([]ast.Stmt, int) {
function rootIdent (line 165) | func rootIdent(n ast.Node) *ast.Ident {
FILE: go/analysis/passes/httpresponse/httpresponse_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/httpresponse/testdata/src/a/a.go
function goodHTTPGet (line 8) | func goodHTTPGet() {
function badHTTPGet (line 16) | func badHTTPGet() {
function badHTTPHead (line 24) | func badHTTPHead() {
function goodClientGet (line 32) | func goodClientGet() {
function badClientPtrGet (line 41) | func badClientPtrGet() {
function badClientGet (line 50) | func badClientGet() {
function badClientPtrDo (line 59) | func badClientPtrDo() {
function badClientDo (line 73) | func badClientDo() {
function goodUnwrapResp (line 87) | func goodUnwrapResp() {
function badUnwrapResp (line 100) | func badUnwrapResp() {
type i66259 (line 114) | type i66259 struct
method Foo (line 116) | func (_ *i66259) Foo() (*int, int) { return nil, 1 }
function issue66259 (line 118) | func issue66259() {
FILE: go/analysis/passes/httpresponse/testdata/src/typeparams/typeparams.go
function badHTTPGet (line 14) | func badHTTPGet[T any](url string) {
function mkClient (line 22) | func mkClient[T any]() *T {
function badClientHTTPGet (line 26) | func badClientHTTPGet() {
type S (line 33) | type S struct
function unmatchedClientTypeName (line 37) | func unmatchedClientTypeName(client S[string]) {
type C (line 43) | type C interface
function userDefinedClientType (line 47) | func userDefinedClientType(client C[http.Response]) {
FILE: go/analysis/passes/ifaceassert/cmd/ifaceassert/main.go
function main (line 13) | func main() { singlechecker.Main(ifaceassert.Analyzer) }
FILE: go/analysis/passes/ifaceassert/ifaceassert.go
function assertableTo (line 32) | func assertableTo(free *typeparams.Free, v, t types.Type) *types.Func {
function run (line 55) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/ifaceassert/ifaceassert_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/ifaceassert/testdata/src/a/a.go
function InterfaceAssertionTest (line 11) | func InterfaceAssertionTest() {
FILE: go/analysis/passes/ifaceassert/testdata/src/typeparams/typeparams.go
type SourceReader (line 9) | type SourceReader interface
function GenericInterfaceAssertionTest (line 13) | func GenericInterfaceAssertionTest[T io.Reader]() {
type Float (line 39) | type Float interface
type Doer (line 43) | type Doer interface
function Underlying (line 47) | func Underlying[F Float](v Doer[F]) string {
function DoIf (line 58) | func DoIf[F Float]() {
function IsASwitch (line 67) | func IsASwitch[F Float, U Float](v Doer[F]) bool {
function IsA (line 75) | func IsA[F Float, U Float](v Doer[F]) bool {
function LayeredTypes (line 80) | func LayeredTypes[F Float]() {
type X (line 94) | type X struct
method m (line 96) | func (x X[T]) m(T) {}
function InstancesOfGenericMethods (line 98) | func InstancesOfGenericMethods() {
FILE: go/analysis/passes/inline/cmd/inline/main.go
function main (line 28) | func main() { singlechecker.Main(inline.Analyzer) }
FILE: go/analysis/passes/inline/inline.go
function init (line 57) | func init() {
type analyzer (line 65) | type analyzer struct
method HandleFunc (line 93) | func (a *analyzer) HandleFunc(decl *ast.FuncDecl) {
method HandleAlias (line 110) | func (a *analyzer) HandleAlias(spec *ast.TypeSpec) {
method HandleConst (line 124) | func (a *analyzer) HandleConst(nameIdent, rhsIdent *ast.Ident) {
method inline (line 146) | func (a *analyzer) inline() {
method inlineCall (line 164) | func (a *analyzer) inlineCall(call *ast.CallExpr, cur inspector.Cursor) {
method withinTestOf (line 258) | func (a *analyzer) withinTestOf(cur inspector.Cursor, target *types.Fu...
method inlineAlias (line 294) | func (a *analyzer) inlineAlias(tn *types.TypeName, curId inspector.Cur...
method inlineConst (line 479) | func (a *analyzer) inlineConst(con *types.Const, cur inspector.Cursor) {
method reportInline (line 539) | func (a *analyzer) reportInline(kind, capKind string, ident ast.Expr, ...
method readFile (line 557) | func (a *analyzer) readFile(node ast.Node) ([]byte, error) {
function run (line 77) | func run(pass *analysis.Pass) (any, error) {
function typenames (line 409) | func typenames(t types.Type) []*types.TypeName {
type goFixInlineFuncFact (line 573) | type goFixInlineFuncFact struct
method String (line 575) | func (f *goFixInlineFuncFact) String() string { return "goFixInline " ...
method AFact (line 576) | func (*goFixInlineFuncFact) AFact() {}
type goFixInlineConstFact (line 580) | type goFixInlineConstFact struct
method String (line 588) | func (c *goFixInlineConstFact) String() string {
method AFact (line 592) | func (*goFixInlineConstFact) AFact() {}
type goFixInlineAliasFact (line 596) | type goFixInlineAliasFact struct
method String (line 598) | func (c *goFixInlineAliasFact) String() string { return "goFixInline a...
method AFact (line 599) | func (*goFixInlineAliasFact) AFact() {}
function discard (line 601) | func discard(string, ...any) {}
FILE: go/analysis/passes/inline/inline_test.go
function TestAnalyzer (line 23) | func TestAnalyzer(t *testing.T) {
function TestAllowBindingDeclFlag (line 41) | func TestAllowBindingDeclFlag(t *testing.T) {
function TestTypesWithNames (line 56) | func TestTypesWithNames(t *testing.T) {
FILE: go/analysis/passes/inline/issue77844_test.go
function TestIssue77844 (line 13) | func TestIssue77844(t *testing.T) {
FILE: go/analysis/passes/inline/testdata/src/a/a.go
function f (line 7) | func f() {
type T (line 13) | type T struct
method Two (line 21) | func (T) Two() int { return 2 }
function One (line 16) | func One() int { return one }
constant one (line 18) | one = 1
constant Uno (line 25) | Uno = 1
constant In1 (line 28) | In1 = Uno
constant no1 (line 31) | no1 = one
constant In2 (line 34) | In2 = one
constant in3 (line 39) | in3 = one
constant in4 (line 40) | in4 = one
constant bad1 (line 41) | bad1 = 1
constant in5 (line 45) | in5,
constant a (line 54) | a = iota
constant b (line 55) | b
constant in7 (line 56) | in7 = one
function _ (line 59) | func _() {
constant x (line 75) | x = 1
constant in8 (line 77) | in8 = x
constant D (line 81) | D = internal.D
function shadow (line 83) | func shadow() {
function _ (line 150) | func _() {
function _ (line 159) | func _[P any]() {
function _ (line 190) | func _[V any]() {
FILE: go/analysis/passes/inline/testdata/src/a/internal/d.go
constant D (line 5) | D = 1
type T (line 7) | type T
FILE: go/analysis/passes/inline/testdata/src/b/b.go
function f (line 6) | func f() {
constant in2 (line 13) | in2 = a.Uno
constant in3 (line 16) | in3 = C
function g (line 18) | func g() {
constant d (line 32) | d = a.D
FILE: go/analysis/passes/inline/testdata/src/binding_false/a.go
function f (line 4) | func f(x, y int) int { // want f:`goFixInline a.f`
function g (line 8) | func g() {
function h (line 14) | func h(int) int
FILE: go/analysis/passes/inline/testdata/src/binding_true/a.go
function f (line 4) | func f(x, y int) int { // want f:`goFixInline a.f`
function g (line 8) | func g() {
function h (line 14) | func h(int) int
FILE: go/analysis/passes/inline/testdata/src/c/c.go
constant C (line 7) | C = 1
FILE: go/analysis/passes/inline/testdata/src/directive/directive.go
function f (line 5) | func f() {
type T (line 11) | type T struct
method Two (line 19) | func (T) Two() int { return 2 }
function One (line 14) | func One() int { return one }
constant one (line 16) | one = 1
constant Uno (line 23) | Uno = 1
constant In1 (line 26) | In1 = Uno
constant no1 (line 29) | no1 = one
constant In2 (line 32) | In2 = one
constant bad1 (line 36) | bad1 = 1
constant in5 (line 39) | in5,
constant a (line 48) | a = iota
constant b (line 49) | b
constant in7 (line 50) | in7 = one
constant x (line 54) | x = 1
constant in8 (line 56) | in8 = x
constant in9 (line 60) | in9 = iota
FILE: go/analysis/passes/inline/testdata/src/rmimport/rmimport.go
function _ (line 8) | func _() {
FILE: go/analysis/passes/inspect/inspect.go
function run (line 47) | func run(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/internal/gofixdirective/gofixdirective.go
type Handler (line 27) | type Handler interface
function Find (line 36) | func Find(pass *analysis.Pass, root inspector.Cursor, h Handler) {
function findFunc (line 61) | func findFunc(decl *ast.FuncDecl, h Handler) {
function findAlias (line 70) | func findAlias(pass *analysis.Pass, spec *ast.TypeSpec, declInline bool,...
function findConst (line 102) | func findConst(pass *analysis.Pass, spec *ast.ValueSpec, declInline bool...
function hasFixInline (line 134) | func hasFixInline(cg *ast.CommentGroup) bool {
FILE: go/analysis/passes/loopclosure/loopclosure.go
function run (line 32) | func run(pass *analysis.Pass) (any, error) {
function reportCaptured (line 136) | func reportCaptured(pass *analysis.Pass, vars []types.Object, checkStmt ...
function forEachLastStmt (line 159) | func forEachLastStmt(stmts []ast.Stmt, onLast func(last ast.Stmt)) {
function litStmts (line 208) | func litStmts(fun ast.Expr) []ast.Stmt {
function goInvoke (line 225) | func goInvoke(info *types.Info, call *ast.CallExpr) ast.Expr {
function parallelSubtest (line 258) | func parallelSubtest(info *types.Info, call *ast.CallExpr) []ast.Stmt {
function unlabel (line 337) | func unlabel(stmt ast.Stmt) (ast.Stmt, bool) {
function isMethodCall (line 349) | func isMethodCall(info *types.Info, call *ast.CallExpr, pkgPath, typeNam...
FILE: go/analysis/passes/loopclosure/loopclosure_test.go
function TestVersions (line 16) | func TestVersions(t *testing.T) {
FILE: go/analysis/passes/loopclosure/testdata/src/a/a.go
function _ (line 18) | func _() {
function _ (line 115) | func _() {
type Group (line 180) | type Group struct
method Go (line 182) | func (g *Group) Go(func() error) {}
function _ (line 184) | func _() {
function _ (line 222) | func _() {
FILE: go/analysis/passes/loopclosure/testdata/src/golang.org/x/sync/errgroup/errgroup.go
type Group (line 5) | type Group struct
method Go (line 8) | func (g *Group) Go(f func() error) {
FILE: go/analysis/passes/loopclosure/testdata/src/subtests/subtest.go
type T (line 17) | type T struct
method Run (line 22) | func (t *T) Run(string, func(*testing.T)) {
method Parallel (line 25) | func (t *T) Parallel() {}
function _ (line 27) | func _(t *testing.T) {
function _ (line 153) | func _(t *testing.T) {
function _ (line 166) | func _(t *T) {
function _ (line 182) | func _(t *testing.T) {
FILE: go/analysis/passes/loopclosure/testdata/src/typeparams/typeparams.go
function f (line 14) | func f[T any](data T) {
function _ (line 18) | func _[T any]() {
function loop (line 28) | func loop[P interface{ Go(func() error) }](grp P) {
function _ (line 40) | func _() {
type T (line 45) | type T struct
method Go (line 49) | func (t T[P]) Go(func() error) {}
function _ (line 51) | func _(g T[errgroup.Group]) {
FILE: go/analysis/passes/lostcancel/cmd/lostcancel/main.go
function main (line 14) | func main() { singlechecker.Main(lostcancel.Analyzer) }
FILE: go/analysis/passes/lostcancel/lostcancel.go
constant debug (line 36) | debug = false
function run (line 50) | func run(pass *analysis.Pass) (any, error) {
function runFunc (line 68) | func runFunc(pass *analysis.Pass, node ast.Node) {
function isCall (line 184) | func isCall(n ast.Node) bool { _, ok := n.(*ast.CallExpr); return ok }
function isContextWithCancel (line 188) | func isContextWithCancel(info *types.Info, n ast.Node) bool {
function lostCancelPath (line 215) | func lostCancelPath(pass *analysis.Pass, g *cfg.CFG, v *types.Var, stmt ...
function tupleContains (line 317) | func tupleContains(tuple *types.Tuple, v *types.Var) bool {
FILE: go/analysis/passes/lostcancel/lostcancel_test.go
function Test (line 14) | func Test(t *testing.T) {
FILE: go/analysis/passes/lostcancel/testdata/src/a/a.go
function _ (line 19) | func _() {
function _ (line 26) | func _() {
function _ (line 33) | func _() {
function _ (line 41) | func _() {
function _ (line 48) | func _() {
function _ (line 53) | func _() {
function _ (line 61) | func _() {
function _ (line 73) | func _() {
function _ (line 84) | func _() {
function _ (line 102) | func _() {
function _ (line 118) | func _(ch chan int) {
function _ (line 132) | func _(ch chan int) {
function _ (line 144) | func _() {
function _ (line 158) | func _() {
function _ (line 164) | func _() (ctx context.Context, cancel func()) {
function _ (line 176) | func _() {
function _ (line 189) | func _() {
FILE: go/analysis/passes/lostcancel/testdata/src/b/b.go
function main (line 11) | func main() {
function notMain (line 18) | func notMain() {
FILE: go/analysis/passes/lostcancel/testdata/src/typeparams/typeparams.go
function _ (line 21) | func _[T any]() {
function _ (line 28) | func _[T any]() {
type C1 (line 34) | type C1 interface
function _ (line 41) | func _(bg C1[bool, interface{}]) {
type C2 (line 48) | type C2 interface
function _ (line 52) | func _(c C2[interface{}]) {
function _ (line 58) | func _() {
function withCancelCause (line 64) | func withCancelCause(maybe bool) {
FILE: go/analysis/passes/modernize/any.go
function runAny (line 25) | func runAny(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/atomictypes.go
function init (line 40) | func init() {
function runAtomic (line 67) | func runAtomic(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/bloop.go
function bloop (line 46) | func bloop(pass *analysis.Pass) (any, error) {
function uses (line 164) | func uses(index *typeindex.Index, cur inspector.Cursor, obj types.Object...
function enclosingFunc (line 175) | func enclosingFunc(c inspector.Cursor) (inspector.Cursor, bool) {
function usesBenchmarkNOnce (line 189) | func usesBenchmarkNOnce(c inspector.Cursor, info *types.Info) bool {
function isBenchmarkFunc (line 222) | func isBenchmarkFunc(f *ast.FuncDecl) bool {
function isIncrementLoop (line 233) | func isIncrementLoop(info *types.Info, loop *ast.ForStmt) *types.Var {
FILE: go/analysis/passes/modernize/cmd/modernize/main.go
function main (line 16) | func main() { multichecker.Main(modernize.Suite...) }
FILE: go/analysis/passes/modernize/errorsastype.go
function init (line 35) | func init() {
function errorsastype (line 80) | func errorsastype(pass *analysis.Pass) (any, error) {
function canUseErrorsAsType (line 180) | func canUseErrorsAsType(info *types.Info, index *typeindex.Index, curCal...
FILE: go/analysis/passes/modernize/fmtappendf.go
function fmtappendf (line 38) | func fmtappendf(pass *analysis.Pass) (any, error) {
function mayFormatEmpty (line 131) | func mayFormatEmpty(formatStr string) bool {
FILE: go/analysis/passes/modernize/forvar.go
function forvar (line 54) | func forvar(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/maps.go
function mapsloop (line 54) | func mapsloop(pass *analysis.Pass) (any, error) {
function assignableToIterSeq2 (line 274) | func assignableToIterSeq2(t types.Type) (k, v types.Type, ok bool) {
FILE: go/analysis/passes/modernize/minmax.go
function minmax (line 57) | func minmax(pass *analysis.Pass) (any, error) {
function allComments (line 245) | func allComments(file *ast.File, start, end token.Pos) string {
function isInequality (line 255) | func isInequality(tok token.Token) int {
function isAssignBlock (line 266) | func isAssignBlock(b *ast.BlockStmt) bool {
function isSimpleAssign (line 275) | func isSimpleAssign(n ast.Node) bool {
function maybeNaN (line 284) | func maybeNaN(t types.Type) bool {
function checkUserDefinedMinMax (line 300) | func checkUserDefinedMinMax(pass *analysis.Pass) {
function canUseBuiltinMinMax (line 339) | func canUseBuiltinMinMax(fn *types.Func, body *ast.BlockStmt) bool {
function hasMinMaxLogic (line 368) | func hasMinMaxLogic(body *ast.BlockStmt, funcName string) bool {
function checkMinMaxPattern (line 397) | func checkMinMaxPattern(ifStmt *ast.IfStmt, falseResult ast.Expr, funcNa...
function is (line 440) | func is[T any](x any) bool {
function cond (line 445) | func cond[T any](cond bool, t, f T) T {
FILE: go/analysis/passes/modernize/modernize.go
function formatExprs (line 66) | func formatExprs(fset *token.FileSet, exprs []ast.Expr) string {
function isZeroIntConst (line 78) | func isZeroIntConst(info *types.Info, e ast.Expr) bool {
function isIntLiteral (line 83) | func isIntLiteral(info *types.Info, e ast.Expr, n int64) bool {
function filesUsingGoVersion (line 96) | func filesUsingGoVersion(pass *analysis.Pass, version string) iter.Seq[i...
function within (line 111) | func within(pass *analysis.Pass, pkgs ...string) bool {
function unparenEnclosing (line 119) | func unparenEnclosing(cur inspector.Cursor) inspector.Cursor {
function lookup (line 143) | func lookup(info *types.Info, cur inspector.Cursor, name string) types.O...
function first (line 149) | func first[T any](x T, _ any) T { return x }
function freshName (line 159) | func freshName(info *types.Info, index *typeindex.Index, scope *types.Sc...
function isLocal (line 176) | func isLocal(obj types.Object) bool {
FILE: go/analysis/passes/modernize/modernize_test.go
function TestAppendClipped (line 16) | func TestAppendClipped(t *testing.T) {
function TestAtomicTypes (line 20) | func TestAtomicTypes(t *testing.T) {
function TestBloop (line 23) | func TestBloop(t *testing.T) {
function TestAny (line 27) | func TestAny(t *testing.T) {
function TestErrorsAsType (line 32) | func TestErrorsAsType(t *testing.T) {
function TestFmtAppendf (line 36) | func TestFmtAppendf(t *testing.T) {
function TestForVar (line 40) | func TestForVar(t *testing.T) {
function TestStdIterators (line 44) | func TestStdIterators(t *testing.T) {
function TestMapsLoop (line 48) | func TestMapsLoop(t *testing.T) {
function TestMinMax (line 52) | func TestMinMax(t *testing.T) {
function TestNewExpr (line 56) | func TestNewExpr(t *testing.T) {
function TestOmitZero (line 60) | func TestOmitZero(t *testing.T) {
function TestRangeInt (line 64) | func TestRangeInt(t *testing.T) {
function TestPlusBuild (line 68) | func TestPlusBuild(t *testing.T) {
function TestReflectTypeFor (line 85) | func TestReflectTypeFor(t *testing.T) {
function TestSlicesContains (line 90) | func TestSlicesContains(t *testing.T) {
function TestSlicesDelete (line 94) | func TestSlicesDelete(t *testing.T) {
function TestSlicesSort (line 98) | func TestSlicesSort(t *testing.T) {
function TestStringsBuilder (line 102) | func TestStringsBuilder(t *testing.T) {
function TestStringsCut (line 106) | func TestStringsCut(t *testing.T) {
function TestStringsCutPrefix (line 110) | func TestStringsCutPrefix(t *testing.T) {
function TestStringsSeq (line 116) | func TestStringsSeq(t *testing.T) {
function TestTestingContext (line 120) | func TestTestingContext(t *testing.T) {
function TestUnsafeFuncs (line 124) | func TestUnsafeFuncs(t *testing.T) {
function TestWaitGroupGo (line 128) | func TestWaitGroupGo(t *testing.T) {
FILE: go/analysis/passes/modernize/newexpr.go
function run (line 33) | func run(pass *analysis.Pass) (any, error) {
type newLike (line 200) | type newLike struct
method AFact (line 202) | func (*newLike) AFact() {}
method String (line 203) | func (*newLike) String() string { return "newlike" }
FILE: go/analysis/passes/modernize/omitzero.go
function omitzero (line 34) | func omitzero(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/plusbuild.go
function init (line 25) | func init() {
function plusbuild (line 30) | func plusbuild(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/rangeint.go
function rangeint (line 67) | func rangeint(pass *analysis.Pass) (any, error) {
function isScalarLvalue (line 322) | func isScalarLvalue(info *types.Info, curId inspector.Cursor) bool {
function enclosingSignature (line 366) | func enclosingSignature(cur inspector.Cursor, info *types.Info) *types.S...
FILE: go/analysis/passes/modernize/reflect.go
function reflecttypefor (line 37) | func reflecttypefor(pass *analysis.Pass) (any, error) {
function isComplicatedType (line 168) | func isComplicatedType(t types.Type) bool {
FILE: go/analysis/passes/modernize/slices.go
function appendclipped (line 57) | func appendclipped(pass *analysis.Pass) (any, error) {
function clippedSlice (line 255) | func clippedSlice(info *types.Info, e ast.Expr) (res ast.Expr, empty boo...
FILE: go/analysis/passes/modernize/slicescontains.go
function slicescontains (line 67) | func slicescontains(pass *analysis.Pass) (any, error) {
function isReturnTrueOrFalse (line 427) | func isReturnTrueOrFalse(info *types.Info, stmt ast.Stmt) int {
function isTrueOrFalse (line 435) | func isTrueOrFalse(info *types.Info, expr ast.Expr) int {
FILE: go/analysis/passes/modernize/slicesdelete.go
function slicesdelete (line 35) | func slicesdelete(pass *analysis.Pass) (any, error) {
function increasingSliceIndices (line 154) | func increasingSliceIndices(info *types.Info, a, b ast.Expr) bool {
FILE: go/analysis/passes/modernize/sortslice.go
function slicessort (line 53) | func slicessort(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/stditerators.go
function init (line 35) | func init() {
function stditerators (line 107) | func stditerators(pass *analysis.Pass) (any, error) {
function methodGoVersion (line 382) | func methodGoVersion(pkgpath, recvtype, method string) (stdlib.Version, ...
FILE: go/analysis/passes/modernize/stringsbuilder.go
function stringsbuilder (line 40) | func stringsbuilder(pass *analysis.Pass) (any, error) {
function isEmptyString (line 378) | func isEmptyString(info *types.Info, e ast.Expr) bool {
FILE: go/analysis/passes/modernize/stringscut.go
function init (line 42) | func init() {
function stringscut (line 116) | func stringscut(pass *analysis.Pass) (any, error) {
function indexArgValid (line 377) | func indexArgValid(info *types.Info, index *typeindex.Index, expr ast.Ex...
function checkIdxUses (line 426) | func checkIdxUses(info *types.Info, uses iter.Seq[inspector.Cursor], s, ...
function hasModifyingUses (line 490) | func hasModifyingUses(info *types.Info, uses iter.Seq[inspector.Cursor],...
function checkIdxComparison (line 522) | func checkIdxComparison(info *types.Info, check *ast.BinaryExpr, iObj ty...
function flip (line 558) | func flip(op token.Token) token.Token {
function isBeforeSlice (line 575) | func isBeforeSlice(info *types.Info, ek edge.Kind, slice *ast.SliceExpr)...
function constSubstrLen (line 580) | func constSubstrLen(info *types.Info, substr ast.Expr) int {
function isAfterSlice (line 606) | func isAfterSlice(info *types.Info, ek edge.Kind, slice *ast.SliceExpr, ...
function isSliceIndexGuarded (line 661) | func isSliceIndexGuarded(info *types.Info, cur inspector.Cursor, iObj ty...
function condChecksIdx (line 694) | func condChecksIdx(info *types.Info, cond ast.Expr, iObj types.Object) i...
function bodyTerminates (line 704) | func bodyTerminates(block *ast.BlockStmt) bool {
function sameObject (line 717) | func sameObject(info *types.Info, expr1, expr2 ast.Expr) bool {
FILE: go/analysis/passes/modernize/stringscutprefix.go
function stringscutprefix (line 56) | func stringscutprefix(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/stringsseq.go
function stringsseq (line 48) | func stringsseq(pass *analysis.Pass) (any, error) {
FILE: go/analysis/passes/modernize/testdata/src/any/any.go
function _ (line 3) | func _(x interface{}) {}
function _ (line 5) | func _() {
FILE: go/analysis/passes/modernize/testdata/src/any/generated.go
function _ (line 5) | func _(x interface{}) {}
function _ (line 7) | func _() {
FILE: go/analysis/passes/modernize/testdata/src/appendclipped/appendclipped.go
type Bytes (line 9) | type Bytes
type Bytes2 (line 10) | type Bytes2
function _ (line 13) | func _(s, other []string) {
FILE: go/analysis/passes/modernize/testdata/src/appendclipped/bytesclone.go
function _ (line 9) | func _(b []byte) {
FILE: go/analysis/passes/modernize/testdata/src/atomictypes/atomic.go
type X (line 8) | type X struct
type Z (line 12) | type Z struct
method fix (line 17) | func (wrapper *Z) fix() {
type Y (line 43) | type Y
method dontfix (line 45) | func (y Y) dontfix(x int32) (result int32) {
FILE: go/analysis/passes/modernize/testdata/src/atomictypes/atomic_shadow.go
function _ (line 5) | func _() {
FILE: go/analysis/passes/modernize/testdata/src/atomictypes/go118/atomic_go118.go
function _ (line 7) | func _() {
FILE: go/analysis/passes/modernize/testdata/src/atomictypes/go120/atomic_go120.go
function _ (line 7) | func _() {
FILE: go/analysis/passes/modernize/testdata/src/atomictypes/ignored/atomic.go
function _ (line 9) | func _() {
FILE: go/analysis/passes/modernize/testdata/src/atomictypes/ignored/atomic_ignored.go
function _ (line 7) | func _() {
FILE: go/analysis/passes/modernize/testdata/src/bloop/bloop_test.go
function BenchmarkA (line 10) | func BenchmarkA(b *testing.B) {
function BenchmarkB (line 18) | func BenchmarkB(b *testing.B) {
function BenchmarkC (line 34) | func BenchmarkC(b *testing.B) {
function BenchmarkD (line 50) | func BenchmarkD(b *testing.B) {
function BenchmarkE (line 56) | func BenchmarkE(b *testing.B) {
function BenchmarkF (line 74) | func BenchmarkF(b *testing.B) {
function BenchmarkG (line 85) | func BenchmarkG(b *testing.B) {
function BenchmarkH (line 99) | func BenchmarkH(b *testing.B) {
function BenchmarkI (line 110) | func BenchmarkI(b *testing.B) {
function BenchmarkJ (line 117) | func BenchmarkJ(b *testing.B) {
FILE: go/analysis/passes/modernize/testdata/src/errorsastype/dotimport/a.go
function _ (line 8) | func _(err error) {
FILE: go/analysis/passe
Copy disabled (too large)
Download .json
Condensed preview — 2761 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (15,801K chars).
[
{
"path": ".gitattributes",
"chars": 345,
"preview": "# Treat all files in this repo as binary, with no git magic updating\n# line endings. Windows users contributing to Go wi"
},
{
"path": ".gitignore",
"chars": 85,
"preview": "# Add no patterns to .gitignore except for files generated by the build.\nlast-change\n"
},
{
"path": ".prettierrc",
"chars": 51,
"preview": "{\n \"singleQuote\": true,\n \"trailingComma\": \"es5\"\n}"
},
{
"path": "CONTRIBUTING.md",
"chars": 913,
"preview": "# Contributing to Go\n\nGo is an open source project.\n\nIt is the work of hundreds of contributors. We appreciate your help"
},
{
"path": "LICENSE",
"chars": 1453,
"preview": "Copyright 2009 The Go Authors.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are per"
},
{
"path": "PATENTS",
"chars": 1303,
"preview": "Additional IP Rights Grant (Patents)\n\n\"This implementation\" means the copyrightable works distributed by\nGoogle as part "
},
{
"path": "README.md",
"chars": 3422,
"preview": "# Go Tools\n\n[](https://pkg.go.dev/golang.org/x/tools)\n\nThis repo"
},
{
"path": "benchmark/parse/parse.go",
"chars": 3467,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "benchmark/parse/parse_test.go",
"chars": 5228,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "blog/atom/atom.go",
"chars": 1575,
"preview": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "blog/blog.go",
"chars": 12518,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "blog/blog_test.go",
"chars": 1980,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/benchcmp/benchcmp.go",
"chars": 4296,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/benchcmp/benchcmp_test.go",
"chars": 1790,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/benchcmp/compare.go",
"chars": 5361,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/benchcmp/compare_test.go",
"chars": 4826,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/benchcmp/doc.go",
"chars": 1251,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/bisect/go120.go",
"chars": 609,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/bisect/main.go",
"chars": 24402,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/bisect/main_test.go",
"chars": 4263,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/bisect/testdata/README.md",
"chars": 1232,
"preview": "This directory contains test inputs for the bisect command.\n\nEach text file is a txtar archive (see <https://pkg.go.dev/"
},
{
"path": "cmd/bisect/testdata/basic.txt",
"chars": 1802,
"preview": "{\"Fail\": \"amber || apricot\"}\n-- stdout --\n--- change set #1 (enabling changes causes failure)\namber\n---\n--- change set #"
},
{
"path": "cmd/bisect/testdata/count2.txt",
"chars": 2885,
"preview": "{\"Fail\": \"amber || apricot\", \"Bisect\": {\"Count\": 2}}\n-- stdout --\n--- change set #1 (enabling changes causes failure)\nam"
},
{
"path": "cmd/bisect/testdata/double.txt",
"chars": 2469,
"preview": "{\"Fail\": \"amber || apricot && peach\"}\n-- stdout --\n--- change set #1 (enabling changes causes failure)\namber\n---\n--- cha"
},
{
"path": "cmd/bisect/testdata/max1.txt",
"chars": 928,
"preview": "{\"Fail\": \"amber || apricot && peach\", \"Bisect\": {\"Max\": 1}}\n-- stdout --\n--- change set #1 (enabling changes causes fail"
},
{
"path": "cmd/bisect/testdata/max2.txt",
"chars": 2707,
"preview": "{\"Fail\": \"amber || apricot && peach || red && green && blue || cyan && magenta && yellow && black\", \"Bisect\": {\"Max\": 2}"
},
{
"path": "cmd/bisect/testdata/maxset.txt",
"chars": 4387,
"preview": "{\"Fail\": \"amber || apricot && peach || red && green && blue || cyan && magenta && yellow && black\", \"Bisect\": {\"MaxSet\":"
},
{
"path": "cmd/bisect/testdata/maxset1.txt",
"chars": 557,
"preview": "{\"Fail\": \"apricot && peach\", \"Bisect\": {\"MaxSet\": 1}}\n-- stdout --\n-- stderr --\nbisect: checking target with all changes"
},
{
"path": "cmd/bisect/testdata/maxset4.txt",
"chars": 7900,
"preview": "{\"Fail\": \"amber || apricot && peach || red && green && blue || cyan && magenta && yellow && black\", \"Bisect\": {\"MaxSet\":"
},
{
"path": "cmd/bisect/testdata/negate.txt",
"chars": 2509,
"preview": "{\"Fail\": \"!amber || !apricot && !peach\"}\n-- stdout --\n--- change set #1 (disabling changes causes failure)\namber\n---\n---"
},
{
"path": "cmd/bisect/testdata/rand.txt",
"chars": 2608,
"preview": "{\"Fail\": \"amber || apricot || blue && random\"}\n-- stdout --\n--- change set #1 (enabling changes causes failure)\namber\n--"
},
{
"path": "cmd/bisect/testdata/rand1.txt",
"chars": 1021,
"preview": "{\"Fail\": \"blue && random\"}\n-- stdout --\n-- stderr --\nbisect: checking target with all changes disabled\nbisect: run: test"
},
{
"path": "cmd/bisect/testdata/rand2.txt",
"chars": 782,
"preview": "{\"Fail\": \"blue && random\", \"Bisect\": {\"Count\": 2}}\n-- stdout --\n-- stderr --\nbisect: checking target with all changes di"
},
{
"path": "cmd/bundle/.gitignore",
"chars": 17,
"preview": "testdata/out.got\n"
},
{
"path": "cmd/bundle/main.go",
"chars": 13646,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/bundle/main_test.go",
"chars": 1844,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/bundle/testdata/out.golden",
"chars": 835,
"preview": "//go:build tag\n\n// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.\n// $ bundle\n\n// The package doc comme"
},
{
"path": "cmd/bundle/testdata/src/domain.name/importdecl/p.go",
"chars": 46,
"preview": "package importdecl\n\nfunc F() int { return 1 }\n"
},
{
"path": "cmd/bundle/testdata/src/initial/a.go",
"chars": 357,
"preview": "package initial\n\nimport \"fmt\" // this comment should not be visible\n\n// init functions are not renamed\nfunc init() { foo"
},
{
"path": "cmd/bundle/testdata/src/initial/b.go",
"chars": 250,
"preview": "// The package doc comment\npackage initial\n\nimport (\n\t\"fmt\"\n\n\t\"domain.name/importdecl\"\n)\n\ntype t int // type1\n\n// const1"
},
{
"path": "cmd/bundle/testdata/src/initial/c.go",
"chars": 168,
"preview": "package initial\n\nimport _ \"fmt\"\nimport renamedfmt \"fmt\"\nimport renamedfmt2 \"fmt\"\nimport . \"fmt\"\n\nfunc baz() {\n\trenamedfm"
},
{
"path": "cmd/callgraph/main.go",
"chars": 9469,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/callgraph/main_test.go",
"chars": 2371,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/callgraph/testdata/src/pkg/pkg.go",
"chars": 221,
"preview": "package main\n\ntype I interface {\n\tf()\n}\n\ntype C int\n\nfunc (C) f() {}\n\ntype D int\n\nfunc (D) f() {}\n\nfunc main() {\n\tvar i "
},
{
"path": "cmd/callgraph/testdata/src/pkg/pkg_test.go",
"chars": 191,
"preview": "package main\n\n// An Example function must have an \"Output:\" comment for the go build\n// system to generate a call to it "
},
{
"path": "cmd/compilebench/main.go",
"chars": 19941,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/deadcode/deadcode.go",
"chars": 17911,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/deadcode/deadcode_test.go",
"chars": 4525,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/deadcode/doc.go",
"chars": 6399,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/deadcode/testdata/basic.txtar",
"chars": 557,
"preview": "# Test of basic functionality.\n\n deadcode -filter= example.com\n\n want \"T.Goodbye\"\n want \"T.Goodbye2\"\n want \"T.Goodbye3\"\n"
},
{
"path": "cmd/deadcode/testdata/filterflag.txtar",
"chars": 485,
"preview": "# Test of -filter flag.\n\n deadcode -filter=other.net example.com\n\n want `other.net`\n want `Dead`\n!want `Live`\n\n!want `ex"
},
{
"path": "cmd/deadcode/testdata/generated.txtar",
"chars": 486,
"preview": "# Test of -generated flag output.\n\n deadcode \"-f={{range .Funcs}}{{$.Name}}.{{.Name}}{{end}}\" example.com\n!want \"main.ma"
},
{
"path": "cmd/deadcode/testdata/issue65915.txtar",
"chars": 847,
"preview": "# Regression test for issue 65915: the enumeration of source-level\n# functions used the flawed ssautil.AllFunctions, cau"
},
{
"path": "cmd/deadcode/testdata/issue67915.txt",
"chars": 735,
"preview": "# Test of -whylive with reflective call\n# (regression test for golang/go#67915).\n\n# The live function is reached via ref"
},
{
"path": "cmd/deadcode/testdata/issue73652.txtar",
"chars": 469,
"preview": "# Test deadcode usage under go.work.\n\n deadcode ./svc/... ./lib/...\n want \"unreachable func: A\"\n\n# different order of pa"
},
{
"path": "cmd/deadcode/testdata/jsonflag.txtar",
"chars": 331,
"preview": "# Very minimal test of -json flag.\n\ndeadcode -json example.com/p\n\n want `\"Path\": \"example.com/p\",`\n want `\"Name\": \"DeadF"
},
{
"path": "cmd/deadcode/testdata/lineflag.txtar",
"chars": 563,
"preview": "# Test of line-oriented output.\n\n deadcode `-f={{range .Funcs}}{{printf \"%s: %s.%s\\n\" .Position $.Path .Name}}{{end}}` -"
},
{
"path": "cmd/deadcode/testdata/marker.txtar",
"chars": 883,
"preview": "# Test of marker suppression functionality.\n# Deadcode should not identify marker interface methods as unreachable\n\n dea"
},
{
"path": "cmd/deadcode/testdata/testflag.txtar",
"chars": 539,
"preview": "# Test of -test flag.\n\ndeadcode -test -filter=example.com example.com/p\n\n want \"Dead\"\n!want \"Live1\"\n!want \"Live2\"\n\n want"
},
{
"path": "cmd/deadcode/testdata/whylive.txtar",
"chars": 2723,
"preview": "# Test of -whylive flag.\n\n# The -whylive argument must be live.\n\n!deadcode -whylive=example.com.d example.com\n want \"fun"
},
{
"path": "cmd/digraph/digraph.go",
"chars": 13178,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/digraph/digraph_test.go",
"chars": 9743,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/digraph/doc.go",
"chars": 3092,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/eg/eg.go",
"chars": 5475,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/file2fuzz/main.go",
"chars": 3425,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/file2fuzz/main_test.go",
"chars": 4847,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/fiximports/main.go",
"chars": 15174,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/fiximports/main_test.go",
"chars": 7261,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/fiximports/testdata/src/fruit.io/banana/banana.go",
"chars": 86,
"preview": "package banana\n\nimport (\n\t_ \"old.com/one\"\n\t_ \"titanic.biz/bar\"\n\t_ \"titanic.biz/foo\"\n)\n"
},
{
"path": "cmd/fiximports/testdata/src/fruit.io/orange/orange.go",
"chars": 41,
"preview": "package orange\n\nimport _ \"fruit.io/pear\"\n"
},
{
"path": "cmd/fiximports/testdata/src/fruit.io/pear/pear.go",
"chars": 41,
"preview": "package pear\n\nimport _ \"fruit.io/banana\"\n"
},
{
"path": "cmd/fiximports/testdata/src/new.com/one/one.go",
"chars": 36,
"preview": "package one // import \"new.com/one\"\n"
},
{
"path": "cmd/fiximports/testdata/src/old.com/bad/bad.go",
"chars": 113,
"preview": "// This ill-formed Go source file is here to ensure the tool is robust\n// against bad packages in the workspace.\n"
},
{
"path": "cmd/fiximports/testdata/src/old.com/one/one.go",
"chars": 36,
"preview": "package one // import \"new.com/one\"\n"
},
{
"path": "cmd/fiximports/testdata/src/titanic.biz/bar/bar.go",
"chars": 78,
"preview": "// This package is moving to new.com too.\npackage bar // import \"new.com/bar\"\n"
},
{
"path": "cmd/fiximports/testdata/src/titanic.biz/foo/foo.go",
"chars": 52,
"preview": "// This package hasn't jumped ship yet.\npackage foo\n"
},
{
"path": "cmd/go-contrib-init/contrib.go",
"chars": 6950,
"preview": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/go-contrib-init/contrib_test.go",
"chars": 1262,
"preview": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/doc.go",
"chars": 2472,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/gc.go",
"chars": 359,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/gccgo.go",
"chars": 886,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/godex.go",
"chars": 5283,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/isAlias18.go",
"chars": 312,
"preview": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/isAlias19.go",
"chars": 276,
"preview": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/print.go",
"chars": 9197,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/source.go",
"chars": 432,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/godex/writetype.go",
"chars": 5917,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goimports/doc.go",
"chars": 1580,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goimports/goimports.go",
"chars": 9974,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goimports/goimports_gc.go",
"chars": 484,
"preview": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goimports/goimports_not_gc.go",
"chars": 234,
"preview": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/gomvpkg/main.go",
"chars": 2951,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/gonew/main.go",
"chars": 6324,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/gonew/main_test.go",
"chars": 5890,
"preview": "// Copyright 2023 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/gonew/testdata/quote.txt",
"chars": 548,
"preview": "gonew example.com/quote my.com/test\n\n-- example.com/quote@v1.5.2/go.mod --\nmodule example.com/quote\n-- example.com/quote"
},
{
"path": "cmd/gotype/gotype.go",
"chars": 8516,
"preview": "// Copyright 2011 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/gotype/sizesFor18.go",
"chars": 836,
"preview": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/gotype/sizesFor19.go",
"chars": 337,
"preview": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goyacc/doc.go",
"chars": 2459,
"preview": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goyacc/testdata/expr/README",
"chars": 445,
"preview": "This directory contains a simple program demonstrating how to use\nthe Go version of yacc.\n\nTo build it:\n\n\t$ go generate\n"
},
{
"path": "cmd/goyacc/testdata/expr/expr.y",
"chars": 3222,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goyacc/testdata/expr/main.go",
"chars": 471,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/goyacc/yacc.go",
"chars": 71463,
"preview": "/*\nDerived from Inferno's utils/iyacc/yacc.c\nhttp://code.google.com/p/inferno-os/source/browse/utils/iyacc/yacc.c\n\nThis "
},
{
"path": "cmd/html2article/conv.go",
"chars": 6824,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/dir.go",
"chars": 5333,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/doc.go",
"chars": 1522,
"preview": "// Copyright 2011 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/main.go",
"chars": 3491,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/play.go",
"chars": 2042,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/static/article.css",
"chars": 2329,
"preview": "body {\n margin: 0;\n font-family: Helvetica, Arial, sans-serif;\n font-size: 16px;\n}\npre,\ncode {\n font-family: Menlo, "
},
{
"path": "cmd/present/static/dir.css",
"chars": 2396,
"preview": "/* copied from $GOROOT/doc/style.css */\n\nbody {\n margin: 0;\n font-family: Helvetica, Arial, sans-serif;\n font-size: 1"
},
{
"path": "cmd/present/static/dir.js",
"chars": 1049,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/static/jquery-ui.js",
"chars": 30584,
"preview": "/*! jQuery UI - v1.10.2 - 2013-03-20\n* http://jqueryui.com\n* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui"
},
{
"path": "cmd/present/static/jquery.js",
"chars": 93432,
"preview": "/*! jQuery v1.8.2 jquery.com | jquery.org/license */\n(function(a,b){function G(a){var b=F[a]={};return p.each(a.split(s)"
},
{
"path": "cmd/present/static/notes.css",
"chars": 602,
"preview": "p {\n margin: 10px;\n}\n\n#presenter-slides {\n display: block;\n margin-top: -10px;\n margin-left: -17px;\n position: fixe"
},
{
"path": "cmd/present/static/notes.js",
"chars": 5107,
"preview": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/static/play.js",
"chars": 3566,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/static/playground.js",
"chars": 16558,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/static/slides.js",
"chars": 15732,
"preview": "// Copyright 2012 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/present/static/styles.css",
"chars": 9997,
"preview": "@media screen {\n /* Framework */\n html {\n height: 100%;\n }\n\n body {\n margin: 0;\n padding: 0;\n\n display: "
},
{
"path": "cmd/present/templates/action.tmpl",
"chars": 1551,
"preview": "{/*\nThis is the action template.\nIt determines how the formatting actions are rendered.\n*/}\n\n{{define \"section\"}}\n <h{{"
},
{
"path": "cmd/present/templates/article.tmpl",
"chars": 3077,
"preview": "{/* This is the article template. It defines how articles are formatted. */}\n\n{{define \"root\"}}\n<!DOCTYPE html>\n<html>\n "
},
{
"path": "cmd/present/templates/dir.tmpl",
"chars": 3253,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n <title>Talks - The"
},
{
"path": "cmd/present/templates/slides.tmpl",
"chars": 3349,
"preview": "{/* This is the slide template. It defines how presentations are formatted. */}\n\n{{define \"root\"}}\n<!DOCTYPE html>\n<html"
},
{
"path": "cmd/present2md/main.go",
"chars": 11960,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/README.md",
"chars": 5921,
"preview": "# signature-fuzzer\n\nThis directory contains utilities for fuzz testing of Go function signatures, for use in developing/"
},
{
"path": "cmd/signature-fuzzer/fuzz-driver/driver.go",
"chars": 6011,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/fuzz-driver/drv_test.go",
"chars": 1943,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/fuzz-runner/rnr_test.go",
"chars": 5047,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/fuzz-runner/runner.go",
"chars": 12911,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/fuzz-runner/testdata/himom.go",
"chars": 210,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/arrayparm.go",
"chars": 2429,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/gen_test.go",
"chars": 7427,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/generator.go",
"chars": 62161,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/mapparm.go",
"chars": 1905,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/numparm.go",
"chars": 3216,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/parm.go",
"chars": 6430,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/pointerparm.go",
"chars": 1596,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/stringparm.go",
"chars": 1269,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/structparm.go",
"chars": 3625,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/typedefparm.go",
"chars": 2047,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/signature-fuzzer/internal/fuzz-generator/wraprand.go",
"chars": 2949,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/splitdwarf/internal/macho/fat.go",
"chars": 3894,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/splitdwarf/internal/macho/file.go",
"chars": 34454,
"preview": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/splitdwarf/internal/macho/file_test.go",
"chars": 12169,
"preview": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/splitdwarf/internal/macho/macho.go",
"chars": 11602,
"preview": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/splitdwarf/internal/macho/reloctype.go",
"chars": 2502,
"preview": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/splitdwarf/internal/macho/reloctype_string.go",
"chars": 4382,
"preview": "// Code generated by \"stringer -type=RelocTypeGeneric,RelocTypeX86_64,RelocTypeARM,RelocTypeARM64 -output reloctype_stri"
},
{
"path": "cmd/splitdwarf/internal/macho/testdata/hello.c",
"chars": 77,
"preview": "#include <stdio.h>\n\nint\nmain(void)\n{\n\tprintf(\"hello, world\\n\");\n\treturn 0;\n}\n"
},
{
"path": "cmd/splitdwarf/splitdwarf.go",
"chars": 13834,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/ssadump/main.go",
"chars": 5569,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stress/stress.go",
"chars": 5264,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/endtoend_test.go",
"chars": 9940,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/golden_test.go",
"chars": 23314,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/multifile_test.go",
"chars": 8600,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/stringer.go",
"chars": 23067,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/cgo.go",
"chars": 555,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/conv.go",
"chars": 670,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/conv2.go",
"chars": 927,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/day.go",
"chars": 666,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/gap.go",
"chars": 713,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/int8overflow.go",
"chars": 7245,
"preview": "// Copyright 2025 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/num.go",
"chars": 504,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/number.go",
"chars": 600,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/prime.go",
"chars": 1024,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/prime2.go",
"chars": 1293,
"preview": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/tag_main.go",
"chars": 93,
"preview": "// No build tag in this file.\n\npackage main\n\ntype Const int\n\nconst (\n\tA Const = iota\n\tB\n\tC\n)\n"
},
{
"path": "cmd/stringer/testdata/tag_tag.go",
"chars": 98,
"preview": "// This file has a build tag \"tag\"\n\n// +build tag\n\npackage main\n\nconst TagProtected Const = C + 1\n"
},
{
"path": "cmd/stringer/testdata/unum.go",
"chars": 549,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/unum2.go",
"chars": 494,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/testdata/vary_day.go",
"chars": 690,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/stringer/util_test.go",
"chars": 2015,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/toolstash/buildall",
"chars": 1572,
"preview": "#!/bin/bash\n\n# Usage: buildall [-e] [-nocmp] [-work]\n#\n# Builds everything (std) for every GOOS/GOARCH combination but i"
},
{
"path": "cmd/toolstash/cmp.go",
"chars": 3972,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cmd/toolstash/main.go",
"chars": 16601,
"preview": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "codereview.cfg",
"chars": 21,
"preview": "issuerepo: golang/go\n"
},
{
"path": "container/intsets/export_test.go",
"chars": 254,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "container/intsets/sparse.go",
"chars": 23813,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "container/intsets/sparse_test.go",
"chars": 16941,
"preview": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "copyright/copyright.go",
"chars": 2392,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "copyright/copyright_test.go",
"chars": 446,
"preview": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cover/profile.go",
"chars": 7696,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "cover/profile_test.go",
"chars": 5392,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/analysis.go",
"chars": 10498,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/analysistest/analysistest.go",
"chars": 26956,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/analysistest/analysistest_test.go",
"chars": 7650,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/checker/checker.go",
"chars": 20743,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/checker/checker_test.go",
"chars": 2086,
"preview": "// Copyright 2026 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/checker/example_test.go",
"chars": 3510,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/checker/print.go",
"chars": 2535,
"preview": "// Copyright 2024 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/diagnostic.go",
"chars": 3265,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/doc/suggested_fixes.md",
"chars": 5192,
"preview": "# Suggested Fixes in the Analysis Framework\n\n## The Purpose of Suggested Fixes\n\nThe analysis framework is planned to add"
},
{
"path": "go/analysis/doc.go",
"chars": 13634,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/analysisflags/flags.go",
"chars": 8340,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/analysisflags/flags_test.go",
"chars": 1584,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/analysisflags/help.go",
"chars": 3378,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/checker/checker.go",
"chars": 9847,
"preview": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/checker/checker_test.go",
"chars": 8713,
"preview": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/checker/fix_test.go",
"chars": 18545,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/checker/start_test.go",
"chars": 2148,
"preview": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "go/analysis/internal/checker/testdata/conflict.txt",
"chars": 717,
"preview": "# Conflicting edits are legal, so long as they appear in different fixes.\n# The driver will apply them in some order, an"
}
]
// ... and 2561 more files (download for full content)
About this extraction
This page contains the full source code of the golang/tools GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 2761 files (13.6 MB), approximately 3.7M tokens, and a symbol index with 16875 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.