all: gofmt

Gofmt to update doc comments to the new formatting.

(There are so many files in x/tools I am breaking up the
gofmt'ing into multiple CLs. This is the leftovers.)

For golang/go#51082.

Change-Id: Id9d440cde9de7093d2ffe06cbaa7098993823d6b
Reviewed-on: https://go-review.googlesource.com/c/tools/+/399363
Run-TryBot: Russ Cox <[email protected]>
Auto-Submit: Russ Cox <[email protected]>
gopls-CI: kokoro <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Reviewed-by: Ian Lance Taylor <[email protected]>

container/intsets/sparse.go

@@ -10,7 +10,6 @@
 // space-efficient than equivalent operations on sets based on the Go
 // map type.  The IsEmpty, Min, Max, Clear and TakeMin operations
 // require constant time.
-//
 package intsets // import "golang.org/x/tools/container/intsets"
 
 // TODO(adonovan):
@@ -37,7 +36,6 @@ import (
 //
 // Sparse sets must be copied using the Copy method, not by assigning
 // a Sparse value.
-//
 type Sparse struct {
 	// An uninitialized Sparse represents an empty set.
 	// An empty set may also be represented by
@@ -105,7 +103,6 @@ func ntz(x word) int {
 // is the Euclidean remainder.
 //
 // A block may only be empty transiently.
-//
 type block struct {
 	offset     int                 // offset mod bitsPerBlock == 0
 	bits       [wordsPerBlock]word // contains at least one set bit
@@ -122,7 +119,6 @@ func wordMask(i uint) (w uint, mask word) {
 
 // insert sets the block b's ith bit and
 // returns true if it was not already set.
-//
 func (b *block) insert(i uint) bool {
 	w, mask := wordMask(i)
 	if b.bits[w]&mask == 0 {
@@ -135,7 +131,6 @@ func (b *block) insert(i uint) bool {
 // remove clears the block's ith bit and
 // returns true if the bit was previously set.
 // NB: may leave the block empty.
-//
 func (b *block) remove(i uint) bool {
 	w, mask := wordMask(i)
 	if b.bits[w]&mask != 0 {
@@ -238,7 +233,6 @@ func (b *block) forEach(f func(int)) {
 
 // offsetAndBitIndex returns the offset of the block that would
 // contain x and the bit index of x within that block.
-//
 func offsetAndBitIndex(x int) (int, uint) {
 	mod := x % bitsPerBlock
 	if mod < 0 {
@@ -438,9 +432,8 @@ func (s *Sparse) Clear() {
 //
 // This method may be used for iteration over a worklist like so:
 //
-// 	var x int
-// 	for worklist.TakeMin(&x) { use(x) }
-//
+//	var x int
+//	for worklist.TakeMin(&x) { use(x) }
 func (s *Sparse) TakeMin(p *int) bool {
 	if s.IsEmpty() {
 		return false
@@ -466,7 +459,6 @@ func (s *Sparse) Has(x int) bool {
 // f must not mutate s.  Consequently, forEach is not safe to expose
 // to clients.  In any case, using "range s.AppendTo()" allows more
 // natural control flow with continue/break/return.
-//
 func (s *Sparse) forEach(f func(int)) {
 	for b := s.first(); b != &none; b = s.next(b) {
 		b.forEach(f)
@@ -1021,11 +1013,11 @@ func (s *Sparse) String() string {
 // preceded by a digit, appears if the sum is non-integral.
 //
 // Examples:
-//              {}.BitString() =      "0"
-//           {4,5}.BitString() = "110000"
-//            {-3}.BitString() =      "0.001"
-//      {-3,0,4,5}.BitString() = "110001.001"
 //
+//	        {}.BitString() =      "0"
+//	     {4,5}.BitString() = "110000"
+//	      {-3}.BitString() =      "0.001"
+//	{-3,0,4,5}.BitString() = "110001.001"
 func (s *Sparse) BitString() string {
 	if s.IsEmpty() {
 		return "0"
@@ -1060,7 +1052,6 @@ func (s *Sparse) BitString() string {
 
 // GoString returns a string showing the internal representation of
 // the set s.
-//
 func (s *Sparse) GoString() string {
 	var buf bytes.Buffer
 	for b := s.first(); b != &none; b = s.next(b) {

copyright/copyright.go

@@ -96,6 +96,7 @@ func checkFile(toolsDir, filename string) (bool, error) {
 
 // Copied from golang.org/x/tools/internal/lsp/source/util.go.
 // Matches cgo generated comment as well as the proposed standard:
+//
 //	https://golang.org/s/generatedcode
 var generatedRx = regexp.MustCompile(`// .*DO NOT EDIT\.?`)
 

go/ast/astutil/enclosing.go

@@ -22,9 +22,9 @@ import (
 // additional whitespace abutting a node to be enclosed by it.
 // In this example:
 //
-//              z := x + y // add them
-//                   <-A->
-//                  <----B----->
+//	z := x + y // add them
+//	     <-A->
+//	    <----B----->
 //
 // the ast.BinaryExpr(+) node is considered to enclose interval B
 // even though its [Pos()..End()) is actually only interval A.
@@ -43,10 +43,10 @@ import (
 // interior whitespace of path[0].
 // In this example:
 //
-//              z := x + y // add them
-//                <--C-->     <---E-->
-//                  ^
-//                  D
+//	z := x + y // add them
+//	  <--C-->     <---E-->
+//	    ^
+//	    D
 //
 // intervals C, D and E are inexact.  C is contained by the
 // z-assignment statement, because it spans three of its children (:=,
@@ -59,7 +59,6 @@ import (
 // Requires FileSet; see loader.tokenFileContainsPos.
 //
 // Postcondition: path is never nil; it always contains at least 'root'.
-//
 func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Node, exact bool) {
 	// fmt.Printf("EnclosingInterval %d %d\n", start, end) // debugging
 
@@ -162,7 +161,6 @@ func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Nod
 // tokenNode is a dummy implementation of ast.Node for a single token.
 // They are used transiently by PathEnclosingInterval but never escape
 // this package.
-//
 type tokenNode struct {
 	pos token.Pos
 	end token.Pos
@@ -183,7 +181,6 @@ func tok(pos token.Pos, len int) ast.Node {
 // childrenOf returns the direct non-nil children of ast.Node n.
 // It may include fake ast.Node implementations for bare tokens.
 // it is not safe to call (e.g.) ast.Walk on such nodes.
-//
 func childrenOf(n ast.Node) []ast.Node {
 	var children []ast.Node
 
@@ -488,7 +485,6 @@ func (sl byPos) Swap(i, j int) {
 // TODO(adonovan): in some cases (e.g. Field, FieldList, Ident,
 // StarExpr) we could be much more specific given the path to the AST
 // root.  Perhaps we should do that.
-//
 func NodeDescription(n ast.Node) string {
 	switch n := n.(type) {
 	case *ast.ArrayType:

go/ast/astutil/enclosing_test.go

@@ -40,7 +40,6 @@ func pathToString(path []ast.Node) string {
 // findInterval parses input and returns the [start, end) positions of
 // the first occurrence of substr in input.  f==nil indicates failure;
 // an error has already been reported in that case.
-//
 func findInterval(t *testing.T, fset *token.FileSet, input, substr string) (f *ast.File, start, end token.Pos) {
 	f, err := parser.ParseFile(fset, "<input>", input, 0)
 	if err != nil {

go/ast/astutil/imports.go

@@ -22,8 +22,11 @@ func AddImport(fset *token.FileSet, f *ast.File, path string) (added bool) {
 // If name is not empty, it is used to rename the import.
 //
 // For example, calling
+//
 //	AddNamedImport(fset, f, "pathpkg", "path")
+//
 // adds
+//
 //	import pathpkg "path"
 func AddNamedImport(fset *token.FileSet, f *ast.File, name, path string) (added bool) {
 	if imports(f, name, path) {

go/ast/astutil/rewrite.go

@@ -41,7 +41,6 @@ type ApplyFunc func(*Cursor) bool
 // Children are traversed in the order in which they appear in the
 // respective node's struct definition. A package's files are
 // traversed in the filenames' alphabetical order.
-//
 func Apply(root ast.Node, pre, post ApplyFunc) (result ast.Node) {
 	parent := &struct{ ast.Node }{root}
 	defer func() {
@@ -65,8 +64,8 @@ var abort = new(int) // singleton, to signal termination of Apply
 // c.Parent(), and f is the field identifier with name c.Name(),
 // the following invariants hold:
 //
-//   p.f            == c.Node()  if c.Index() <  0
-//   p.f[c.Index()] == c.Node()  if c.Index() >= 0
+//	p.f            == c.Node()  if c.Index() <  0
+//	p.f[c.Index()] == c.Node()  if c.Index() >= 0
 //
 // The methods Replace, Delete, InsertBefore, and InsertAfter
 // can be used to change the AST without disrupting Apply.

go/ast/inspector/typeof.go

@@ -77,20 +77,21 @@ const (
 // typeOf returns a distinct single-bit value that represents the type of n.
 //
 // Various implementations were benchmarked with BenchmarkNewInspector:
-//								GOGC=off
-// - type switch				4.9-5.5ms	2.1ms
-// - binary search over a sorted list of types  5.5-5.9ms	2.5ms
-// - linear scan, frequency-ordered list 	5.9-6.1ms	2.7ms
-// - linear scan, unordered list		6.4ms		2.7ms
-// - hash table					6.5ms		3.1ms
+//
+//	                                                                GOGC=off
+//	- type switch					4.9-5.5ms	2.1ms
+//	- binary search over a sorted list of types	5.5-5.9ms	2.5ms
+//	- linear scan, frequency-ordered list		5.9-6.1ms	2.7ms
+//	- linear scan, unordered list			6.4ms		2.7ms
+//	- hash table					6.5ms		3.1ms
+//
 // A perfect hash seemed like overkill.
 //
 // The compiler's switch statement is the clear winner
 // as it produces a binary tree in code,
 // with constant conditions and good branch prediction.
 // (Sadly it is the most verbose in source code.)
 // Binary search suffered from poor branch prediction.
-//
 func typeOf(n ast.Node) uint64 {
 	// Fast path: nearly half of all nodes are identifiers.
 	if _, ok := n.(*ast.Ident); ok {

go/buildutil/allpackages.go

@@ -28,7 +28,6 @@ import (
 //
 // All I/O is done via the build.Context file system interface,
 // which must be concurrency-safe.
-//
 func AllPackages(ctxt *build.Context) []string {
 	var list []string
 	ForEachPackage(ctxt, func(pkg string, _ error) {
@@ -48,7 +47,6 @@ func AllPackages(ctxt *build.Context) []string {
 //
 // All I/O is done via the build.Context file system interface,
 // which must be concurrency-safe.
-//
 func ForEachPackage(ctxt *build.Context, found func(importPath string, err error)) {
 	ch := make(chan item)
 
@@ -127,19 +125,18 @@ func allPackages(ctxt *build.Context, root string, ch chan<- item) {
 // ExpandPatterns returns the set of packages matched by patterns,
 // which may have the following forms:
 //
-//		golang.org/x/tools/cmd/guru     # a single package
-//		golang.org/x/tools/...          # all packages beneath dir
-//		...                             # the entire workspace.
+//	golang.org/x/tools/cmd/guru     # a single package
+//	golang.org/x/tools/...          # all packages beneath dir
+//	...                             # the entire workspace.
 //
 // Order is significant: a pattern preceded by '-' removes matching
 // packages from the set.  For example, these patterns match all encoding
 // packages except encoding/xml:
 //
-// 	encoding/... -encoding/xml
+//	encoding/... -encoding/xml
 //
 // A trailing slash in a pattern is ignored.  (Path components of Go
 // package names are separated by slash, not the platform's path separator.)
-//
 func ExpandPatterns(ctxt *build.Context, patterns []string) map[string]bool {
 	// TODO(adonovan): support other features of 'go list':
 	// - "std"/"cmd"/"all" meta-packages

go/buildutil/fakecontext.go

@@ -30,7 +30,6 @@ import (
 // /go/src/ including, for instance, "math" and "math/big".
 // ReadDir("/go/src/math/big") would return all the files in the
 // "math/big" package.
-//
 func FakeContext(pkgs map[string]map[string]string) *build.Context {
 	clean := func(filename string) string {
 		f := path.Clean(filepath.ToSlash(filename))

go/buildutil/overlay.go

@@ -60,8 +60,7 @@ func OverlayContext(orig *build.Context, overlay map[string][]byte) *build.Conte
 // ParseOverlayArchive parses an archive containing Go files and their
 // contents. The result is intended to be used with OverlayContext.
 //
-//
-// Archive format
+// # Archive format
 //
 // The archive consists of a series of files. Each file consists of a
 // name, a decimal file size and the file contents, separated by

go/buildutil/tags.go

@@ -20,7 +20,8 @@ const TagsFlagDoc = "a list of `build tags` to consider satisfied during the bui
 // See $GOROOT/src/cmd/go/doc.go for description of 'go build -tags' flag.
 //
 // Example:
-// 	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+//
+//	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
 type TagsFlag []string
 
 func (v *TagsFlag) Set(s string) error {

go/buildutil/util.go

@@ -28,7 +28,6 @@ import (
 // filename that will be attached to the ASTs.
 //
 // TODO(adonovan): call this from go/loader.parseFiles when the tree thaws.
-//
 func ParseFile(fset *token.FileSet, ctxt *build.Context, displayPath func(string) string, dir string, file string, mode parser.Mode) (*ast.File, error) {
 	if !IsAbsPath(ctxt, file) {
 		file = JoinPath(ctxt, dir, file)
@@ -51,7 +50,6 @@ func ParseFile(fset *token.FileSet, ctxt *build.Context, displayPath func(string
 //
 // The '...Files []string' fields of the resulting build.Package are not
 // populated (build.FindOnly mode).
-//
 func ContainingPackage(ctxt *build.Context, dir, filename string) (*build.Package, error) {
 	if !IsAbsPath(ctxt, filename) {
 		filename = JoinPath(ctxt, dir, filename)
@@ -196,7 +194,6 @@ func SplitPathList(ctxt *build.Context, s string) []string {
 
 // sameFile returns true if x and y have the same basename and denote
 // the same file.
-//
 func sameFile(x, y string) bool {
 	if path.Clean(x) == path.Clean(y) {
 		return true

go/cfg/builder.go

@@ -443,7 +443,6 @@ func (b *builder) rangeStmt(s *ast.RangeStmt, label *lblock) {
 // Destinations associated with unlabeled for/switch/select stmts.
 // We push/pop one of these as we enter/leave each construct and for
 // each BranchStmt we scan for the innermost target of the right type.
-//
 type targets struct {
 	tail         *targets // rest of stack
 	_break       *Block
@@ -454,7 +453,6 @@ type targets struct {
 // Destinations associated with a labeled block.
 // We populate these as labels are encountered in forward gotos or
 // labeled statements.
-//
 type lblock struct {
 	_goto     *Block
 	_break    *Block
@@ -463,7 +461,6 @@ type lblock struct {
 
 // labeledBlock returns the branch target associated with the
 // specified label, creating it if needed.
-//
 func (b *builder) labeledBlock(label *ast.Ident) *lblock {
 	lb := b.lblocks[label.Obj]
 	if lb == nil {

go/cfg/cfg.go

@@ -20,14 +20,14 @@
 //
 // produces this CFG:
 //
-//    1:  x := f()
-//        x != nil
-//        succs: 2, 3
-//    2:  T()
-//        succs: 4
-//    3:  F()
-//        succs: 4
-//    4:
+//	1:  x := f()
+//	    x != nil
+//	    succs: 2, 3
+//	2:  T()
+//	    succs: 4
+//	3:  F()
+//	    succs: 4
+//	4:
 //
 // The CFG does contain Return statements; even implicit returns are
 // materialized (at the position of the function's closing brace).
@@ -36,7 +36,6 @@
 // edges, nor the short-circuit semantics of the && and || operators,
 // nor abnormal control flow caused by panic.  If you need this
 // information, use golang.org/x/tools/go/ssa instead.
-//
 package cfg
 
 import (