diff --git a/cover/profile_test.go b/cover/profile_test.go
index 3cecdac..925b397 100644
--- a/cover/profile_test.go
+++ b/cover/profile_test.go
@@ -6,8 +6,8 @@
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
+	"path/filepath"
 	"reflect"
 	"testing"
 )
@@ -208,26 +208,12 @@
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			f, err := ioutil.TempFile("", "")
-			if err != nil {
-				t.Fatalf("Failed to create a temp file: %v.", err)
-			}
-			defer func() {
-				f.Close()
-				os.Remove(f.Name())
-			}()
-			n, err := f.WriteString(tc.input)
-			if err != nil {
-				t.Fatalf("Failed to write to temp file: %v", err)
-			}
-			if n < len(tc.input) {
-				t.Fatalf("Didn't write enough bytes to temp file (wrote %d, expected %d).", n, len(tc.input))
-			}
-			if err := f.Sync(); err != nil {
-				t.Fatalf("Failed to sync temp file: %v", err)
+			fname := filepath.Join(t.TempDir(), "test.cov")
+			if err := os.WriteFile(fname, []byte(tc.input), 0644); err != nil {
+				t.Fatal(err)
 			}
 
-			result, err := ParseProfiles(f.Name())
+			result, err := ParseProfiles(fname)
 			if err != nil {
 				if !tc.expectErr {
 					t.Errorf("Unexpected error: %v", err)
diff --git a/go/analysis/passes/slog/slog.go b/go/analysis/passes/slog/slog.go
index 874ebec..8429eab 100644
--- a/go/analysis/passes/slog/slog.go
+++ b/go/analysis/passes/slog/slog.go
@@ -204,7 +204,7 @@
 		"WarnCtx":  2,
 		"ErrorCtx": 2,
 		"Log":      3,
-		"Group":    0,
+		"Group":    1,
 	},
 	"Logger": map[string]int{
 		"Debug":    1,
diff --git a/go/analysis/passes/slog/testdata/src/a/a.go b/go/analysis/passes/slog/testdata/src/a/a.go
index a13aac7..aa408d0 100644
--- a/go/analysis/passes/slog/testdata/src/a/a.go
+++ b/go/analysis/passes/slog/testdata/src/a/a.go
@@ -143,7 +143,8 @@
 
 	r.Add(1, 2) // want `slog.Record.Add arg "1" should be a string or a slog.Attr`
 
-	_ = slog.Group("a", 1, 2, 3) // want `slog.Group arg "2" should be a string or a slog.Attr`
+	_ = slog.Group("key", "a", 1, "b", 2)
+	_ = slog.Group("key", "a", 1, 2, 3) // want `slog.Group arg "2" should be a string or a slog.Attr`
 
 }
 
diff --git a/go/ssa/builder_generic_test.go b/go/ssa/builder_generic_test.go
index 77de326..c86da0c 100644
--- a/go/ssa/builder_generic_test.go
+++ b/go/ssa/builder_generic_test.go
@@ -685,7 +685,7 @@
 	//@ instrs("f12", "*ssa.MakeMap", "make map[P]bool 1:int")
 	func f12[T any, P *struct{f T}](x T) map[P]bool { return map[P]bool{{}: true} }
 
-	//@ instrs("f13", "&v[0:int]")
+	//@ instrs("f13", "*ssa.IndexAddr", "&v[0:int]")
 	//@ instrs("f13", "*ssa.Store", "*t0 = 7:int", "*v = *new(A):A")
 	func f13[A [3]int, PA *A](v PA) {
 		*v = A{7}
diff --git a/go/ssa/doc.go b/go/ssa/doc.go
index afda476..a687de4 100644
--- a/go/ssa/doc.go
+++ b/go/ssa/doc.go
@@ -66,7 +66,6 @@
 //	*FieldAddr            ✔               ✔
 //	*FreeVar              ✔
 //	*Function             ✔                               ✔ (func)
-//	*GenericConvert       ✔               ✔
 //	*Global               ✔                               ✔ (var)
 //	*Go                                   ✔
 //	*If                                   ✔
@@ -80,6 +79,7 @@
 //	*MakeMap              ✔               ✔
 //	*MakeSlice            ✔               ✔
 //	*MapUpdate                            ✔
+//	*MultiConvert         ✔               ✔
 //	*NamedConst                                           ✔ (const)
 //	*Next                 ✔               ✔
 //	*Panic                                ✔
diff --git a/go/ssa/emit.go b/go/ssa/emit.go
index 80e30b6..fe2f6f0 100644
--- a/go/ssa/emit.go
+++ b/go/ssa/emit.go
@@ -476,7 +476,7 @@
 // value of a field.
 func emitImplicitSelections(f *Function, v Value, indices []int, pos token.Pos) Value {
 	for _, index := range indices {
-		if st, vptr := deptr(v.Type()); vptr {
+		if st, vptr := deref(v.Type()); vptr {
 			fld := fieldOf(st, index)
 			instr := &FieldAddr{
 				X:     v,
@@ -486,7 +486,7 @@
 			instr.setType(types.NewPointer(fld.Type()))
 			v = f.emit(instr)
 			// Load the field's value iff indirectly embedded.
-			if _, fldptr := deptr(fld.Type()); fldptr {
+			if _, fldptr := deref(fld.Type()); fldptr {
 				v = emitLoad(f, v)
 			}
 		} else {
@@ -510,7 +510,7 @@
 // field's value.
 // Ident id is used for position and debug info.
 func emitFieldSelection(f *Function, v Value, index int, wantAddr bool, id *ast.Ident) Value {
-	if st, vptr := deptr(v.Type()); vptr {
+	if st, vptr := deref(v.Type()); vptr {
 		fld := fieldOf(st, index)
 		instr := &FieldAddr{
 			X:     v,
diff --git a/go/ssa/ssa.go b/go/ssa/ssa.go
index eeb9681..313146d 100644
--- a/go/ssa/ssa.go
+++ b/go/ssa/ssa.go
@@ -865,7 +865,7 @@
 type FieldAddr struct {
 	register
 	X     Value // *struct
-	Field int   // field is typeparams.CoreType(X.Type().Underlying().(*types.Pointer).Elem()).(*types.Struct).Field(Field)
+	Field int   // index into CoreType(CoreType(X.Type()).(*types.Pointer).Elem()).(*types.Struct).Fields
 }
 
 // The Field instruction yields the Field of struct X.
@@ -884,7 +884,7 @@
 type Field struct {
 	register
 	X     Value // struct
-	Field int   // index into typeparams.CoreType(X.Type()).(*types.Struct).Fields
+	Field int   // index into CoreType(X.Type()).(*types.Struct).Fields
 }
 
 // The IndexAddr instruction yields the address of the element at
diff --git a/go/ssa/stdlib_test.go b/go/ssa/stdlib_test.go
index 8b9f423..11782f7 100644
--- a/go/ssa/stdlib_test.go
+++ b/go/ssa/stdlib_test.go
@@ -36,7 +36,7 @@
 
 func TestStdlib(t *testing.T) {
 	if testing.Short() {
-		t.Skip("skipping in short mode; too slow (https://golang.org/issue/14113)")
+		t.Skip("skipping in short mode; too slow (https://golang.org/issue/14113)") // ~5s
 	}
 	testenv.NeedsTool(t, "go")
 
@@ -81,20 +81,33 @@
 
 	allFuncs := ssautil.AllFunctions(prog)
 
-	// Check that all non-synthetic functions have distinct names.
-	// Synthetic wrappers for exported methods should be distinct too,
-	// except for unexported ones (explained at (*Function).RelString).
-	byName := make(map[string]*ssa.Function)
-	for fn := range allFuncs {
-		if fn.Synthetic == "" || ast.IsExported(fn.Name()) {
-			str := fn.String()
-			prev := byName[str]
-			byName[str] = fn
-			if prev != nil {
-				t.Errorf("%s: duplicate function named %s",
-					prog.Fset.Position(fn.Pos()), str)
-				t.Errorf("%s:   (previously defined here)",
-					prog.Fset.Position(prev.Pos()))
+	// The assertion below is not valid if the program contains
+	// variants of the same package, such as the test variants
+	// (e.g. package p as compiled for test executable x) obtained
+	// when cfg.Tests=true. Profile-guided optimization may
+	// lead to similar variation for non-test executables.
+	//
+	// Ideally, the test would assert that all functions within
+	// each executable (more generally: within any singly rooted
+	// transitively closed subgraph of the import graph) have
+	// distinct names, but that isn't so easy to compute efficiently.
+	// Disabling for now.
+	if false {
+		// Check that all non-synthetic functions have distinct names.
+		// Synthetic wrappers for exported methods should be distinct too,
+		// except for unexported ones (explained at (*Function).RelString).
+		byName := make(map[string]*ssa.Function)
+		for fn := range allFuncs {
+			if fn.Synthetic == "" || ast.IsExported(fn.Name()) {
+				str := fn.String()
+				prev := byName[str]
+				byName[str] = fn
+				if prev != nil {
+					t.Errorf("%s: duplicate function named %s",
+						prog.Fset.Position(fn.Pos()), str)
+					t.Errorf("%s:   (previously defined here)",
+						prog.Fset.Position(prev.Pos()))
+				}
 			}
 		}
 	}
diff --git a/gopls/README.md b/gopls/README.md
index 56d1592..396f86c 100644
--- a/gopls/README.md
+++ b/gopls/README.md
@@ -93,6 +93,7 @@
 | ----------- | --------------------------------------------------- |
 | Go 1.12     | [gopls@v0.7.5](https://github.com/golang/tools/releases/tag/gopls%2Fv0.7.5) |
 | Go 1.15     | [gopls@v0.9.5](https://github.com/golang/tools/releases/tag/gopls%2Fv0.9.5) |
+| Go 1.17     | [gopls@v0.11.0](https://github.com/golang/tools/releases/tag/gopls%2Fv0.11.0) |
 
 Our extended support is enforced via [continuous integration with older Go
 versions](doc/contributing.md#ci). This legacy Go CI may not block releases:
diff --git a/gopls/doc/commands.md b/gopls/doc/commands.md
index 8fe677b..b259f63 100644
--- a/gopls/doc/commands.md
+++ b/gopls/doc/commands.md
@@ -267,6 +267,9 @@
 	"URI": string,
 	// The module path to remove.
 	"ModulePath": string,
+	// If the module is tidied apart from the one unused diagnostic, we can
+	// run `go get module@none`, and then run `go mod tidy`. Otherwise, we
+	// must make textual edits.
 	"OnlyDiagnostic": bool,
 }
 ```
diff --git a/gopls/doc/design/implementation.md b/gopls/doc/design/implementation.md
index 859ec1c..e9b915b 100644
--- a/gopls/doc/design/implementation.md
+++ b/gopls/doc/design/implementation.md
@@ -37,12 +37,12 @@
 
 [gopls]: https://github.com/golang/tools/tree/master/gopls
 [internal/jsonrpc2]: https://github.com/golang/tools/tree/master/internal/jsonrpc2
-[internal/lsp]: https://github.com/golang/tools/tree/master/internal/lsp
-[internal/lsp/cache]: https://github.com/golang/tools/tree/master/internal/lsp/cache
-[internal/lsp/cmd]: https://github.com/golang/tools/tree/master/internal/lsp/cmd
-[internal/lsp/debug]: https://github.com/golang/tools/tree/master/internal/lsp/debug
-[internal/lsp/protocol]: https://github.com/golang/tools/tree/master/internal/lsp/protocol
-[internal/lsp/source]: https://github.com/golang/tools/tree/master/internal/lsp/source
+[internal/lsp]: https://github.com/golang/tools/tree/master/gopls/internal/lsp
+[internal/lsp/cache]: https://github.com/golang/tools/tree/master/gopls/internal/lsp/cache
+[internal/lsp/cmd]: https://github.com/golang/tools/tree/master/gopls/internal/lsp/cmd
+[internal/lsp/debug]: https://github.com/golang/tools/tree/master/gopls/internal/lsp/debug
+[internal/lsp/protocol]: https://github.com/golang/tools/tree/master/gopls/internal/lsp/protocol
+[internal/lsp/source]: https://github.com/golang/tools/tree/master/gopls/internal/lsp/source
 [internal/memoize]: https://github.com/golang/tools/tree/master/internal/memoize
-[internal/span]: https://github.com/golang/tools/tree/master/internal/span
+[internal/span]: https://github.com/golang/tools/tree/master/gopls/internal/span
 [x/tools]: https://github.com/golang/tools
diff --git a/gopls/go.mod b/gopls/go.mod
index 5f64a62..ca3f9bf2 100644
--- a/gopls/go.mod
+++ b/gopls/go.mod
@@ -25,3 +25,5 @@
 	golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e // indirect
 	golang.org/x/exp/typeparams v0.0.0-20221212164502-fae10dda9338 // indirect
 )
+
+replace golang.org/x/tools => ../
diff --git a/gopls/go.sum b/gopls/go.sum
index fe1d7bb..f6308a7 100644
--- a/gopls/go.sum
+++ b/gopls/go.sum
@@ -42,86 +42,42 @@
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e h1:+WEEuIdZHnUeJJmEUjyYC2gfUMj69yZXw17EnHg/otA=
 golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e/go.mod h1:Kr81I6Kryrl9sr8s2FK3vxD90NdsKWRuOIl2O4CvYbA=
 golang.org/x/exp/typeparams v0.0.0-20221208152030-732eee02a75a/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=
 golang.org/x/exp/typeparams v0.0.0-20221212164502-fae10dda9338 h1:2O2DON6y3XMJiQRAS1UWU+54aec2uopH3x7MAiqGW6Y=
 golang.org/x/exp/typeparams v0.0.0-20221212164502-fae10dda9338/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk=
 golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.3.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
 golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211213223007-03aa0b5f6827/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
-golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
-golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.4.1-0.20221208213631-3f74d914ae6d/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ=
-golang.org/x/tools v0.4.1-0.20221217013628-b4dfc36097e2/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.9.2-0.20230516204147-76f78597112f h1:sbeNk1oZVYGPodwxlh++zvjWdh/C9nWD3lkPTLPkzDU=
-golang.org/x/tools v0.9.2-0.20230516204147-76f78597112f/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc=
 golang.org/x/vuln v0.0.0-20230110180137-6ad3e3d07815 h1:A9kONVi4+AnuOr1dopsibH6hLi1Huy54cbeJxnq4vmU=
 golang.org/x/vuln v0.0.0-20230110180137-6ad3e3d07815/go.mod h1:XJiVExZgoZfrrxoTeVsFYrSSk1snhfpOEC95JL+A4T0=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/gopls/internal/bug/bug.go b/gopls/internal/bug/bug.go
index 1bf7d30..f72948b 100644
--- a/gopls/internal/bug/bug.go
+++ b/gopls/internal/bug/bug.go
@@ -17,6 +17,7 @@
 	"runtime/debug"
 	"sort"
 	"sync"
+	"time"
 )
 
 // PanicOnBugs controls whether to panic when bugs are reported.
@@ -32,12 +33,15 @@
 
 // A Bug represents an unexpected event or broken invariant. They are used for
 // capturing metadata that helps us understand the event.
+//
+// Bugs are JSON-serializable.
 type Bug struct {
-	File        string // file containing the call to bug.Report
-	Line        int    // line containing the call to bug.Report
-	Description string // description of the bug
-	Key         string // key identifying the bug (file:line if available)
-	Stack       string // call stack
+	File        string    // file containing the call to bug.Report
+	Line        int       // line containing the call to bug.Report
+	Description string    // description of the bug
+	Key         string    // key identifying the bug (file:line if available)
+	Stack       string    // call stack
+	AtTime      time.Time // time the bug was reported
 }
 
 // Reportf reports a formatted bug message.
@@ -77,6 +81,7 @@
 		Description: description,
 		Key:         key,
 		Stack:       string(debug.Stack()),
+		AtTime:      time.Now(),
 	}
 
 	mu.Lock()
diff --git a/gopls/internal/bug/bug_test.go b/gopls/internal/bug/bug_test.go
index 2e36221..8ca2aa5 100644
--- a/gopls/internal/bug/bug_test.go
+++ b/gopls/internal/bug/bug_test.go
@@ -5,8 +5,12 @@
 package bug
 
 import (
+	"encoding/json"
 	"fmt"
 	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
 )
 
 func resetForTesting() {
@@ -62,3 +66,26 @@
 		t.Errorf("got %q, want %q", got, want)
 	}
 }
+
+func TestBugJSON(t *testing.T) {
+	b1 := Bug{
+		File:        "foo.go",
+		Line:        1,
+		Description: "a bug",
+		Key:         "foo.go:1",
+		Stack:       "<stack>",
+		AtTime:      time.Now(),
+	}
+
+	data, err := json.Marshal(b1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var b2 Bug
+	if err := json.Unmarshal(data, &b2); err != nil {
+		t.Fatal(err)
+	}
+	if diff := cmp.Diff(b1, b2); diff != "" {
+		t.Errorf("bugs differ after JSON Marshal/Unmarshal (-b1 +b2):\n%s", diff)
+	}
+}
diff --git a/gopls/internal/lsp/cache/check.go b/gopls/internal/lsp/cache/check.go
index 83ea177..6631270 100644
--- a/gopls/internal/lsp/cache/check.go
+++ b/gopls/internal/lsp/cache/check.go
@@ -1190,7 +1190,7 @@
 
 		relatedInformation: s.view.Options().RelatedInformationSupported,
 		linkTarget:         s.view.Options().LinkTarget,
-		moduleMode:         s.moduleMode(),
+		moduleMode:         s.view.moduleMode(),
 	}, nil
 }
 
@@ -1542,14 +1542,18 @@
 				if err != nil {
 					return nil, err
 				}
-				errors = append(errors, &source.Diagnostic{
+				diag := &source.Diagnostic{
 					URI:            imp.cgf.URI,
 					Range:          rng,
 					Severity:       protocol.SeverityError,
 					Source:         source.TypeError,
 					Message:        fmt.Sprintf("error while importing %v: %v", item, depErr.Err),
 					SuggestedFixes: fixes,
-				})
+				}
+				if !source.BundleQuickFixes(diag) {
+					bug.Reportf("failed to bundle fixes for diagnostic %q", diag.Message)
+				}
+				errors = append(errors, diag)
 			}
 		}
 	}
@@ -1585,14 +1589,18 @@
 			if err != nil {
 				return nil, err
 			}
-			errors = append(errors, &source.Diagnostic{
+			diag := &source.Diagnostic{
 				URI:            pm.URI,
 				Range:          rng,
 				Severity:       protocol.SeverityError,
 				Source:         source.TypeError,
 				Message:        fmt.Sprintf("error while importing %v: %v", item, depErr.Err),
 				SuggestedFixes: fixes,
-			})
+			}
+			if !source.BundleQuickFixes(diag) {
+				bug.Reportf("failed to bundle fixes for diagnostic %q", diag.Message)
+			}
+			errors = append(errors, diag)
 			break
 		}
 	}
diff --git a/gopls/internal/lsp/cache/load.go b/gopls/internal/lsp/cache/load.go
index 111b074..939d084 100644
--- a/gopls/internal/lsp/cache/load.go
+++ b/gopls/internal/lsp/cache/load.go
@@ -378,53 +378,6 @@
 		return fmt.Errorf(msg), s.applyCriticalErrorToFiles(ctx, msg, openFiles)
 	}
 
-	// If the user has one active go.mod file, they may still be editing files
-	// in nested modules. Check the module of each open file and add warnings
-	// that the nested module must be opened as a workspace folder.
-	if len(s.workspaceModFiles) == 1 {
-		// Get the active root go.mod file to compare against.
-		var rootMod string
-		for uri := range s.workspaceModFiles {
-			rootMod = uri.Filename()
-		}
-		rootDir := filepath.Dir(rootMod)
-		nestedModules := make(map[string][]*Overlay)
-		for _, fh := range openFiles {
-			mod, err := findRootPattern(ctx, filepath.Dir(fh.URI().Filename()), "go.mod", s)
-			if err != nil {
-				if ctx.Err() != nil {
-					return ctx.Err(), nil
-				}
-				continue
-			}
-			if mod == "" {
-				continue
-			}
-			if mod != rootMod && source.InDir(rootDir, mod) {
-				modDir := filepath.Dir(mod)
-				nestedModules[modDir] = append(nestedModules[modDir], fh)
-			}
-		}
-		var multiModuleMsg string
-		if s.view.goversion >= 18 {
-			multiModuleMsg = `To work on multiple modules at once, please use a go.work file.
-See https://github.com/golang/tools/blob/master/gopls/doc/workspace.md for more information on using workspaces.`
-		} else {
-			multiModuleMsg = `To work on multiple modules at once, please upgrade to Go 1.18 and use a go.work file.
-See https://github.com/golang/tools/blob/master/gopls/doc/workspace.md for more information on using workspaces.`
-		}
-		// Add a diagnostic to each file in a nested module to mark it as
-		// "orphaned". Don't show a general diagnostic in the progress bar,
-		// because the user may still want to edit a file in a nested module.
-		var srcDiags []*source.Diagnostic
-		for modDir, files := range nestedModules {
-			msg := fmt.Sprintf("This file is in %s, which is a nested module in the %s module.\n%s", modDir, rootMod, multiModuleMsg)
-			srcDiags = append(srcDiags, s.applyCriticalErrorToFiles(ctx, msg, files)...)
-		}
-		if len(srcDiags) != 0 {
-			return fmt.Errorf("You have opened a nested module.\n%s", multiModuleMsg), srcDiags
-		}
-	}
 	return nil, nil
 }
 
diff --git a/gopls/internal/lsp/cache/maps.go b/gopls/internal/lsp/cache/maps.go
index 0ad4ac9..533c339 100644
--- a/gopls/internal/lsp/cache/maps.go
+++ b/gopls/internal/lsp/cache/maps.go
@@ -15,7 +15,8 @@
 // TODO(euroelessar): Use generics once support for go1.17 is dropped.
 
 type filesMap struct {
-	impl *persistent.Map
+	impl       *persistent.Map
+	overlayMap map[span.URI]*Overlay // the subset that are overlays
 }
 
 // uriLessInterface is the < relation for "any" values containing span.URIs.
@@ -25,13 +26,19 @@
 
 func newFilesMap() filesMap {
 	return filesMap{
-		impl: persistent.NewMap(uriLessInterface),
+		impl:       persistent.NewMap(uriLessInterface),
+		overlayMap: make(map[span.URI]*Overlay),
 	}
 }
 
 func (m filesMap) Clone() filesMap {
+	overlays := make(map[span.URI]*Overlay, len(m.overlayMap))
+	for k, v := range m.overlayMap {
+		overlays[k] = v
+	}
 	return filesMap{
-		impl: m.impl.Clone(),
+		impl:       m.impl.Clone(),
+		overlayMap: overlays,
 	}
 }
 
@@ -55,10 +62,30 @@
 
 func (m filesMap) Set(key span.URI, value source.FileHandle) {
 	m.impl.Set(key, value, nil)
+
+	if o, ok := value.(*Overlay); ok {
+		m.overlayMap[key] = o
+	} else {
+		// Setting a non-overlay must delete the corresponding overlay, to preserve
+		// the accuracy of the overlay set.
+		delete(m.overlayMap, key)
+	}
 }
 
-func (m filesMap) Delete(key span.URI) {
+func (m *filesMap) Delete(key span.URI) {
 	m.impl.Delete(key)
+	delete(m.overlayMap, key)
+}
+
+// overlays returns a new unordered array of overlay files.
+func (m filesMap) overlays() []*Overlay {
+	// In practice we will always have at least one overlay, so there is no need
+	// to optimize for the len=0 case by returning a nil slice.
+	overlays := make([]*Overlay, 0, len(m.overlayMap))
+	for _, o := range m.overlayMap {
+		overlays = append(overlays, o)
+	}
+	return overlays
 }
 
 func packageIDLessInterface(x, y interface{}) bool {
diff --git a/gopls/internal/lsp/cache/mod_tidy.go b/gopls/internal/lsp/cache/mod_tidy.go
index b5e2dea..8dd555d 100644
--- a/gopls/internal/lsp/cache/mod_tidy.go
+++ b/gopls/internal/lsp/cache/mod_tidy.go
@@ -183,7 +183,33 @@
 	// go.mod file. The fixes will be for the go.mod file, but the
 	// diagnostics should also appear in both the go.mod file and the import
 	// statements in the Go files in which the dependencies are used.
+	// Finally, add errors for any unused dependencies.
+	if len(missing) > 0 {
+		missingModuleDiagnostics, err := missingModuleDiagnostics(ctx, snapshot, pm, ideal, missing)
+		if err != nil {
+			return nil, err
+		}
+		diagnostics = append(diagnostics, missingModuleDiagnostics...)
+	}
+
+	// Opt: if this is the only diagnostic, we can avoid textual edits and just
+	// run the Go command.
+	//
+	// See also the documentation for command.RemoveDependencyArgs.OnlyDiagnostic.
+	onlyDiagnostic := len(diagnostics) == 0 && len(unused) == 1
+	for _, req := range unused {
+		srcErr, err := unusedDiagnostic(pm.Mapper, req, onlyDiagnostic)
+		if err != nil {
+			return nil, err
+		}
+		diagnostics = append(diagnostics, srcErr)
+	}
+	return diagnostics, nil
+}
+
+func missingModuleDiagnostics(ctx context.Context, snapshot *snapshot, pm *source.ParsedModule, ideal *modfile.File, missing map[string]*modfile.Require) ([]*source.Diagnostic, error) {
 	missingModuleFixes := map[*modfile.Require][]source.SuggestedFix{}
+	var diagnostics []*source.Diagnostic
 	for _, req := range missing {
 		srcDiag, err := missingModuleDiagnostic(pm, req)
 		if err != nil {
@@ -290,15 +316,6 @@
 			}
 		}
 	}
-	// Finally, add errors for any unused dependencies.
-	onlyDiagnostic := len(diagnostics) == 0 && len(unused) == 1
-	for _, req := range unused {
-		srcErr, err := unusedDiagnostic(pm.Mapper, req, onlyDiagnostic)
-		if err != nil {
-			return nil, err
-		}
-		diagnostics = append(diagnostics, srcErr)
-	}
 	return diagnostics, nil
 }
 
diff --git a/gopls/internal/lsp/cache/session.go b/gopls/internal/lsp/cache/session.go
index eaad67c..8eae64e 100644
--- a/gopls/internal/lsp/cache/session.go
+++ b/gopls/internal/lsp/cache/session.go
@@ -109,13 +109,14 @@
 
 // TODO(rfindley): clarify that createView can never be cancelled (with the
 // possible exception of server shutdown).
+// On success, the caller becomes responsible for calling the release function once.
 func (s *Session) createView(ctx context.Context, name string, folder span.URI, options *source.Options, seqID uint64) (*View, *snapshot, func(), error) {
 	index := atomic.AddInt64(&viewIndex, 1)
 
 	// Get immutable workspace information.
 	info, err := s.getWorkspaceInformation(ctx, folder, options)
 	if err != nil {
-		return nil, nil, func() {}, err
+		return nil, nil, nil, err
 	}
 
 	gowork, _ := info.GOWORK()
@@ -327,6 +328,15 @@
 	}
 
 	v, snapshot, release, err := s.createView(ctx, view.name, view.folder, options, seqID)
+	if err != nil {
+		// we have dropped the old view, but could not create the new one
+		// this should not happen and is very bad, but we still need to clean
+		// up the view array if it happens
+		s.views = removeElement(s.views, i)
+		return nil, err
+	}
+	defer release()
+
 	// The new snapshot has lost the history of the previous view. As a result,
 	// it may not see open files that aren't in its build configuration (as it
 	// would have done via didOpen notifications). This can lead to inconsistent
@@ -336,15 +346,7 @@
 	for _, o := range v.fs.Overlays() {
 		_, _ = snapshot.ReadFile(ctx, o.URI())
 	}
-	release()
 
-	if err != nil {
-		// we have dropped the old view, but could not create the new one
-		// this should not happen and is very bad, but we still need to clean
-		// up the view array if it happens
-		s.views = removeElement(s.views, i)
-		return nil, err
-	}
 	// substitute the new view into the array where the old view was
 	s.views[i] = v
 	return v, nil
@@ -596,20 +598,17 @@
 	for _, c := range changes {
 		if !knownDirs.Contains(c.URI) {
 			result = append(result, c)
-			continue
+		} else {
+			for uri := range knownFilesInDir(ctx, snapshots, c.URI) {
+				result = append(result, source.FileModification{
+					URI:        uri,
+					Action:     c.Action,
+					LanguageID: "",
+					OnDisk:     c.OnDisk,
+					// changes to directories cannot include text or versions
+				})
+			}
 		}
-		affectedFiles := knownFilesInDir(ctx, snapshots, c.URI)
-		var fileChanges []source.FileModification
-		for uri := range affectedFiles {
-			fileChanges = append(fileChanges, source.FileModification{
-				URI:        uri,
-				Action:     c.Action,
-				LanguageID: "",
-				OnDisk:     c.OnDisk,
-				// changes to directories cannot include text or versions
-			})
-		}
-		result = append(result, fileChanges...)
 	}
 	return result
 }
@@ -738,9 +737,10 @@
 	return nil
 }
 
-// FileWatchingGlobPatterns returns glob patterns to watch every directory
-// known by the view. For views within a module, this is the module root,
-// any directory in the module root, and any replace targets.
+// FileWatchingGlobPatterns returns a new set of glob patterns to
+// watch every directory known by the view. For views within a module,
+// this is the module root, any directory in the module root, and any
+// replace targets.
 func (s *Session) FileWatchingGlobPatterns(ctx context.Context) map[string]struct{} {
 	s.viewMu.Lock()
 	defer s.viewMu.Unlock()
diff --git a/gopls/internal/lsp/cache/snapshot.go b/gopls/internal/lsp/cache/snapshot.go
index 7988a72..de9524b 100644
--- a/gopls/internal/lsp/cache/snapshot.go
+++ b/gopls/internal/lsp/cache/snapshot.go
@@ -159,10 +159,10 @@
 	modWhyHandles  *persistent.Map // from span.URI to *memoize.Promise[modWhyResult]
 	modVulnHandles *persistent.Map // from span.URI to *memoize.Promise[modVulnResult]
 
-	// knownSubdirs is the set of subdirectories in the workspace, used to
-	// create glob patterns for file watching.
-	knownSubdirs             knownDirsSet
-	knownSubdirsPatternCache string
+	// knownSubdirs is the set of subdirectory URIs in the workspace,
+	// used to create glob patterns for file watching.
+	knownSubdirs      knownDirsSet
+	knownSubdirsCache map[string]struct{} // memo of knownSubdirs as a set of filenames
 	// unprocessedSubdirChanges are any changes that might affect the set of
 	// subdirectories in the workspace. They are not reflected to knownSubdirs
 	// during the snapshot cloning step as it can slow down cloning.
@@ -327,47 +327,19 @@
 	if s.view.hasGopackagesDriver {
 		return true
 	}
+
 	// Check if the user is working within a module or if we have found
 	// multiple modules in the workspace.
 	if len(s.workspaceModFiles) > 0 {
 		return true
 	}
-	// The user may have a multiple directories in their GOPATH.
-	// Check if the workspace is within any of them.
+
 	// TODO(rfindley): this should probably be subject to "if GO111MODULES = off {...}".
-	for _, gp := range filepath.SplitList(s.view.gopath) {
-		if source.InDir(filepath.Join(gp, "src"), s.view.folder.Filename()) {
-			return true
-		}
-	}
-	return false
-}
-
-// moduleMode reports whether the current snapshot uses Go modules.
-//
-// From https://go.dev/ref/mod, module mode is active if either of the
-// following hold:
-//   - GO111MODULE=on
-//   - GO111MODULE=auto and we are inside a module or have a GOWORK value.
-//
-// Additionally, this method returns false if GOPACKAGESDRIVER is set.
-//
-// TODO(rfindley): use this more widely.
-func (s *snapshot) moduleMode() bool {
-	// Since we only really understand the `go` command, if the user has a
-	// different GOPACKAGESDRIVER, assume that their configuration is valid.
-	if s.view.hasGopackagesDriver {
-		return false
-	}
-
-	switch s.view.effectiveGO111MODULE() {
-	case on:
+	if s.view.inGOPATH {
 		return true
-	case off:
-		return false
-	default:
-		return len(s.workspaceModFiles) > 0 || s.view.gowork != ""
 	}
+
+	return false
 }
 
 // workspaceMode describes the way in which the snapshot's workspace should
@@ -652,21 +624,11 @@
 	return overlays
 }
 
-// TODO(rfindley): investigate whether it would be worthwhile to keep track of
-// overlays when we get them via GetFile.
 func (s *snapshot) overlays() []*Overlay {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	var overlays []*Overlay
-	s.files.Range(func(uri span.URI, fh source.FileHandle) {
-		overlay, ok := fh.(*Overlay)
-		if !ok {
-			return
-		}
-		overlays = append(overlays, overlay)
-	})
-	return overlays
+	return s.files.overlays()
 }
 
 // Package data kinds, identifying various package data that may be stored in
@@ -763,6 +725,18 @@
 }
 
 func (s *snapshot) MetadataForFile(ctx context.Context, uri span.URI) ([]*source.Metadata, error) {
+	if s.view.ViewType() == AdHocView {
+		// As described in golang/go#57209, in ad-hoc workspaces (where we load ./
+		// rather than ./...), preempting the directory load with file loads can
+		// lead to an inconsistent outcome, where certain files are loaded with
+		// command-line-arguments packages and others are loaded only in the ad-hoc
+		// package. Therefore, ensure that the workspace is loaded before doing any
+		// file loads.
+		if err := s.awaitLoaded(ctx); err != nil {
+			return nil, err
+		}
+	}
+
 	s.mu.Lock()
 
 	// Start with the set of package associations derived from the last load.
@@ -962,19 +936,57 @@
 		patterns[fmt.Sprintf("%s/**/*.{%s}", dirName, extensions)] = struct{}{}
 	}
 
-	// Some clients do not send notifications for changes to directories that
-	// contain Go code (golang/go#42348). To handle this, explicitly watch all
-	// of the directories in the workspace. We find them by adding the
-	// directories of every file in the snapshot's workspace directories.
-	// There may be thousands.
-	if pattern := s.getKnownSubdirsPattern(dirs); pattern != "" {
-		patterns[pattern] = struct{}{}
+	if s.watchSubdirs() {
+		// Some clients (e.g. VS Code) do not send notifications for changes to
+		// directories that contain Go code (golang/go#42348). To handle this,
+		// explicitly watch all of the directories in the workspace. We find them
+		// by adding the directories of every file in the snapshot's workspace
+		// directories. There may be thousands of patterns, each a single
+		// directory.
+		//
+		// (A previous iteration created a single glob pattern holding a union of
+		// all the directories, but this was found to cause VS Code to get stuck
+		// for several minutes after a buffer was saved twice in a workspace that
+		// had >8000 watched directories.)
+		//
+		// Some clients (notably coc.nvim, which uses watchman for globs) perform
+		// poorly with a large list of individual directories.
+		s.addKnownSubdirs(patterns, dirs)
 	}
 
 	return patterns
 }
 
-func (s *snapshot) getKnownSubdirsPattern(wsDirs []span.URI) string {
+// watchSubdirs reports whether gopls should request separate file watchers for
+// each relevant subdirectory. This is necessary only for clients (namely VS
+// Code) that do not send notifications for individual files in a directory
+// when the entire directory is deleted.
+func (s *snapshot) watchSubdirs() bool {
+	opts := s.view.Options()
+	switch p := opts.SubdirWatchPatterns; p {
+	case source.SubdirWatchPatternsOn:
+		return true
+	case source.SubdirWatchPatternsOff:
+		return false
+	case source.SubdirWatchPatternsAuto:
+		// See the documentation of InternalOptions.SubdirWatchPatterns for an
+		// explanation of why VS Code gets a different default value here.
+		//
+		// Unfortunately, there is no authoritative list of client names, nor any
+		// requirements that client names do not change. We should update the VS
+		// Code extension to set a default value of "subdirWatchPatterns" to "on",
+		// so that this workaround is only temporary.
+		if opts.ClientInfo != nil && opts.ClientInfo.Name == "Visual Studio Code" {
+			return true
+		}
+		return false
+	default:
+		bug.Reportf("invalid subdirWatchPatterns: %q", p)
+		return false
+	}
+}
+
+func (s *snapshot) addKnownSubdirs(patterns map[string]struct{}, wsDirs []span.URI) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -983,23 +995,18 @@
 	// It may change list of known subdirs and therefore invalidate the cache.
 	s.applyKnownSubdirsChangesLocked(wsDirs)
 
-	if s.knownSubdirsPatternCache == "" {
-		var builder strings.Builder
+	// TODO(adonovan): is it still necessary to memoize the Range
+	// and URI.Filename operations?
+	if s.knownSubdirsCache == nil {
+		s.knownSubdirsCache = make(map[string]struct{})
 		s.knownSubdirs.Range(func(uri span.URI) {
-			if builder.Len() == 0 {
-				builder.WriteString("{")
-			} else {
-				builder.WriteString(",")
-			}
-			builder.WriteString(uri.Filename())
+			s.knownSubdirsCache[uri.Filename()] = struct{}{}
 		})
-		if builder.Len() > 0 {
-			builder.WriteString("}")
-			s.knownSubdirsPatternCache = builder.String()
-		}
 	}
 
-	return s.knownSubdirsPatternCache
+	for pattern := range s.knownSubdirsCache {
+		patterns[pattern] = struct{}{}
+	}
 }
 
 // collectAllKnownSubdirs collects all of the subdirectories within the
@@ -1013,7 +1020,7 @@
 
 	s.knownSubdirs.Destroy()
 	s.knownSubdirs = newKnownDirsSet()
-	s.knownSubdirsPatternCache = ""
+	s.knownSubdirsCache = nil
 	s.files.Range(func(uri span.URI, fh source.FileHandle) {
 		s.addKnownSubdirLocked(uri, dirs)
 	})
@@ -1072,7 +1079,7 @@
 		}
 		s.knownSubdirs.Insert(uri)
 		dir = filepath.Dir(dir)
-		s.knownSubdirsPatternCache = ""
+		s.knownSubdirsCache = nil
 	}
 }
 
@@ -1085,7 +1092,7 @@
 		}
 		if info, _ := os.Stat(dir); info == nil {
 			s.knownSubdirs.Remove(uri)
-			s.knownSubdirsPatternCache = ""
+			s.knownSubdirsCache = nil
 		}
 		dir = filepath.Dir(dir)
 	}
@@ -1849,7 +1856,7 @@
 					fix = `To work with multiple modules simultaneously, please upgrade to Go 1.18 or
 later, reinstall gopls, and use a go.work file.`
 				}
-				msg = fmt.Sprintf(`This file is in directory %q, which is not included in your workspace.
+				msg = fmt.Sprintf(`This file is within module %q, which is not included in your workspace.
 %s
 See the documentation for more information on setting up your workspace:
 https://github.com/golang/tools/blob/master/gopls/doc/workspace.md.`, modDir, fix)
@@ -2050,7 +2057,7 @@
 	// changed files. We need to rebuild the workspace module to know the
 	// true set of known subdirectories, but we don't want to do that in clone.
 	result.knownSubdirs = s.knownSubdirs.Clone()
-	result.knownSubdirsPatternCache = s.knownSubdirsPatternCache
+	result.knownSubdirsCache = s.knownSubdirsCache
 	for _, c := range changes {
 		result.unprocessedSubdirChanges = append(result.unprocessedSubdirChanges, c)
 	}
@@ -2109,10 +2116,36 @@
 		// Invalidate the previous modTidyHandle if any of the files have been
 		// saved or if any of the metadata has been invalidated.
 		if invalidateMetadata || fileWasSaved(originalFH, change.fileHandle) {
-			// TODO(maybe): Only delete mod handles for
-			// which the withoutURI is relevant.
-			// Requires reverse-engineering the go command. (!)
-			result.modTidyHandles.Clear()
+			// Only invalidate mod tidy results for the most relevant modfile in the
+			// workspace. This is a potentially lossy optimization for workspaces
+			// with many modules (such as google-cloud-go, which has 145 modules as
+			// of writing).
+			//
+			// While it is theoretically possible that a change in workspace module A
+			// could affect the mod-tidiness of workspace module B (if B transitively
+			// requires A), such changes are probably unlikely and not worth the
+			// penalty of re-running go mod tidy for everything. Note that mod tidy
+			// ignores GOWORK, so the two modules would have to be related by a chain
+			// of replace directives.
+			//
+			// We could improve accuracy by inspecting replace directives, using
+			// overlays in go mod tidy, and/or checking for metadata changes from the
+			// on-disk content.
+			//
+			// Note that we iterate the modTidyHandles map here, rather than e.g.
+			// using nearestModFile, because we don't have access to an accurate
+			// FileSource at this point in the snapshot clone.
+			const onlyInvalidateMostRelevant = true
+			if onlyInvalidateMostRelevant {
+				deleteMostRelevantModFile(result.modTidyHandles, uri)
+			} else {
+				result.modTidyHandles.Clear()
+			}
+
+			// TODO(rfindley): should we apply the above heuristic to mod vuln
+			// or mod handles as well?
+			//
+			// TODO(rfindley): no tests fail if I delete the below line.
 			result.modWhyHandles.Clear()
 			result.modVulnHandles.Clear()
 		}
@@ -2303,6 +2336,31 @@
 	return result, release
 }
 
+// deleteMostRelevantModFile deletes the mod file most likely to be the mod
+// file for the changed URI, if it exists.
+//
+// Specifically, this is the longest mod file path in a directory containing
+// changed. This might not be accurate if there is another mod file closer to
+// changed that happens not to be present in the map, but that's OK: the goal
+// of this function is to guarantee that IF the nearest mod file is present in
+// the map, it is invalidated.
+func deleteMostRelevantModFile(m *persistent.Map, changed span.URI) {
+	var mostRelevant span.URI
+	changedFile := changed.Filename()
+
+	m.Range(func(key, value interface{}) {
+		modURI := key.(span.URI)
+		if len(modURI) > len(mostRelevant) {
+			if source.InDir(filepath.Dir(modURI.Filename()), changedFile) {
+				mostRelevant = modURI
+			}
+		}
+	})
+	if mostRelevant != "" {
+		m.Delete(mostRelevant)
+	}
+}
+
 // invalidatedPackageIDs returns all packages invalidated by a change to uri.
 // If we haven't seen this URI before, we guess based on files in the same
 // directory. This is of course incorrect in build systems where packages are
diff --git a/gopls/internal/lsp/cache/view.go b/gopls/internal/lsp/cache/view.go
index d999170..1dc13aa 100644
--- a/gopls/internal/lsp/cache/view.go
+++ b/gopls/internal/lsp/cache/view.go
@@ -130,6 +130,10 @@
 	// GOPACKAGESDRIVER environment variable or a gopackagesdriver binary on
 	// their machine.
 	hasGopackagesDriver bool
+
+	// inGOPATH reports whether the workspace directory is contained in a GOPATH
+	// directory.
+	inGOPATH bool
 }
 
 // effectiveGO111MODULE reports the value of GO111MODULE effective in the go
@@ -145,6 +149,79 @@
 	}
 }
 
+// A ViewType describes how we load package information for a view.
+//
+// This is used for constructing the go/packages.Load query, and for
+// interpreting missing packages, imports, or errors.
+//
+// Each view has a ViewType which is derived from its immutable workspace
+// information -- any environment change that would affect the view type
+// results in a new view.
+type ViewType int
+
+const (
+	// GoPackagesDriverView is a view with a non-empty GOPACKAGESDRIVER
+	// environment variable.
+	GoPackagesDriverView ViewType = iota
+
+	// GOPATHView is a view in GOPATH mode.
+	//
+	// I.e. in GOPATH, with GO111MODULE=off, or GO111MODULE=auto with no
+	// go.mod file.
+	GOPATHView
+
+	// GoModuleView is a view in module mode with a single Go module.
+	GoModuleView
+
+	// GoWorkView is a view in module mode with a go.work file.
+	GoWorkView
+
+	// An AdHocView is a collection of files in a given directory, not in GOPATH
+	// or a module.
+	AdHocView
+)
+
+// ViewType derives the type of the view from its workspace information.
+//
+// TODO(rfindley): this logic is overlapping and slightly inconsistent with
+// validBuildConfiguration. As part of zero-config-gopls (golang/go#57979), fix
+// this inconsistency and consolidate on the ViewType abstraction.
+func (w workspaceInformation) ViewType() ViewType {
+	if w.hasGopackagesDriver {
+		return GoPackagesDriverView
+	}
+	go111module := w.effectiveGO111MODULE()
+	if w.gowork != "" && go111module != off {
+		return GoWorkView
+	}
+	if w.gomod != "" && go111module != off {
+		return GoModuleView
+	}
+	if w.inGOPATH && go111module != on {
+		return GOPATHView
+	}
+	return AdHocView
+}
+
+// moduleMode reports whether the current snapshot uses Go modules.
+//
+// From https://go.dev/ref/mod, module mode is active if either of the
+// following hold:
+//   - GO111MODULE=on
+//   - GO111MODULE=auto and we are inside a module or have a GOWORK value.
+//
+// Additionally, this method returns false if GOPACKAGESDRIVER is set.
+//
+// TODO(rfindley): use this more widely.
+func (w workspaceInformation) moduleMode() bool {
+	switch w.ViewType() {
+	case GoModuleView, GoWorkView:
+		return true
+	default:
+		return false
+	}
+}
+
 // GOWORK returns the effective GOWORK value for this workspace, if
 // any, in URI form.
 //
@@ -740,6 +817,8 @@
 		})
 	}
 
+	// TODO(rfindley): this should be predicated on the s.view.moduleMode().
+	// There is no point loading ./... if we have an empty go.work.
 	if len(s.workspaceModFiles) > 0 {
 		for modURI := range s.workspaceModFiles {
 			// Verify that the modfile is valid before trying to load it.
@@ -881,7 +960,7 @@
 	if err != nil {
 		return info, err
 	}
-	if err := info.goEnv.load(ctx, folder.Filename(), options.EnvSlice(), s.gocmdRunner); err != nil {
+	if err := info.load(ctx, folder.Filename(), options.EnvSlice(), s.gocmdRunner); err != nil {
 		return info, err
 	}
 	// The value of GOPACKAGESDRIVER is not returned through the go command.
@@ -899,6 +978,13 @@
 		return info, err
 	}
 
+	// Check if the workspace is within any GOPATH directory.
+	for _, gp := range filepath.SplitList(info.gopath) {
+		if source.InDir(filepath.Join(gp, "src"), folder.Filename()) {
+			info.inGOPATH = true
+			break
+		}
+	}
 	return info, nil
 }
 
diff --git a/gopls/internal/lsp/cache/workspace.go b/gopls/internal/lsp/cache/workspace.go
index de36da6..28179f5 100644
--- a/gopls/internal/lsp/cache/workspace.go
+++ b/gopls/internal/lsp/cache/workspace.go
@@ -8,6 +8,7 @@
 	"context"
 	"errors"
 	"fmt"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"sort"
@@ -127,7 +128,10 @@
 
 // Limit go.mod search to 1 million files. As a point of reference,
 // Kubernetes has 22K files (as of 2020-11-24).
-const fileLimit = 1000000
+//
+// Note: per golang/go#56496, the previous limit of 1M files was too slow, at
+// which point this limit was decreased to 100K.
+const fileLimit = 100_000
 
 // findModules recursively walks the root directory looking for go.mod files,
 // returning the set of modules it discovers. If modLimit is non-zero,
@@ -139,7 +143,7 @@
 	modFiles := make(map[span.URI]struct{})
 	searched := 0
 	errDone := errors.New("done")
-	err := filepath.Walk(root.Filename(), func(path string, info os.FileInfo, err error) error {
+	err := filepath.WalkDir(root.Filename(), func(path string, info fs.DirEntry, err error) error {
 		if err != nil {
 			// Probably a permission error. Keep looking.
 			return filepath.SkipDir
diff --git a/gopls/internal/lsp/cmd/capabilities_test.go b/gopls/internal/lsp/cmd/capabilities_test.go
index 39b60af..6d4e32f 100644
--- a/gopls/internal/lsp/cmd/capabilities_test.go
+++ b/gopls/internal/lsp/cmd/capabilities_test.go
@@ -41,17 +41,16 @@
 	defer os.RemoveAll(tmpDir)
 
 	app := New("gopls-test", tmpDir, os.Environ(), nil)
-	c := newConnection(app, nil)
-	ctx := context.Background()
-	defer c.terminate(ctx)
 
 	params := &protocol.ParamInitialize{}
-	params.RootURI = protocol.URIFromPath(c.Client.app.wd)
+	params.RootURI = protocol.URIFromPath(app.wd)
 	params.Capabilities.Workspace.Configuration = true
 
 	// Send an initialize request to the server.
-	c.Server = lsp.NewServer(cache.NewSession(ctx, cache.New(nil), app.options), c.Client)
-	result, err := c.Server.Initialize(ctx, params)
+	ctx := context.Background()
+	client := newClient(app, nil)
+	server := lsp.NewServer(cache.NewSession(ctx, cache.New(nil), app.options), client)
+	result, err := server.Initialize(ctx, params)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -60,10 +59,13 @@
 		t.Error(err)
 	}
 	// Complete initialization of server.
-	if err := c.Server.Initialized(ctx, &protocol.InitializedParams{}); err != nil {
+	if err := server.Initialized(ctx, &protocol.InitializedParams{}); err != nil {
 		t.Fatal(err)
 	}
 
+	c := newConnection(server, client)
+	defer c.terminate(ctx)
+
 	// Open the file on the server side.
 	uri := protocol.URIFromPath(tmpFile)
 	if err := c.Server.DidOpen(ctx, &protocol.DidOpenTextDocumentParams{
diff --git a/gopls/internal/lsp/cmd/check.go b/gopls/internal/lsp/cmd/check.go
index f501c44..a529f14 100644
--- a/gopls/internal/lsp/cmd/check.go
+++ b/gopls/internal/lsp/cmd/check.go
@@ -57,8 +57,8 @@
 	if err := conn.diagnoseFiles(ctx, uris); err != nil {
 		return err
 	}
-	conn.Client.filesMu.Lock()
-	defer conn.Client.filesMu.Unlock()
+	conn.client.filesMu.Lock()
+	defer conn.client.filesMu.Unlock()
 
 	for _, file := range checking {
 		for _, d := range file.diagnostics {
diff --git a/gopls/internal/lsp/cmd/cmd.go b/gopls/internal/lsp/cmd/cmd.go
index 02e135a..0bd636c 100644
--- a/gopls/internal/lsp/cmd/cmd.go
+++ b/gopls/internal/lsp/cmd/cmd.go
@@ -293,10 +293,14 @@
 func (app *Application) connect(ctx context.Context, onProgress func(*protocol.ProgressParams)) (*connection, error) {
 	switch {
 	case app.Remote == "":
-		connection := newConnection(app, onProgress)
-		connection.Server = lsp.NewServer(cache.NewSession(ctx, cache.New(nil), app.options), connection.Client)
-		ctx = protocol.WithClient(ctx, connection.Client)
-		return connection, connection.initialize(ctx, app.options)
+		client := newClient(app, onProgress)
+		server := lsp.NewServer(cache.NewSession(ctx, cache.New(nil), app.options), client)
+		conn := newConnection(server, client)
+		if err := conn.initialize(protocol.WithClient(ctx, client), app.options); err != nil {
+			return nil, err
+		}
+		return conn, nil
+
 	case strings.HasPrefix(app.Remote, "internal@"):
 		internalMu.Lock()
 		defer internalMu.Unlock()
@@ -331,19 +335,19 @@
 }
 
 func (app *Application) connectRemote(ctx context.Context, remote string) (*connection, error) {
-	connection := newConnection(app, nil)
 	conn, err := lsprpc.ConnectToRemote(ctx, remote)
 	if err != nil {
 		return nil, err
 	}
 	stream := jsonrpc2.NewHeaderStream(conn)
 	cc := jsonrpc2.NewConn(stream)
-	connection.Server = protocol.ServerDispatcher(cc)
-	ctx = protocol.WithClient(ctx, connection.Client)
+	server := protocol.ServerDispatcher(cc)
+	client := newClient(app, nil)
+	connection := newConnection(server, client)
+	ctx = protocol.WithClient(ctx, connection.client)
 	cc.Go(ctx,
 		protocol.Handlers(
-			protocol.ClientHandler(connection.Client,
-				jsonrpc2.MethodNotFound)))
+			protocol.ClientHandler(client, jsonrpc2.MethodNotFound)))
 	return connection, connection.initialize(ctx, app.options)
 }
 
@@ -355,7 +359,7 @@
 
 func (c *connection) initialize(ctx context.Context, options func(*source.Options)) error {
 	params := &protocol.ParamInitialize{}
-	params.RootURI = protocol.URIFromPath(c.Client.app.wd)
+	params.RootURI = protocol.URIFromPath(c.client.app.wd)
 	params.Capabilities.Workspace.Configuration = true
 
 	// Make sure to respect configured options when sending initialize request.
@@ -377,7 +381,7 @@
 
 	// If the subcommand has registered a progress handler, report the progress
 	// capability.
-	if c.Client.onProgress != nil {
+	if c.client.onProgress != nil {
 		params.Capabilities.Window.WorkDoneProgress = true
 	}
 
@@ -395,11 +399,10 @@
 
 type connection struct {
 	protocol.Server
-	Client *cmdClient
+	client *cmdClient
 }
 
 type cmdClient struct {
-	protocol.Server
 	app        *Application
 	onProgress func(*protocol.ProgressParams)
 
@@ -417,13 +420,18 @@
 	diagnostics []protocol.Diagnostic
 }
 
-func newConnection(app *Application, onProgress func(*protocol.ProgressParams)) *connection {
+func newClient(app *Application, onProgress func(*protocol.ProgressParams)) *cmdClient {
+	return &cmdClient{
+		app:        app,
+		onProgress: onProgress,
+		files:      make(map[span.URI]*cmdFile),
+	}
+}
+
+func newConnection(server protocol.Server, client *cmdClient) *connection {
 	return &connection{
-		Client: &cmdClient{
-			app:        app,
-			onProgress: onProgress,
-			files:      make(map[span.URI]*cmdFile),
-		},
+		Server: server,
+		client: client,
 	}
 }
 
@@ -518,11 +526,6 @@
 }
 
 func (c *cmdClient) PublishDiagnostics(ctx context.Context, p *protocol.PublishDiagnosticsParams) error {
-	var debug = os.Getenv(DebugSuggestedFixEnvVar) == "true"
-	if debug {
-		log.Printf("PublishDiagnostics URI=%v Diagnostics=%v", p.URI, p.Diagnostics)
-	}
-
 	if p.URI == "gopls://diagnostics-done" {
 		close(c.diagnosticsDone)
 	}
@@ -616,7 +619,7 @@
 // - map a (URI, protocol.Range) to a MappedRange;
 // - parse a command-line argument to a MappedRange.
 func (c *connection) openFile(ctx context.Context, uri span.URI) (*cmdFile, error) {
-	file := c.Client.openFile(ctx, uri)
+	file := c.client.openFile(ctx, uri)
 	if file.err != nil {
 		return nil, file.err
 	}
@@ -651,22 +654,22 @@
 	for _, file := range files {
 		untypedFiles = append(untypedFiles, string(file))
 	}
-	c.Client.diagnosticsMu.Lock()
-	defer c.Client.diagnosticsMu.Unlock()
+	c.client.diagnosticsMu.Lock()
+	defer c.client.diagnosticsMu.Unlock()
 
-	c.Client.diagnosticsDone = make(chan struct{})
+	c.client.diagnosticsDone = make(chan struct{})
 	_, err := c.Server.NonstandardRequest(ctx, "gopls/diagnoseFiles", map[string]interface{}{"files": untypedFiles})
 	if err != nil {
-		close(c.Client.diagnosticsDone)
+		close(c.client.diagnosticsDone)
 		return err
 	}
 
-	<-c.Client.diagnosticsDone
+	<-c.client.diagnosticsDone
 	return nil
 }
 
 func (c *connection) terminate(ctx context.Context) {
-	if strings.HasPrefix(c.Client.app.Remote, "internal@") {
+	if strings.HasPrefix(c.client.app.Remote, "internal@") {
 		// internal connections need to be left alive for the next test
 		return
 	}
diff --git a/gopls/internal/lsp/cmd/serve.go b/gopls/internal/lsp/cmd/serve.go
index df42e79..03cc187 100644
--- a/gopls/internal/lsp/cmd/serve.go
+++ b/gopls/internal/lsp/cmd/serve.go
@@ -90,7 +90,6 @@
 		}
 		defer closeLog()
 		di.ServerAddress = s.Address
-		di.MonitorMemory(ctx)
 		di.Serve(ctx, s.Debug)
 	}
 	var ss jsonrpc2.StreamServer
diff --git a/gopls/internal/lsp/cmd/stats.go b/gopls/internal/lsp/cmd/stats.go
index 1b9df2f..a681c5c 100644
--- a/gopls/internal/lsp/cmd/stats.go
+++ b/gopls/internal/lsp/cmd/stats.go
@@ -9,9 +9,11 @@
 	"encoding/json"
 	"flag"
 	"fmt"
+	"go/token"
 	"io/fs"
 	"os"
 	"path/filepath"
+	"reflect"
 	"runtime"
 	"strings"
 	"sync"
@@ -24,10 +26,13 @@
 	"golang.org/x/tools/gopls/internal/lsp/filecache"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
 	"golang.org/x/tools/gopls/internal/lsp/source"
+	"golang.org/x/tools/internal/event"
 )
 
 type stats struct {
 	app *Application
+
+	Anon bool `flag:"anon" help:"hide any fields that may contain user names, file names, or source code"`
 }
 
 func (s *stats) Name() string      { return "stats" }
@@ -41,14 +46,17 @@
 workspace information relevant to performance. As a side effect, this command
 populates the gopls file cache for the current workspace.
 
+By default, this command may include output that refers to the location or
+content of user code. When the -anon flag is set, fields that may refer to user
+code are hidden.
+
 Example:
-  $ gopls stats
+  $ gopls stats -anon
 `)
 	printFlagDefaults(f)
 }
 
 func (s *stats) Run(ctx context.Context, args ...string) error {
-
 	// This undocumented environment variable allows
 	// the cmd integration test to trigger a call to bug.Report.
 	if msg := os.Getenv("TEST_GOPLS_BUG"); msg != "" {
@@ -65,9 +73,14 @@
 		return fmt.Errorf("the stats subcommand does not work with -remote")
 	}
 
+	if !s.app.Verbose {
+		event.SetExporter(nil) // don't log errors to stderr
+	}
+
 	stats := GoplsStats{
 		GOOS:         runtime.GOOS,
 		GOARCH:       runtime.GOARCH,
+		GOPLSCACHE:   os.Getenv("GOPLSCACHE"),
 		GoVersion:    runtime.Version(),
 		GoplsVersion: debug.Version,
 	}
@@ -138,10 +151,10 @@
 
 	// Gather bug reports produced by any process using
 	// this executable and persisted in the cache.
-	stats.BugReports = []string{} // non-nil for JSON
 	do("Gathering bug reports", func() error {
-		for _, report := range filecache.BugReports() {
-			stats.BugReports = append(stats.BugReports, string(report))
+		stats.CacheDir, stats.BugReports = filecache.BugReports()
+		if stats.BugReports == nil {
+			stats.BugReports = []goplsbug.Bug{} // non-nil for JSON
 		}
 		return nil
 	})
@@ -183,24 +196,51 @@
 		return err
 	}
 
-	data, err := json.MarshalIndent(stats, "", "  ")
+	// Filter JSON output to fields that are consistent with s.Anon.
+	okFields := make(map[string]interface{})
+	{
+		v := reflect.ValueOf(stats)
+		t := v.Type()
+		for i := 0; i < t.NumField(); i++ {
+			f := t.Field(i)
+			if !token.IsExported(f.Name) {
+				continue
+			}
+			if s.Anon && f.Tag.Get("anon") != "ok" {
+				// Fields that can be served with -anon must be explicitly marked as OK.
+				continue
+			}
+			vf := v.FieldByName(f.Name)
+			okFields[f.Name] = vf.Interface()
+		}
+	}
+	data, err := json.MarshalIndent(okFields, "", "  ")
 	if err != nil {
 		return err
 	}
+
 	os.Stdout.Write(data)
 	fmt.Println()
 	return nil
 }
 
+// GoplsStats holds information extracted from a gopls session in the current
+// workspace.
+//
+// Fields that should be printed with the -anon flag should be explicitly
+// marked as `anon:"ok"`. Only fields that cannot refer to user files or code
+// should be marked as such.
 type GoplsStats struct {
-	GOOS, GOARCH                 string
-	GoVersion                    string
-	GoplsVersion                 string
-	InitialWorkspaceLoadDuration string // in time.Duration string form
-	BugReports                   []string
-	MemStats                     command.MemStatsResult
-	WorkspaceStats               command.WorkspaceStatsResult
-	DirStats                     dirStats
+	GOOS, GOARCH                 string `anon:"ok"`
+	GOPLSCACHE                   string
+	GoVersion                    string `anon:"ok"`
+	GoplsVersion                 string `anon:"ok"`
+	InitialWorkspaceLoadDuration string `anon:"ok"` // in time.Duration string form
+	CacheDir                     string
+	BugReports                   []goplsbug.Bug
+	MemStats                     command.MemStatsResult       `anon:"ok"`
+	WorkspaceStats               command.WorkspaceStatsResult `anon:"ok"`
+	DirStats                     dirStats                     `anon:"ok"`
 }
 
 type dirStats struct {
diff --git a/gopls/internal/lsp/cmd/suggested_fix.go b/gopls/internal/lsp/cmd/suggested_fix.go
index 1128688..169d6d1 100644
--- a/gopls/internal/lsp/cmd/suggested_fix.go
+++ b/gopls/internal/lsp/cmd/suggested_fix.go
@@ -9,7 +9,6 @@
 	"flag"
 	"fmt"
 	"io/ioutil"
-	"log"
 	"os"
 
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
@@ -42,16 +41,11 @@
 	printFlagDefaults(f)
 }
 
-const DebugSuggestedFixEnvVar = "_DEBUG_SUGGESTED_FIX"
-
 // Run performs diagnostic checks on the file specified and either;
 // - if -w is specified, updates the file in place;
 // - if -d is specified, prints out unified diffs of the changes; or
 // - otherwise, prints the new versions to stdout.
 func (s *suggestedFix) Run(ctx context.Context, args ...string) error {
-	// For debugging golang/go#59475, enable some additional output.
-	var debug = os.Getenv(DebugSuggestedFixEnvVar) == "true"
-
 	if len(args) < 1 {
 		return tool.CommandLineErrorf("fix expects at least 1 argument")
 	}
@@ -77,12 +71,9 @@
 		return err
 	}
 	diagnostics := []protocol.Diagnostic{} // LSP wants non-nil slice
-	conn.Client.filesMu.Lock()
+	conn.client.filesMu.Lock()
 	diagnostics = append(diagnostics, file.diagnostics...)
-	conn.Client.filesMu.Unlock()
-	if debug {
-		log.Printf("file diagnostics: %#v", diagnostics)
-	}
+	conn.client.filesMu.Unlock()
 
 	// Request code actions
 	codeActionKinds := []protocol.CodeActionKind{protocol.QuickFix}
@@ -106,9 +97,6 @@
 	if err != nil {
 		return fmt.Errorf("%v: %v", from, err)
 	}
-	if debug {
-		log.Printf("code actions: %#v", actions)
-	}
 
 	// Gather edits from matching code actions.
 	var edits []protocol.TextEdit
diff --git a/gopls/internal/lsp/cmd/test/integration_test.go b/gopls/internal/lsp/cmd/test/integration_test.go
index c95790c..52ecb23 100644
--- a/gopls/internal/lsp/cmd/test/integration_test.go
+++ b/gopls/internal/lsp/cmd/test/integration_test.go
@@ -756,6 +756,18 @@
 		}
 	}
 
+	// Check that -anon suppresses fields containing user information.
+	{
+		res2 := gopls(t, tree, "stats", "-anon")
+		res2.checkExit(true)
+		var stats2 cmd.GoplsStats
+		if err := json.Unmarshal([]byte(res2.stdout), &stats2); err != nil {
+			t.Fatalf("failed to unmarshal JSON output of stats command: %v", err)
+		}
+		if got := len(stats2.BugReports); got > 0 {
+			t.Errorf("Got %d bug reports with -anon, want 0. Reports:%+v", got, stats2.BugReports)
+		}
+	}
 }
 
 // TestFix tests the 'fix' subcommand (../suggested_fix.go).
@@ -890,10 +902,7 @@
 	}
 
 	goplsCmd := exec.Command(os.Args[0], args...)
-	goplsCmd.Env = append(os.Environ(),
-		"ENTRYPOINT=goplsMain",
-		fmt.Sprintf("%s=true", cmd.DebugSuggestedFixEnvVar),
-	)
+	goplsCmd.Env = append(os.Environ(), "ENTRYPOINT=goplsMain")
 	goplsCmd.Env = append(goplsCmd.Env, env...)
 	goplsCmd.Dir = dir
 	goplsCmd.Stdout = new(bytes.Buffer)
diff --git a/gopls/internal/lsp/cmd/usage/stats.hlp b/gopls/internal/lsp/cmd/usage/stats.hlp
index 7694e29..71cce07 100644
--- a/gopls/internal/lsp/cmd/usage/stats.hlp
+++ b/gopls/internal/lsp/cmd/usage/stats.hlp
@@ -7,5 +7,11 @@
 workspace information relevant to performance. As a side effect, this command
 populates the gopls file cache for the current workspace.
 
+By default, this command may include output that refers to the location or
+content of user code. When the -anon flag is set, fields that may refer to user
+code are hidden.
+
 Example:
-  $ gopls stats
+  $ gopls stats -anon
+  -anon
+    	hide any fields that may contain user names, file names, or source code
diff --git a/gopls/internal/lsp/code_action.go b/gopls/internal/lsp/code_action.go
index 8658ba55..8e817b8 100644
--- a/gopls/internal/lsp/code_action.go
+++ b/gopls/internal/lsp/code_action.go
@@ -473,6 +473,17 @@
 
 func codeActionsMatchingDiagnostics(ctx context.Context, snapshot source.Snapshot, pdiags []protocol.Diagnostic, sdiags []*source.Diagnostic) ([]protocol.CodeAction, error) {
 	var actions []protocol.CodeAction
+	var unbundled []protocol.Diagnostic // diagnostics without bundled code actions in their Data field
+	for _, pd := range pdiags {
+		bundled := source.BundledQuickFixes(pd)
+		if len(bundled) > 0 {
+			actions = append(actions, bundled...)
+		} else {
+			// No bundled actions: keep searching for a match.
+			unbundled = append(unbundled, pd)
+		}
+	}
+
 	for _, sd := range sdiags {
 		var diag *protocol.Diagnostic
 		for _, pd := range pdiags {
diff --git a/gopls/internal/lsp/command.go b/gopls/internal/lsp/command.go
index 7236087..7bbadc1 100644
--- a/gopls/internal/lsp/command.go
+++ b/gopls/internal/lsp/command.go
@@ -360,10 +360,9 @@
 		progress: "Removing dependency",
 		forURI:   args.URI,
 	}, func(ctx context.Context, deps commandDeps) error {
-		// If the module is tidied apart from the one unused diagnostic, we can
-		// run `go get module@none`, and then run `go mod tidy`. Otherwise, we
-		// must make textual edits.
-		// TODO(rstambler): In Go 1.17+, we will be able to use the go command
+		// See the documentation for OnlyDiagnostic.
+		//
+		// TODO(rfindley): In Go 1.17+, we will be able to use the go command
 		// without checking if the module is tidy.
 		if args.OnlyDiagnostic {
 			return c.s.runGoModUpdateCommands(ctx, deps.snapshot, args.URI.SpanURI(), func(invoke func(...string) (*bytes.Buffer, error)) error {
diff --git a/gopls/internal/lsp/command/interface.go b/gopls/internal/lsp/command/interface.go
index 1342e84..ababac6 100644
--- a/gopls/internal/lsp/command/interface.go
+++ b/gopls/internal/lsp/command/interface.go
@@ -236,7 +236,10 @@
 	// The go.mod file URI.
 	URI protocol.DocumentURI
 	// The module path to remove.
-	ModulePath     string
+	ModulePath string
+	// If the module is tidied apart from the one unused diagnostic, we can
+	// run `go get module@none`, and then run `go mod tidy`. Otherwise, we
+	// must make textual edits.
 	OnlyDiagnostic bool
 }
 
diff --git a/gopls/internal/lsp/debug/info.go b/gopls/internal/lsp/debug/info.go
index 34fe216..fec4562 100644
--- a/gopls/internal/lsp/debug/info.go
+++ b/gopls/internal/lsp/debug/info.go
@@ -10,6 +10,7 @@
 	"encoding/json"
 	"fmt"
 	"io"
+	"os"
 	"reflect"
 	"runtime"
 	"runtime/debug"
@@ -67,6 +68,7 @@
 	section(w, HTML, "Server Instance", func() {
 		fmt.Fprintf(w, "Start time: %v\n", i.StartTime)
 		fmt.Fprintf(w, "LogFile: %s\n", i.Logfile)
+		fmt.Fprintf(w, "pid: %d\n", os.Getpid())
 		fmt.Fprintf(w, "Working directory: %s\n", i.Workdir)
 		fmt.Fprintf(w, "Address: %s\n", i.ServerAddress)
 		fmt.Fprintf(w, "Debug address: %s\n", i.DebugAddress())
diff --git a/gopls/internal/lsp/debug/serve.go b/gopls/internal/lsp/debug/serve.go
index 3c17dad..f36a238 100644
--- a/gopls/internal/lsp/debug/serve.go
+++ b/gopls/internal/lsp/debug/serve.go
@@ -5,7 +5,6 @@
 package debug
 
 import (
-	"archive/zip"
 	"bytes"
 	"context"
 	"errors"
@@ -20,7 +19,6 @@
 	"path"
 	"path/filepath"
 	"runtime"
-	rpprof "runtime/pprof"
 	"strconv"
 	"strings"
 	"sync"
@@ -494,65 +492,6 @@
 	return i.listenedDebugAddress
 }
 
-// MonitorMemory starts recording memory statistics each second.
-func (i *Instance) MonitorMemory(ctx context.Context) {
-	tick := time.NewTicker(time.Second)
-	nextThresholdGiB := uint64(1)
-	go func() {
-		for {
-			<-tick.C
-			var mem runtime.MemStats
-			runtime.ReadMemStats(&mem)
-			if mem.HeapAlloc < nextThresholdGiB*1<<30 {
-				continue
-			}
-			if err := i.writeMemoryDebug(nextThresholdGiB, true); err != nil {
-				event.Error(ctx, "writing memory debug info", err)
-			}
-			if err := i.writeMemoryDebug(nextThresholdGiB, false); err != nil {
-				event.Error(ctx, "writing memory debug info", err)
-			}
-			event.Log(ctx, fmt.Sprintf("Wrote memory usage debug info to %v", os.TempDir()))
-			nextThresholdGiB++
-		}
-	}()
-}
-
-func (i *Instance) writeMemoryDebug(threshold uint64, withNames bool) error {
-	suffix := "withnames"
-	if !withNames {
-		suffix = "nonames"
-	}
-
-	filename := fmt.Sprintf("gopls.%d-%dGiB-%s.zip", os.Getpid(), threshold, suffix)
-	zipf, err := os.OpenFile(filepath.Join(os.TempDir(), filename), os.O_CREATE|os.O_RDWR, 0644)
-	if err != nil {
-		return err
-	}
-	zipw := zip.NewWriter(zipf)
-
-	f, err := zipw.Create("heap.pb.gz")
-	if err != nil {
-		return err
-	}
-	if err := rpprof.Lookup("heap").WriteTo(f, 0); err != nil {
-		return err
-	}
-
-	f, err = zipw.Create("goroutines.txt")
-	if err != nil {
-		return err
-	}
-	if err := rpprof.Lookup("goroutine").WriteTo(f, 1); err != nil {
-		return err
-	}
-
-	if err := zipw.Close(); err != nil {
-		return err
-	}
-	return zipf.Close()
-}
-
 func makeGlobalExporter(stderr io.Writer) event.Exporter {
 	p := export.Printer{}
 	var pMu sync.Mutex
diff --git a/gopls/internal/lsp/diagnostics.go b/gopls/internal/lsp/diagnostics.go
index 90c2232..88008d3 100644
--- a/gopls/internal/lsp/diagnostics.go
+++ b/gopls/internal/lsp/diagnostics.go
@@ -145,6 +145,9 @@
 		fmt.Fprintf(h, "range: %s\n", d.Range)
 		fmt.Fprintf(h, "severity: %s\n", d.Severity)
 		fmt.Fprintf(h, "source: %s\n", d.Source)
+		if d.BundledFixes != nil {
+			fmt.Fprintf(h, "fixes: %s\n", *d.BundledFixes)
+		}
 	}
 	return fmt.Sprintf("%x", h.Sum(nil))
 }
@@ -771,6 +774,7 @@
 			Source:             string(diag.Source),
 			Tags:               emptySliceDiagnosticTag(diag.Tags),
 			RelatedInformation: diag.Related,
+			Data:               diag.BundledFixes,
 		}
 		if diag.Code != "" {
 			pdiag.Code = diag.Code
diff --git a/gopls/internal/lsp/fake/client.go b/gopls/internal/lsp/fake/client.go
index b619ef5..555428e 100644
--- a/gopls/internal/lsp/fake/client.go
+++ b/gopls/internal/lsp/fake/client.go
@@ -94,9 +94,8 @@
 	results := make([]interface{}, len(p.Items))
 	for i, item := range p.Items {
 		if item.Section == "gopls" {
-			c.editor.mu.Lock()
-			results[i] = c.editor.settingsLocked()
-			c.editor.mu.Unlock()
+			config := c.editor.Config()
+			results[i] = makeSettings(c.editor.sandbox, config)
 		}
 	}
 	return results, nil
diff --git a/gopls/internal/lsp/fake/editor.go b/gopls/internal/lsp/fake/editor.go
index ae9338d..45def8f 100644
--- a/gopls/internal/lsp/fake/editor.go
+++ b/gopls/internal/lsp/fake/editor.go
@@ -37,7 +37,6 @@
 	serverConn jsonrpc2.Conn
 	client     *Client
 	sandbox    *Sandbox
-	defaultEnv map[string]string
 
 	// TODO(adonovan): buffers should be keyed by protocol.DocumentURI.
 	mu                 sync.Mutex
@@ -75,8 +74,14 @@
 // source.UserOptions, but we use a separate type here so that we expose only
 // that configuration which we support.
 //
-// The zero value for EditorConfig should correspond to its defaults.
+// The zero value for EditorConfig is the default configuration.
 type EditorConfig struct {
+	// ClientName sets the clientInfo.name for the LSP session (in the initialize request).
+	//
+	// Since this can only be set during initialization, changing this field via
+	// Editor.ChangeConfiguration has no effect.
+	ClientName string
+
 	// Env holds environment variables to apply on top of the default editor
 	// environment. When applying these variables, the special string
 	// $SANDBOX_WORKDIR is replaced by the absolute path to the sandbox working
@@ -109,10 +114,9 @@
 // NewEditor creates a new Editor.
 func NewEditor(sandbox *Sandbox, config EditorConfig) *Editor {
 	return &Editor{
-		buffers:    make(map[string]buffer),
-		sandbox:    sandbox,
-		defaultEnv: sandbox.GoEnv(),
-		config:     config,
+		buffers: make(map[string]buffer),
+		sandbox: sandbox,
+		config:  config,
 	}
 }
 
@@ -198,19 +202,17 @@
 	return e.client
 }
 
-// settingsLocked builds the settings map for use in LSP settings RPCs.
-//
-// e.mu must be held while calling this function.
-func (e *Editor) settingsLocked() map[string]interface{} {
+// makeSettings builds the settings map for use in LSP settings RPCs.
+func makeSettings(sandbox *Sandbox, config EditorConfig) map[string]interface{} {
 	env := make(map[string]string)
-	for k, v := range e.defaultEnv {
+	for k, v := range sandbox.GoEnv() {
 		env[k] = v
 	}
-	for k, v := range e.config.Env {
+	for k, v := range config.Env {
 		env[k] = v
 	}
 	for k, v := range env {
-		v = strings.ReplaceAll(v, "$SANDBOX_WORKDIR", e.sandbox.Workdir.RootURI().SpanURI().Filename())
+		v = strings.ReplaceAll(v, "$SANDBOX_WORKDIR", sandbox.Workdir.RootURI().SpanURI().Filename())
 		env[k] = v
 	}
 
@@ -226,7 +228,7 @@
 		"completionBudget": "10s",
 	}
 
-	for k, v := range e.config.Settings {
+	for k, v := range config.Settings {
 		if k == "env" {
 			panic("must not provide env via the EditorConfig.Settings field: use the EditorConfig.Env field instead")
 		}
@@ -237,20 +239,22 @@
 }
 
 func (e *Editor) initialize(ctx context.Context) error {
+	config := e.Config()
+
 	params := &protocol.ParamInitialize{}
-	params.ClientInfo = &protocol.Msg_XInitializeParams_clientInfo{}
-	params.ClientInfo.Name = "fakeclient"
-	params.ClientInfo.Version = "v1.0.0"
-	e.mu.Lock()
-	params.WorkspaceFolders = e.makeWorkspaceFoldersLocked()
-	params.InitializationOptions = e.settingsLocked()
-	e.mu.Unlock()
-	params.Capabilities.Workspace.Configuration = true
-	params.Capabilities.Window.WorkDoneProgress = true
+	if e.config.ClientName != "" {
+		params.ClientInfo = &protocol.Msg_XInitializeParams_clientInfo{}
+		params.ClientInfo.Name = e.config.ClientName
+		params.ClientInfo.Version = "v1.0.0"
+	}
+	params.InitializationOptions = makeSettings(e.sandbox, config)
+	params.WorkspaceFolders = makeWorkspaceFolders(e.sandbox, config.WorkspaceFolders)
+	params.Capabilities.Workspace.Configuration = true // support workspace/configuration
+	params.Capabilities.Window.WorkDoneProgress = true // support window/workDoneProgress
 
-	// TODO: set client capabilities
+	// TODO(rfindley): set client capabilities (note from the future: why?)
+
 	params.Capabilities.TextDocument.Completion.CompletionItem.TagSupport.ValueSet = []protocol.CompletionItemTag{protocol.ComplDeprecated}
-
 	params.Capabilities.TextDocument.Completion.CompletionItem.SnippetSupport = true
 	params.Capabilities.TextDocument.SemanticTokens.Requests.Full.Value = true
 	// copied from lsp/semantic.go to avoid import cycle in tests
@@ -269,11 +273,12 @@
 	// but really we should test both ways for older editors.
 	params.Capabilities.TextDocument.DocumentSymbol.HierarchicalDocumentSymbolSupport = true
 
-	// This is a bit of a hack, since the fake editor doesn't actually support
-	// watching changed files that match a specific glob pattern. However, the
-	// editor does send didChangeWatchedFiles notifications, so set this to
-	// true.
+	// Glob pattern watching is enabled.
 	params.Capabilities.Workspace.DidChangeWatchedFiles.DynamicRegistration = true
+
+	// "rename" operations are used for package renaming.
+	//
+	// TODO(rfindley): add support for other resource operations (create, delete, ...)
 	params.Capabilities.Workspace.WorkspaceEdit = &protocol.WorkspaceEditClientCapabilities{
 		ResourceOperations: []protocol.ResourceOperationKind{
 			"rename",
@@ -300,18 +305,15 @@
 	return nil
 }
 
-// makeWorkspaceFoldersLocked creates a slice of workspace folders to use for
+// makeWorkspaceFolders creates a slice of workspace folders to use for
 // this editing session, based on the editor configuration.
-//
-// e.mu must be held while calling this function.
-func (e *Editor) makeWorkspaceFoldersLocked() (folders []protocol.WorkspaceFolder) {
-	paths := e.config.WorkspaceFolders
+func makeWorkspaceFolders(sandbox *Sandbox, paths []string) (folders []protocol.WorkspaceFolder) {
 	if len(paths) == 0 {
-		paths = append(paths, string(e.sandbox.Workdir.RelativeTo))
+		paths = []string{string(sandbox.Workdir.RelativeTo)}
 	}
 
 	for _, path := range paths {
-		uri := string(e.sandbox.Workdir.URI(path))
+		uri := string(sandbox.Workdir.URI(path))
 		folders = append(folders, protocol.WorkspaceFolder{
 			URI:  uri,
 			Name: filepath.Base(uri),
@@ -1329,14 +1331,18 @@
 	return e.config
 }
 
+func (e *Editor) SetConfig(cfg EditorConfig) {
+	e.mu.Lock()
+	e.config = cfg
+	e.mu.Unlock()
+}
+
 // ChangeConfiguration sets the new editor configuration, and if applicable
 // sends a didChangeConfiguration notification.
 //
 // An error is returned if the change notification failed to send.
 func (e *Editor) ChangeConfiguration(ctx context.Context, newConfig EditorConfig) error {
-	e.mu.Lock()
-	e.config = newConfig
-	e.mu.Unlock() // don't hold e.mu during server calls
+	e.SetConfig(newConfig)
 	if e.Server != nil {
 		var params protocol.DidChangeConfigurationParams // empty: gopls ignores the Settings field
 		if err := e.Server.DidChangeConfiguration(ctx, &params); err != nil {
@@ -1351,12 +1357,13 @@
 //
 // The given folders must all be unique.
 func (e *Editor) ChangeWorkspaceFolders(ctx context.Context, folders []string) error {
+	config := e.Config()
+
 	// capture existing folders so that we can compute the change.
-	e.mu.Lock()
-	oldFolders := e.makeWorkspaceFoldersLocked()
-	e.config.WorkspaceFolders = folders
-	newFolders := e.makeWorkspaceFoldersLocked()
-	e.mu.Unlock()
+	oldFolders := makeWorkspaceFolders(e.sandbox, config.WorkspaceFolders)
+	newFolders := makeWorkspaceFolders(e.sandbox, folders)
+	config.WorkspaceFolders = folders
+	e.SetConfig(config)
 
 	if e.Server == nil {
 		return nil
diff --git a/gopls/internal/lsp/filecache/filecache.go b/gopls/internal/lsp/filecache/filecache.go
index c4e2ce4..df84693 100644
--- a/gopls/internal/lsp/filecache/filecache.go
+++ b/gopls/internal/lsp/filecache/filecache.go
@@ -23,25 +23,23 @@
 import (
 	"bytes"
 	"crypto/sha256"
-	"encoding/binary"
 	"encoding/hex"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"hash/crc32"
 	"io"
 	"io/fs"
 	"log"
 	"os"
 	"path/filepath"
-	"runtime"
 	"sort"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
 	"golang.org/x/tools/gopls/internal/bug"
 	"golang.org/x/tools/gopls/internal/lsp/lru"
-	"golang.org/x/tools/internal/lockedfile"
 )
 
 // Start causes the filecache to initialize and start garbage gollection.
@@ -77,60 +75,60 @@
 	iolimit <- struct{}{}        // acquire a token
 	defer func() { <-iolimit }() // release a token
 
-	name, err := filename(kind, key)
+	// Read the index file, which provides the name of the CAS file.
+	indexName, err := filename(kind, key)
 	if err != nil {
 		return nil, err
 	}
-	data, err := lockedfile.Read(name)
+	indexData, err := os.ReadFile(indexName)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
 			return nil, ErrNotFound
 		}
 		return nil, err
 	}
-
-	// Verify that the Write was complete
-	// by checking the recorded length.
-	if len(data) < 8+4 {
-		return nil, ErrNotFound // cache entry is incomplete
-	}
-	length, value, checksum := data[:8], data[8:len(data)-4], data[len(data)-4:]
-	if binary.LittleEndian.Uint64(length) != uint64(len(value)) {
-		return nil, ErrNotFound // cache entry is incomplete (or too long!)
+	var valueHash [32]byte
+	if copy(valueHash[:], indexData) != len(valueHash) {
+		return nil, ErrNotFound // index entry has wrong length
 	}
 
-	// Check for corruption and print the entire file content; see
-	// issue #59289. TODO(adonovan): stop printing the entire file
-	// once we've seen enough reports to understand the pattern.
-	if binary.LittleEndian.Uint32(checksum) != crc32.ChecksumIEEE(value) {
-		// Darwin has repeatedly displayed a problem (#59895)
-		// whereby the checksum portion (and only it) is zero,
-		// which suggests a bug in its file system . Don't
-		// panic, but keep an eye on other failures for now.
-		errorf := bug.Errorf
-		if binary.LittleEndian.Uint32(checksum) == 0 && runtime.GOOS == "darwin" {
-			errorf = fmt.Errorf
-		}
-
-		return nil, errorf("internal error in filecache.Get(%q, %x): invalid checksum at end of %d-byte file %s:\n%q",
-			kind, key, len(data), name, data)
+	// Read the CAS file and check its contents match.
+	//
+	// This ensures integrity in all cases (corrupt or truncated
+	// file, short read, I/O error, wrong length, etc) except an
+	// engineered hash collision, which is infeasible.
+	casName, err := filename(casKind, valueHash)
+	if err != nil {
+		return nil, err
+	}
+	value, _ := os.ReadFile(casName) // ignore error
+	if sha256.Sum256(value) != valueHash {
+		return nil, ErrNotFound // CAS file is missing or has wrong contents
 	}
 
-	// Update file time for use by LRU eviction.
-	// (This turns every read into a write operation.
-	// If this is a performance problem, we should
-	// touch the files aynchronously.)
+	// Update file times used by LRU eviction.
+	//
+	// Because this turns a read into a write operation,
+	// we follow the approach used in the go command's
+	// cache and update the access time only if the
+	// existing timestamp is older than one hour.
 	//
 	// (Traditionally the access time would be updated
 	// automatically, but for efficiency most POSIX systems have
 	// for many years set the noatime mount option to avoid every
 	// open or read operation entailing a metadata write.)
 	now := time.Now()
-	if err := os.Chtimes(name, now, now); err != nil {
-		return nil, fmt.Errorf("failed to update access time: %w", err)
+	touch := func(filename string) {
+		st, err := os.Stat(filename)
+		if err == nil && now.Sub(st.ModTime()) > time.Hour {
+			os.Chtimes(filename, now, now) // ignore error
+		}
 	}
+	touch(indexName)
+	touch(casName)
 
 	memCache.Set(memKey{kind, key}, value, len(value))
+
 	return value, nil
 }
 
@@ -145,56 +143,81 @@
 	iolimit <- struct{}{}        // acquire a token
 	defer func() { <-iolimit }() // release a token
 
-	name, err := filename(kind, key)
+	// First, add the value to the content-
+	// addressable store (CAS), if not present.
+	hash := sha256.Sum256(value)
+	casName, err := filename(casKind, hash)
 	if err != nil {
 		return err
 	}
-	if err := os.MkdirAll(filepath.Dir(name), 0700); err != nil {
-		return err
+	// Does CAS file exist and have correct (complete) content?
+	// TODO(adonovan): opt: use mmap for this check.
+	if prev, _ := os.ReadFile(casName); !bytes.Equal(prev, value) {
+		if err := os.MkdirAll(filepath.Dir(casName), 0700); err != nil {
+			return err
+		}
+		// Avoiding O_TRUNC here is merely an optimization to avoid
+		// cache misses when two threads race to write the same file.
+		if err := writeFileNoTrunc(casName, value, 0600); err != nil {
+			os.Remove(casName) // ignore error
+			return err         // e.g. disk full
+		}
 	}
 
-	// In the unlikely event of a short write (e.g. ENOSPC)
-	// followed by process termination (e.g. a power cut), we
-	// don't want a reader to see a short file, so we record
-	// the expected length first and verify it in Get.
-	var length [8]byte
-	binary.LittleEndian.PutUint64(length[:], uint64(len(value)))
+	// Now write an index entry that refers to the CAS file.
+	indexName, err := filename(kind, key)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(indexName), 0700); err != nil {
+		return err
+	}
+	if err := writeFileNoTrunc(indexName, hash[:], 0600); err != nil {
+		os.Remove(indexName) // ignore error
+		return err           // e.g. disk full
+	}
 
-	// Occasional file corruption (presence of zero bytes in JSON
-	// files) has been reported on macOS (see issue #59289),
-	// assumed due to a nonatomicity problem in the file system.
-	// Ideally the macOS kernel would be fixed, or lockedfile
-	// would implement a workaround (since its job is to provide
-	// reliable the mutual exclusion primitive that allows
-	// cooperating gopls processes to implement transactional
-	// file replacement), but for now we add an extra integrity
-	// check: a 32-bit checksum at the end.
-	var checksum [4]byte
-	binary.LittleEndian.PutUint32(checksum[:], crc32.ChecksumIEEE(value))
-
-	// Windows doesn't support atomic rename--we tried MoveFile,
-	// MoveFileEx, ReplaceFileEx, and SetFileInformationByHandle
-	// of RenameFileInfo, all to no avail--so instead we use
-	// advisory file locking, which is only about 2x slower even
-	// on POSIX platforms with atomic rename.
-	return lockedfile.Write(name, io.MultiReader(
-		bytes.NewReader(length[:]),
-		bytes.NewReader(value),
-		bytes.NewReader(checksum[:])),
-		0600)
+	return nil
 }
 
+// writeFileNoTrunc is like os.WriteFile but doesn't truncate until
+// after the write, so that racing writes of the same data are idempotent.
+func writeFileNoTrunc(filename string, data []byte, perm os.FileMode) error {
+	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, perm)
+	if err != nil {
+		return err
+	}
+	_, err = f.Write(data)
+	if err == nil {
+		err = f.Truncate(int64(len(data)))
+	}
+	if closeErr := f.Close(); err == nil {
+		err = closeErr
+	}
+	return err
+}
+
+// reserved kind strings
+const (
+	casKind = "cas" // content-addressable store files
+	bugKind = "bug" // gopls bug reports
+)
+
 var iolimit = make(chan struct{}, 128) // counting semaphore to limit I/O concurrency in Set.
 
 var budget int64 = 1e9 // 1GB
 
-// SetBudget sets a soft limit on disk usage of the cache (in bytes)
-// and returns the previous value. Supplying a negative value queries
-// the current value without changing it.
+// SetBudget sets a soft limit on disk usage of files in the cache (in
+// bytes) and returns the previous value. Supplying a negative value
+// queries the current value without changing it.
 //
 // If two gopls processes have different budgets, the one with the
 // lower budget will collect garbage more actively, but both will
 // observe the effect.
+//
+// Even in the steady state, the storage usage reported by the 'du'
+// command may exceed the budget by as much as 50-70% due to the
+// overheads of directories and the effects of block quantization.
 func SetBudget(new int64) (old int64) {
 	if new < 0 {
 		return atomic.LoadInt64(&budget)
@@ -204,22 +227,62 @@
 
 // --- implementation ----
 
-// filename returns the cache entry of the specified kind and key.
+// filename returns the name of the cache file of the specified kind and key.
 //
-// A typical cache entry is a file name such as:
+// A typical cache file has a name such as:
 //
-//	$HOME/Library/Caches / gopls / VVVVVVVV / kind / KK / KKKK...KKKK
+//	$HOME/Library/Caches / gopls / VVVVVVVV / KK / KKKK...KKKK - kind
 //
 // The portions separated by spaces are as follows:
 // - The user's preferred cache directory; the default value varies by OS.
 // - The constant "gopls".
 // - The "version", 32 bits of the digest of the gopls executable.
-// - The kind or purpose of this cache subtree (e.g. "analysis").
 // - The first 8 bits of the key, to avoid huge directories.
 // - The full 256 bits of the key.
+// - The kind or purpose of this cache file (e.g. "analysis").
 //
-// Once a file is written its contents are never modified, though it
-// may be atomically replaced or removed.
+// The kind establishes a namespace for the keys. It is represented as
+// a suffix, not a segment, as this significantly reduces the number
+// of directories created, and thus the storage overhead.
+//
+// Previous iterations of the design aimed for the invariant that once
+// a file is written, its contents are never modified, though it may
+// be atomically replaced or removed. However, not all platforms have
+// an atomic rename operation (our first approach), and file locking
+// (our second) is a notoriously fickle mechanism.
+//
+// The current design instead exploits a trick from the cache
+// implementation used by the go command: writes of small files are in
+// practice atomic (all or nothing) on all platforms.
+// (See GOROOT/src/cmd/go/internal/cache/cache.go.)
+//
+// Russ Cox notes: "all file systems use an rwlock around every file
+// system block, including data blocks, so any writes or reads within
+// the same block are going to be handled atomically by the FS
+// implementation without any need to request file locking explicitly.
+// And since the files are so small, there's only one block. (A block
+// is at minimum 512 bytes, usually much more.)" And: "all modern file
+// systems protect against [partial writes due to power loss] with
+// journals."
+//
+// We use a two-level scheme consisting of an index and a
+// content-addressable store (CAS). A single cache entry consists of
+// two files. The value of a cache entry is written into the file at
+// filename("cas", sha256(value)). Since the value may be arbitrarily
+// large, this write is not atomic. That means we must check the
+// integrity of the contents read back from the CAS to make sure they
+// hash to the expected key. If the CAS file is incomplete or
+// inconsistent, we proceed as if it were missing.
+//
+// Once the CAS file has been written, we write a small fixed-size
+// index file at filename(kind, key), using the values supplied by the
+// caller. The index file contains the hash that identifies the value
+// file in the CAS. (We could add extra metadata to this file, up to
+// 512B, the minimum size of a disk block, if later desired, so long
+// as the total size remains fixed.) Because the index file is small,
+// concurrent writes to it are atomic in practice, even though this is
+// not guaranteed by any OS. The fixed size ensures that readers can't
+// see a palimpsest when a short new file overwrites a longer old one.
 //
 // New versions of gopls are free to reorganize the contents of the
 // version directory as needs evolve.  But all versions of gopls must
@@ -230,12 +293,13 @@
 // after older ones: in the development cycle especially, new
 // new versions may be created frequently.
 func filename(kind string, key [32]byte) (string, error) {
-	hex := fmt.Sprintf("%x", key)
+	base := fmt.Sprintf("%x-%s", key, kind)
 	dir, err := getCacheDir()
 	if err != nil {
 		return "", err
 	}
-	return filepath.Join(dir, kind, hex[:2], hex), nil
+	// Keep the BugReports function consistent with this one.
+	return filepath.Join(dir, base[:2], base), nil
 }
 
 // getCacheDir returns the persistent cache directory of all processes
@@ -462,8 +526,6 @@
 	}
 }
 
-const bugKind = "bug" // reserved kind for gopls bug reports
-
 func init() {
 	// Register a handler to durably record this process's first
 	// assertion failure in the cache so that we can ask users to
@@ -472,37 +534,51 @@
 		// Wait for cache init (bugs in tests happen early).
 		_, _ = getCacheDir()
 
-		value := []byte(fmt.Sprintf("%s: %+v", time.Now().Format(time.RFC3339), bug))
-		key := sha256.Sum256(value)
-		_ = Set(bugKind, key, value)
+		data, err := json.Marshal(bug)
+		if err != nil {
+			panic(fmt.Sprintf("error marshalling bug %+v: %v", bug, err))
+		}
+
+		key := sha256.Sum256(data)
+		_ = Set(bugKind, key, data)
 	})
 }
 
 // BugReports returns a new unordered array of the contents
 // of all cached bug reports produced by this executable.
-func BugReports() [][]byte {
+// It also returns the location of the cache directory
+// used by this process (or "" on initialization error).
+func BugReports() (string, []bug.Bug) {
+	// To test this logic, run:
+	// $ TEST_GOPLS_BUG=oops gopls stats   # trigger a bug
+	// $ gopls stats                       # list the bugs
+
 	dir, err := getCacheDir()
 	if err != nil {
-		return nil // ignore initialization errors
+		return "", nil // ignore initialization errors
 	}
-	var result [][]byte
-	_ = filepath.Walk(filepath.Join(dir, bugKind),
-		func(path string, info fs.FileInfo, err error) error {
-			if err != nil {
-				return nil // ignore readdir/stat errors
+	var result []bug.Bug
+	_ = filepath.Walk(dir, func(path string, info fs.FileInfo, err error) error {
+		if err != nil {
+			return nil // ignore readdir/stat errors
+		}
+		// Parse the key from each "XXXX-bug" cache file name.
+		if !info.IsDir() && strings.HasSuffix(path, bugKind) {
+			var key [32]byte
+			n, err := hex.Decode(key[:], []byte(filepath.Base(path)[:len(key)*2]))
+			if err != nil || n != len(key) {
+				return nil // ignore malformed file names
 			}
-			if !info.IsDir() {
-				var key [32]byte
-				n, err := hex.Decode(key[:], []byte(filepath.Base(path)))
-				if err != nil || n != len(key) {
-					return nil // ignore malformed file names
+			content, err := Get(bugKind, key)
+			if err == nil { // ignore read errors
+				var b bug.Bug
+				if err := json.Unmarshal(content, &b); err != nil {
+					log.Printf("error marshalling bug %q: %v", string(content), err)
 				}
-				content, err := Get(bugKind, key)
-				if err == nil { // ignore read errors
-					result = append(result, content)
-				}
+				result = append(result, b)
 			}
-			return nil
-		})
-	return result
+		}
+		return nil
+	})
+	return dir, result
 }
diff --git a/gopls/internal/lsp/general.go b/gopls/internal/lsp/general.go
index 9d12f97..7486f24 100644
--- a/gopls/internal/lsp/general.go
+++ b/gopls/internal/lsp/general.go
@@ -8,6 +8,7 @@
 	"context"
 	"encoding/json"
 	"fmt"
+	"go/build"
 	"log"
 	"os"
 	"path"
@@ -59,7 +60,7 @@
 	if err := s.handleOptionResults(ctx, source.SetOptions(options, params.InitializationOptions)); err != nil {
 		return nil, err
 	}
-	options.ForClientCapabilities(params.Capabilities)
+	options.ForClientCapabilities(params.ClientInfo, params.Capabilities)
 
 	if options.ShowBugReports {
 		// Report the next bug that occurs on the server.
@@ -239,14 +240,16 @@
 
 // GoVersionTable maps Go versions to the gopls version in which support will
 // be deprecated, and the final gopls version supporting them without warnings.
-// Keep this in sync with gopls/README.md
+// Keep this in sync with gopls/README.md.
 //
 // Must be sorted in ascending order of Go version.
 //
 // Mutable for testing.
 var GoVersionTable = []GoVersionSupport{
 	{12, "", "v0.7.5"},
-	{15, "v0.11.0", "v0.9.5"},
+	{15, "", "v0.9.5"},
+	{16, "v0.13.0", "v0.11.0"},
+	{17, "v0.13.0", "v0.11.0"},
 }
 
 // GoVersionSupport holds information about end-of-life Go version support.
@@ -262,11 +265,13 @@
 	return GoVersionTable[len(GoVersionTable)-1].GoVersion + 1
 }
 
-// versionMessage returns the warning/error message to display if the user is
-// on the given Go version, if any. The goVersion variable is the X in Go 1.X.
+// versionMessage returns the warning/error message to display if the user has
+// the given Go version, if any. The goVersion variable is the X in Go 1.X. If
+// fromBuild is set, the Go version is the version used to build gopls.
+// Otherwise, it is the go command version.
 //
 // If goVersion is invalid (< 0), it returns "", 0.
-func versionMessage(goVersion int) (string, protocol.MessageType) {
+func versionMessage(goVersion int, fromBuild bool) (string, protocol.MessageType) {
 	if goVersion < 0 {
 		return "", 0
 	}
@@ -276,7 +281,11 @@
 			var msgBuilder strings.Builder
 
 			mType := protocol.Error
-			fmt.Fprintf(&msgBuilder, "Found Go version 1.%d", goVersion)
+			if fromBuild {
+				fmt.Fprintf(&msgBuilder, "Gopls was built with Go version 1.%d", goVersion)
+			} else {
+				fmt.Fprintf(&msgBuilder, "Found Go version 1.%d", goVersion)
+			}
 			if v.DeprecatedVersion != "" {
 				// not deprecated yet, just a warning
 				fmt.Fprintf(&msgBuilder, ", which will be unsupported by gopls %s. ", v.DeprecatedVersion)
@@ -299,15 +308,15 @@
 //
 // It should be called after views change.
 func (s *Server) checkViewGoVersions() {
-	oldestVersion := -1
+	oldestVersion, fromBuild := go1Point(), true
 	for _, view := range s.session.Views() {
 		viewVersion := view.GoVersion()
 		if oldestVersion == -1 || viewVersion < oldestVersion {
-			oldestVersion = viewVersion
+			oldestVersion, fromBuild = viewVersion, false
 		}
 	}
 
-	if msg, mType := versionMessage(oldestVersion); msg != "" {
+	if msg, mType := versionMessage(oldestVersion, fromBuild); msg != "" {
 		s.eventuallyShowMessage(context.Background(), &protocol.ShowMessageParams{
 			Type:    mType,
 			Message: msg,
@@ -315,6 +324,21 @@
 	}
 }
 
+// go1Point returns the x in Go 1.x. If an error occurs extracting the go
+// version, it returns -1.
+//
+// Copied from the testenv package.
+func go1Point() int {
+	for i := len(build.Default.ReleaseTags) - 1; i >= 0; i-- {
+		var version int
+		if _, err := fmt.Sscanf(build.Default.ReleaseTags[i], "go1.%d", &version); err != nil {
+			continue
+		}
+		return version
+	}
+	return -1
+}
+
 func (s *Server) addFolders(ctx context.Context, folders []protocol.WorkspaceFolder) error {
 	originalViews := len(s.session.Views())
 	viewErrors := make(map[span.URI]error)
@@ -445,14 +469,13 @@
 
 // registerWatchedDirectoriesLocked sends the workspace/didChangeWatchedFiles
 // registrations to the client and updates s.watchedDirectories.
+// The caller must not subsequently mutate patterns.
 func (s *Server) registerWatchedDirectoriesLocked(ctx context.Context, patterns map[string]struct{}) error {
 	if !s.session.Options().DynamicWatchedFilesSupported {
 		return nil
 	}
-	for k := range s.watchedGlobPatterns {
-		delete(s.watchedGlobPatterns, k)
-	}
-	watchers := []protocol.FileSystemWatcher{} // must be a slice
+	s.watchedGlobPatterns = patterns
+	watchers := make([]protocol.FileSystemWatcher, 0, len(patterns)) // must be a slice
 	val := protocol.WatchChange | protocol.WatchDelete | protocol.WatchCreate
 	for pattern := range patterns {
 		watchers = append(watchers, protocol.FileSystemWatcher{
@@ -473,10 +496,6 @@
 		return err
 	}
 	s.watchRegistrationCount++
-
-	for k, v := range patterns {
-		s.watchedGlobPatterns[k] = v
-	}
 	return nil
 }
 
diff --git a/gopls/internal/lsp/general_test.go b/gopls/internal/lsp/general_test.go
index a0312ba..6bc0dc1 100644
--- a/gopls/internal/lsp/general_test.go
+++ b/gopls/internal/lsp/general_test.go
@@ -14,18 +14,22 @@
 func TestVersionMessage(t *testing.T) {
 	tests := []struct {
 		goVersion    int
+		fromBuild    bool
 		wantContains []string // string fragments that we expect to see
 		wantType     protocol.MessageType
 	}{
-		{-1, nil, 0},
-		{12, []string{"1.12", "not supported", "upgrade to Go 1.16", "install gopls v0.7.5"}, protocol.Error},
-		{13, []string{"1.13", "will be unsupported by gopls v0.11.0", "upgrade to Go 1.16", "install gopls v0.9.5"}, protocol.Warning},
-		{15, []string{"1.15", "will be unsupported by gopls v0.11.0", "upgrade to Go 1.16", "install gopls v0.9.5"}, protocol.Warning},
-		{16, nil, 0},
+		{-1, false, nil, 0},
+		{12, false, []string{"1.12", "not supported", "upgrade to Go 1.18", "install gopls v0.7.5"}, protocol.Error},
+		{13, false, []string{"1.13", "not supported", "upgrade to Go 1.18", "install gopls v0.9.5"}, protocol.Error},
+		{15, false, []string{"1.15", "not supported", "upgrade to Go 1.18", "install gopls v0.9.5"}, protocol.Error},
+		{15, true, []string{"Gopls was built with Go version 1.15", "not supported", "upgrade to Go 1.18", "install gopls v0.9.5"}, protocol.Error},
+		{16, false, []string{"1.16", "will be unsupported by gopls v0.13.0", "upgrade to Go 1.18", "install gopls v0.11.0"}, protocol.Warning},
+		{17, false, []string{"1.17", "will be unsupported by gopls v0.13.0", "upgrade to Go 1.18", "install gopls v0.11.0"}, protocol.Warning},
+		{17, true, []string{"Gopls was built with Go version 1.17", "will be unsupported by gopls v0.13.0", "upgrade to Go 1.18", "install gopls v0.11.0"}, protocol.Warning},
 	}
 
 	for _, test := range tests {
-		gotMsg, gotType := versionMessage(test.goVersion)
+		gotMsg, gotType := versionMessage(test.goVersion, test.fromBuild)
 
 		if len(test.wantContains) == 0 && gotMsg != "" {
 			t.Errorf("versionMessage(%d) = %q, want \"\"", test.goVersion, gotMsg)
diff --git a/gopls/internal/lsp/mod/diagnostics.go b/gopls/internal/lsp/mod/diagnostics.go
index af5fe38..cd1c85b 100644
--- a/gopls/internal/lsp/mod/diagnostics.go
+++ b/gopls/internal/lsp/mod/diagnostics.go
@@ -9,11 +9,14 @@
 import (
 	"context"
 	"fmt"
+	"runtime"
 	"sort"
 	"strings"
+	"sync"
 
 	"golang.org/x/mod/modfile"
 	"golang.org/x/mod/semver"
+	"golang.org/x/sync/errgroup"
 	"golang.org/x/tools/gopls/internal/govulncheck"
 	"golang.org/x/tools/gopls/internal/lsp/command"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
@@ -58,24 +61,36 @@
 }
 
 func collectDiagnostics(ctx context.Context, snapshot source.Snapshot, diagFn func(context.Context, source.Snapshot, source.FileHandle) ([]*source.Diagnostic, error)) (map[span.URI][]*source.Diagnostic, error) {
+
+	g, ctx := errgroup.WithContext(ctx)
+	cpulimit := runtime.GOMAXPROCS(0)
+	g.SetLimit(cpulimit)
+
+	var mu sync.Mutex
 	reports := make(map[span.URI][]*source.Diagnostic)
+
 	for _, uri := range snapshot.ModFiles() {
-		fh, err := snapshot.ReadFile(ctx, uri)
-		if err != nil {
-			return nil, err
-		}
-		reports[fh.URI()] = []*source.Diagnostic{}
-		diagnostics, err := diagFn(ctx, snapshot, fh)
-		if err != nil {
-			return nil, err
-		}
-		for _, d := range diagnostics {
-			fh, err := snapshot.ReadFile(ctx, d.URI)
+		uri := uri
+		g.Go(func() error {
+			fh, err := snapshot.ReadFile(ctx, uri)
 			if err != nil {
-				return nil, err
+				return err
 			}
-			reports[fh.URI()] = append(reports[fh.URI()], d)
-		}
+			diagnostics, err := diagFn(ctx, snapshot, fh)
+			if err != nil {
+				return err
+			}
+			for _, d := range diagnostics {
+				mu.Lock()
+				reports[d.URI] = append(reports[fh.URI()], d)
+				mu.Unlock()
+			}
+			return nil
+		})
+	}
+
+	if err := g.Wait(); err != nil {
+		return nil, err
 	}
 	return reports, nil
 }
diff --git a/gopls/internal/lsp/protocol/generate/tables.go b/gopls/internal/lsp/protocol/generate/tables.go
index 126301a..8fb9707 100644
--- a/gopls/internal/lsp/protocol/generate/tables.go
+++ b/gopls/internal/lsp/protocol/generate/tables.go
@@ -68,6 +68,7 @@
 	{"Command", "arguments"}:       "[]json.RawMessage",
 	{"CompletionItem", "textEdit"}: "TextEdit",
 	{"Diagnostic", "code"}:         "interface{}",
+	{"Diagnostic", "data"}:         "json.RawMessage", // delay unmarshalling quickfixes
 
 	{"DocumentDiagnosticReportPartialResult", "relatedDocuments"}: "map[DocumentURI]interface{}",
 
diff --git a/gopls/internal/lsp/protocol/tsprotocol.go b/gopls/internal/lsp/protocol/tsprotocol.go
index 8469aeb..f8ebb46 100644
--- a/gopls/internal/lsp/protocol/tsprotocol.go
+++ b/gopls/internal/lsp/protocol/tsprotocol.go
@@ -896,7 +896,7 @@
 	// notification and `textDocument/codeAction` request.
 	//
 	// @since 3.16.0
-	Data interface{} `json:"data,omitempty"`
+	Data *json.RawMessage `json:"data,omitempty"`
 }
 
 // Client capabilities specific to diagnostic pull requests.
diff --git a/gopls/internal/lsp/regtest/expectation.go b/gopls/internal/lsp/regtest/expectation.go
index 9d9f023..a770616 100644
--- a/gopls/internal/lsp/regtest/expectation.go
+++ b/gopls/internal/lsp/regtest/expectation.go
@@ -235,7 +235,7 @@
 	}
 	return Expectation{
 		Check:       check,
-		Description: "received ShowMessage",
+		Description: fmt.Sprintf("received window/showMessage containing %q", containing),
 	}
 }
 
@@ -576,50 +576,6 @@
 	return jsonProperty(m[path[0]], path[1:]...)
 }
 
-// RegistrationMatching asserts that the client has received a capability
-// registration matching the given regexp.
-//
-// TODO(rfindley): remove this once TestWatchReplaceTargets has been revisited.
-//
-// Deprecated: use (No)FileWatchMatching
-func RegistrationMatching(re string) Expectation {
-	rec := regexp.MustCompile(re)
-	check := func(s State) Verdict {
-		for _, p := range s.registrations {
-			for _, r := range p.Registrations {
-				if rec.Match([]byte(r.Method)) {
-					return Met
-				}
-			}
-		}
-		return Unmet
-	}
-	return Expectation{
-		Check:       check,
-		Description: fmt.Sprintf("registration matching %q", re),
-	}
-}
-
-// UnregistrationMatching asserts that the client has received an
-// unregistration whose ID matches the given regexp.
-func UnregistrationMatching(re string) Expectation {
-	rec := regexp.MustCompile(re)
-	check := func(s State) Verdict {
-		for _, p := range s.unregistrations {
-			for _, r := range p.Unregisterations {
-				if rec.Match([]byte(r.Method)) {
-					return Met
-				}
-			}
-		}
-		return Unmet
-	}
-	return Expectation{
-		Check:       check,
-		Description: fmt.Sprintf("unregistration matching %q", re),
-	}
-}
-
 // Diagnostics asserts that there is at least one diagnostic matching the given
 // filters.
 func Diagnostics(filters ...DiagnosticFilter) Expectation {
diff --git a/gopls/internal/lsp/regtest/options.go b/gopls/internal/lsp/regtest/options.go
index 7a41696..f55fd5b 100644
--- a/gopls/internal/lsp/regtest/options.go
+++ b/gopls/internal/lsp/regtest/options.go
@@ -64,8 +64,14 @@
 	})
 }
 
-// Settings is a RunOption that sets user-provided configuration for the LSP
-// server.
+// ClientName sets the LSP client name.
+func ClientName(name string) RunOption {
+	return optionSetter(func(opts *runConfig) {
+		opts.editor.ClientName = name
+	})
+}
+
+// Settings sets user-provided configuration for the LSP server.
 //
 // As a special case, the env setting must not be provided via Settings: use
 // EnvVars instead.
diff --git a/gopls/internal/lsp/server.go b/gopls/internal/lsp/server.go
index 9f82e90..db69565 100644
--- a/gopls/internal/lsp/server.go
+++ b/gopls/internal/lsp/server.go
@@ -29,7 +29,7 @@
 	return &Server{
 		diagnostics:           map[span.URI]*fileReports{},
 		gcOptimizationDetails: make(map[source.PackageID]struct{}),
-		watchedGlobPatterns:   make(map[string]struct{}),
+		watchedGlobPatterns:   nil, // empty
 		changedFiles:          make(map[span.URI]struct{}),
 		session:               session,
 		client:                client,
@@ -85,6 +85,7 @@
 	// watchedGlobPatterns is the set of glob patterns that we have requested
 	// the client watch on disk. It will be updated as the set of directories
 	// that the server should watch changes.
+	// The map field may be reassigned but the map is immutable.
 	watchedGlobPatternsMu  sync.Mutex
 	watchedGlobPatterns    map[string]struct{}
 	watchRegistrationCount int
diff --git a/gopls/internal/lsp/source/api_json.go b/gopls/internal/lsp/source/api_json.go
index 281772b..f777fdb 100644
--- a/gopls/internal/lsp/source/api_json.go
+++ b/gopls/internal/lsp/source/api_json.go
@@ -760,7 +760,7 @@
 			Command: "gopls.remove_dependency",
 			Title:   "Remove a dependency",
 			Doc:     "Removes a dependency from the go.mod file of a module.",
-			ArgDoc:  "{\n\t// The go.mod file URI.\n\t\"URI\": string,\n\t// The module path to remove.\n\t\"ModulePath\": string,\n\t\"OnlyDiagnostic\": bool,\n}",
+			ArgDoc:  "{\n\t// The go.mod file URI.\n\t\"URI\": string,\n\t// The module path to remove.\n\t\"ModulePath\": string,\n\t// If the module is tidied apart from the one unused diagnostic, we can\n\t// run `go get module@none`, and then run `go mod tidy`. Otherwise, we\n\t// must make textual edits.\n\t\"OnlyDiagnostic\": bool,\n}",
 		},
 		{
 			Command: "gopls.reset_go_mod_diagnostics",
diff --git a/gopls/internal/lsp/source/completion/completion.go b/gopls/internal/lsp/source/completion/completion.go
index ad5ce16..bc2b0c3 100644
--- a/gopls/internal/lsp/source/completion/completion.go
+++ b/gopls/internal/lsp/source/completion/completion.go
@@ -12,6 +12,7 @@
 	"go/ast"
 	"go/constant"
 	"go/parser"
+	"go/printer"
 	"go/scanner"
 	"go/token"
 	"go/types"
@@ -1268,19 +1269,30 @@
 				var sn snippet.Builder
 				sn.WriteText(id.Name)
 				sn.WriteText("(")
+
+				var cfg printer.Config // slight overkill
 				var nparams int
-				for _, field := range fn.Type.Params.List {
-					if field.Names != nil {
-						nparams += len(field.Names)
-					} else {
-						nparams++
-					}
-				}
-				for i := 0; i < nparams; i++ {
-					if i > 0 {
+				param := func(name string, typ ast.Expr) {
+					if nparams > 0 {
 						sn.WriteText(", ")
 					}
-					sn.WritePlaceholder(nil)
+					nparams++
+					sn.WritePlaceholder(func(b *snippet.Builder) {
+						var buf strings.Builder
+						buf.WriteString(name)
+						buf.WriteByte(' ')
+						cfg.Fprint(&buf, token.NewFileSet(), typ)
+						b.WriteText(buf.String())
+					})
+				}
+				for _, field := range fn.Type.Params.List {
+					if field.Names != nil {
+						for _, name := range field.Names {
+							param(name.Name, field.Type)
+						}
+					} else {
+						param("_", field.Type)
+					}
 				}
 				sn.WriteText(")")
 				item.snippet = &sn
diff --git a/gopls/internal/lsp/source/diagnostics.go b/gopls/internal/lsp/source/diagnostics.go
index fc08dcf..336e35b 100644
--- a/gopls/internal/lsp/source/diagnostics.go
+++ b/gopls/internal/lsp/source/diagnostics.go
@@ -6,7 +6,9 @@
 
 import (
 	"context"
+	"encoding/json"
 
+	"golang.org/x/tools/gopls/internal/bug"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
 	"golang.org/x/tools/gopls/internal/span"
 )
@@ -136,3 +138,81 @@
 
 	*outT = append(*outT, tdiags...)
 }
+
+// quickFixesJSON is a JSON-serializable list of quick fixes
+// to be saved in the protocol.Diagnostic.Data field.
+type quickFixesJSON struct {
+	// TODO(rfindley): pack some sort of identifier here for later
+	// lookup/validation?
+	Fixes []protocol.CodeAction
+}
+
+// BundleQuickFixes attempts to bundle sd.SuggestedFixes into the
+// sd.BundledFixes field, so that it can be round-tripped through the client.
+// It returns false if the quick-fixes cannot be bundled.
+func BundleQuickFixes(sd *Diagnostic) bool {
+	if len(sd.SuggestedFixes) == 0 {
+		return true
+	}
+	var actions []protocol.CodeAction
+	for _, fix := range sd.SuggestedFixes {
+		if fix.Edits != nil {
+			// For now, we only support bundled code actions that execute commands.
+			//
+			// In order to cleanly support bundled edits, we'd have to guarantee that
+			// the edits were generated on the current snapshot. But this naively
+			// implies that every fix would have to include a snapshot ID, which
+			// would require us to republish all diagnostics on each new snapshot.
+			//
+			// TODO(rfindley): in order to avoid this additional chatter, we'd need
+			// to build some sort of registry or other mechanism on the snapshot to
+			// check whether a diagnostic is still valid.
+			return false
+		}
+		action := protocol.CodeAction{
+			Title:   fix.Title,
+			Kind:    fix.ActionKind,
+			Command: fix.Command,
+		}
+		actions = append(actions, action)
+	}
+	fixes := quickFixesJSON{
+		Fixes: actions,
+	}
+	data, err := json.Marshal(fixes)
+	if err != nil {
+		bug.Reportf("marshalling quick fixes: %v", err)
+		return false
+	}
+	msg := json.RawMessage(data)
+	sd.BundledFixes = &msg
+	return true
+}
+
+// BundledQuickFixes extracts any bundled codeActions from the
+// diag.Data field.
+func BundledQuickFixes(diag protocol.Diagnostic) []protocol.CodeAction {
+	if diag.Data == nil {
+		return nil
+	}
+	var fix quickFixesJSON
+	if err := json.Unmarshal(*diag.Data, &fix); err != nil {
+		bug.Reportf("unmarshalling quick fix: %v", err)
+		return nil
+	}
+
+	var actions []protocol.CodeAction
+	for _, action := range fix.Fixes {
+		// See BundleQuickFixes: for now we only support bundling commands.
+		if action.Edit != nil {
+			bug.Reportf("bundled fix %q includes workspace edits", action.Title)
+			continue
+		}
+		// associate the action with the incoming diagnostic
+		// (Note that this does not mutate the fix.Fixes slice).
+		action.Diagnostics = []protocol.Diagnostic{diag}
+		actions = append(actions, action)
+	}
+
+	return actions
+}
diff --git a/gopls/internal/lsp/source/options.go b/gopls/internal/lsp/source/options.go
index 2ca8895..23d6e9a 100644
--- a/gopls/internal/lsp/source/options.go
+++ b/gopls/internal/lsp/source/options.go
@@ -169,6 +169,7 @@
 				DeepCompletion:          true,
 				ChattyDiagnostics:       true,
 				NewDiff:                 "both",
+				SubdirWatchPatterns:     SubdirWatchPatternsAuto,
 			},
 			Hooks: Hooks{
 				// TODO(adonovan): switch to new diff.Strings implementation.
@@ -198,6 +199,7 @@
 // ClientOptions holds LSP-specific configuration that is provided by the
 // client.
 type ClientOptions struct {
+	ClientInfo                                 *protocol.Msg_XInitializeParams_clientInfo
 	InsertTextFormat                           protocol.InsertTextFormat
 	ConfigurationSupported                     bool
 	DynamicConfigurationSupported              bool
@@ -536,6 +538,9 @@
 // average user. These may be settings used by tests or outdated settings that
 // will soon be deprecated. Some of these settings may not even be configurable
 // by the user.
+//
+// TODO(rfindley): even though these settings are not intended for
+// modification, we should surface them in our documentation.
 type InternalOptions struct {
 	// LiteralCompletions controls whether literal candidates such as
 	// "&someStruct{}" are offered. Tests disable this flag to simplify
@@ -599,8 +604,42 @@
 	// file change. If unset, gopls only reports diagnostics when they change, or
 	// when a file is opened or closed.
 	ChattyDiagnostics bool
+
+	// SubdirWatchPatterns configures the file watching glob patterns registered
+	// by gopls.
+	//
+	// Some clients (namely VS Code) do not send workspace/didChangeWatchedFile
+	// notifications for files contained in a directory when that directory is
+	// deleted:
+	// https://github.com/microsoft/vscode/issues/109754
+	//
+	// In this case, gopls would miss important notifications about deleted
+	// packages. To work around this, gopls registers a watch pattern for each
+	// directory containing Go files.
+	//
+	// Unfortunately, other clients experience performance problems with this
+	// many watch patterns, so there is no single behavior that works well for
+	// all clients.
+	//
+	// The "subdirWatchPatterns" setting allows configuring this behavior. Its
+	// default value of "auto" attempts to guess the correct behavior based on
+	// the client name. We'd love to avoid this specialization, but as described
+	// above there is no single value that works for all clients.
+	//
+	// If any LSP client does not behave well with the default value (for
+	// example, if like VS Code it drops file notifications), please file an
+	// issue.
+	SubdirWatchPatterns SubdirWatchPatterns
 }
 
+type SubdirWatchPatterns string
+
+const (
+	SubdirWatchPatternsOn   SubdirWatchPatterns = "on"
+	SubdirWatchPatternsOff  SubdirWatchPatterns = "off"
+	SubdirWatchPatternsAuto SubdirWatchPatterns = "auto"
+)
+
 type ImportShortcut string
 
 const (
@@ -742,7 +781,8 @@
 	return results
 }
 
-func (o *Options) ForClientCapabilities(caps protocol.ClientCapabilities) {
+func (o *Options) ForClientCapabilities(clientName *protocol.Msg_XInitializeParams_clientInfo, caps protocol.ClientCapabilities) {
+	o.ClientInfo = clientName
 	// Check if the client supports snippets in completion items.
 	if caps.Workspace.WorkspaceEdit != nil {
 		o.SupportedResourceOperations = caps.Workspace.WorkspaceEdit.ResourceOperations
@@ -1159,6 +1199,15 @@
 	case "chattyDiagnostics":
 		result.setBool(&o.ChattyDiagnostics)
 
+	case "subdirWatchPatterns":
+		if s, ok := result.asOneOf(
+			string(SubdirWatchPatternsOn),
+			string(SubdirWatchPatternsOff),
+			string(SubdirWatchPatternsAuto),
+		); ok {
+			o.SubdirWatchPatterns = SubdirWatchPatterns(s)
+		}
+
 	// Replaced settings.
 	case "experimentalDisabledAnalyses":
 		result.deprecated("analyses")
diff --git a/gopls/internal/lsp/source/view.go b/gopls/internal/lsp/source/view.go
index 6dd3811..2f7a3f2 100644
--- a/gopls/internal/lsp/source/view.go
+++ b/gopls/internal/lsp/source/view.go
@@ -8,6 +8,7 @@
 	"bytes"
 	"context"
 	"crypto/sha256"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"go/ast"
@@ -971,7 +972,18 @@
 	Related []protocol.DiagnosticRelatedInformation
 
 	// Fields below are used internally to generate quick fixes. They aren't
-	// part of the LSP spec and don't leave the server.
+	// part of the LSP spec and historically didn't leave the server.
+	//
+	// Update(2023-05): version 3.16 of the LSP spec included support for the
+	// Diagnostic.data field, which holds arbitrary data preserved in the
+	// diagnostic for codeAction requests. This field allows bundling additional
+	// information for quick-fixes, and gopls can (and should) use this
+	// information to avoid re-evaluating diagnostics in code-action handlers.
+	//
+	// In order to stage this transition incrementally, the 'BundledFixes' field
+	// may store a 'bundled' (=json-serialized) form of the associated
+	// SuggestedFixes. Not all diagnostics have their fixes bundled.
+	BundledFixes   *json.RawMessage
 	SuggestedFixes []SuggestedFix
 }
 
diff --git a/gopls/internal/regtest/bench/didchange_test.go b/gopls/internal/regtest/bench/didchange_test.go
index 6bde10e..2030f32 100644
--- a/gopls/internal/regtest/bench/didchange_test.go
+++ b/gopls/internal/regtest/bench/didchange_test.go
@@ -19,11 +19,13 @@
 // shared file cache.
 var editID int64 = time.Now().UnixNano()
 
-var didChangeTests = []struct {
+type changeTest struct {
 	repo string
 	file string
-}{
-	{"google-cloud-go", "httpreplay/httpreplay.go"},
+}
+
+var didChangeTests = []changeTest{
+	{"google-cloud-go", "internal/annotate.go"},
 	{"istio", "pkg/fuzz/util.go"},
 	{"kubernetes", "pkg/controller/lookup_cache.go"},
 	{"kuma", "api/generic/insights.go"},
@@ -64,43 +66,63 @@
 
 func BenchmarkDiagnoseChange(b *testing.B) {
 	for _, test := range didChangeTests {
-		b.Run(test.repo, func(b *testing.B) {
-			sharedEnv := getRepo(b, test.repo).sharedEnv(b)
-			config := fake.EditorConfig{
-				Env: map[string]string{
-					"GOPATH": sharedEnv.Sandbox.GOPATH(),
-				},
-				Settings: map[string]interface{}{
-					"diagnosticsDelay": "0s",
-				},
-			}
-			// Use a new env to avoid the diagnostic delay: we want to measure how
-			// long it takes to produce the diagnostics.
-			env := getRepo(b, test.repo).newEnv(b, "diagnoseChange", config)
-			defer env.Close()
-			env.OpenFile(test.file)
-			// Insert the text we'll be modifying at the top of the file.
-			env.EditBuffer(test.file, protocol.TextEdit{NewText: "// __REGTEST_PLACEHOLDER_0__\n"})
-			env.AfterChange()
-			b.ResetTimer()
-
-			// We must use an extra subtest layer here, so that we only set up the
-			// shared env once (otherwise we pay additional overhead and the profiling
-			// flags don't work).
-			b.Run("diagnose", func(b *testing.B) {
-				for i := 0; i < b.N; i++ {
-					edits := atomic.AddInt64(&editID, 1)
-					env.EditBuffer(test.file, protocol.TextEdit{
-						Range: protocol.Range{
-							Start: protocol.Position{Line: 0, Character: 0},
-							End:   protocol.Position{Line: 1, Character: 0},
-						},
-						// Increment the placeholder text, to ensure cache misses.
-						NewText: fmt.Sprintf("// __REGTEST_PLACEHOLDER_%d__\n", edits),
-					})
-					env.AfterChange()
-				}
-			})
-		})
+		runChangeDiagnosticsBenchmark(b, test, false)
 	}
 }
+
+// TODO(rfindley): add a benchmark for with a metadata-affecting change, when
+// this matters.
+func BenchmarkDiagnoseSave(b *testing.B) {
+	for _, test := range didChangeTests {
+		runChangeDiagnosticsBenchmark(b, test, true)
+	}
+}
+
+// runChangeDiagnosticsBenchmark runs a benchmark to edit the test file and
+// await the resulting diagnostics pass. If save is set, the file is also saved.
+func runChangeDiagnosticsBenchmark(b *testing.B, test changeTest, save bool) {
+	b.Run(test.repo, func(b *testing.B) {
+		sharedEnv := getRepo(b, test.repo).sharedEnv(b)
+		config := fake.EditorConfig{
+			Env: map[string]string{
+				"GOPATH": sharedEnv.Sandbox.GOPATH(),
+			},
+			Settings: map[string]interface{}{
+				"diagnosticsDelay": "0s",
+			},
+		}
+		// Use a new env to avoid the diagnostic delay: we want to measure how
+		// long it takes to produce the diagnostics.
+		env := getRepo(b, test.repo).newEnv(b, "diagnoseSave", config)
+		defer env.Close()
+		env.OpenFile(test.file)
+		// Insert the text we'll be modifying at the top of the file.
+		env.EditBuffer(test.file, protocol.TextEdit{NewText: "// __REGTEST_PLACEHOLDER_0__\n"})
+		if save {
+			env.SaveBuffer(test.file)
+		}
+		env.AfterChange()
+		b.ResetTimer()
+
+		// We must use an extra subtest layer here, so that we only set up the
+		// shared env once (otherwise we pay additional overhead and the profiling
+		// flags don't work).
+		b.Run("diagnose", func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				edits := atomic.AddInt64(&editID, 1)
+				env.EditBuffer(test.file, protocol.TextEdit{
+					Range: protocol.Range{
+						Start: protocol.Position{Line: 0, Character: 0},
+						End:   protocol.Position{Line: 1, Character: 0},
+					},
+					// Increment the placeholder text, to ensure cache misses.
+					NewText: fmt.Sprintf("// __REGTEST_PLACEHOLDER_%d__\n", edits),
+				})
+				if save {
+					env.SaveBuffer(test.file)
+				}
+				env.AfterChange()
+			}
+		})
+	})
+}
diff --git a/gopls/internal/regtest/completion/completion_test.go b/gopls/internal/regtest/completion/completion_test.go
index 872bdc2..7f86594 100644
--- a/gopls/internal/regtest/completion/completion_test.go
+++ b/gopls/internal/regtest/completion/completion_test.go
@@ -527,13 +527,60 @@
 		env.AcceptCompletion(loc, completions.Items[0])
 		env.Await(env.DoneWithChange())
 		got := env.BufferText("main.go")
-		want := "package main\r\n\r\nimport (\r\n\t\"fmt\"\r\n\t\"math\"\r\n)\r\n\r\nfunc main() {\r\n\tfmt.Println(\"a\")\r\n\tmath.Sqrt(${1:})\r\n}\r\n"
+		want := "package main\r\n\r\nimport (\r\n\t\"fmt\"\r\n\t\"math\"\r\n)\r\n\r\nfunc main() {\r\n\tfmt.Println(\"a\")\r\n\tmath.Sqrt(${1:x float64})\r\n}\r\n"
 		if diff := cmp.Diff(want, got); diff != "" {
 			t.Errorf("unimported completion (-want +got):\n%s", diff)
 		}
 	})
 }
 
+func TestUnimportedCompletionHasPlaceholders60269(t *testing.T) {
+	// We can't express this as a marker test because it doesn't support AcceptCompletion.
+	const src = `
+-- go.mod --
+module example.com
+go 1.12
+
+-- a/a.go --
+package a
+
+var _ = b.F
+
+-- b/b.go --
+package b
+
+func F0(a, b int, c float64) {}
+func F1(int, chan *string) {}
+`
+	WithOptions(
+		WindowsLineEndings(),
+	).Run(t, src, func(t *testing.T, env *Env) {
+		env.OpenFile("a/a.go")
+		env.Await(env.DoneWithOpen())
+
+		// The table lists the expected completions as they appear in Items.
+		const common = "package a\r\n\r\nimport \"example.com/b\"\r\n\r\nvar _ = "
+		for i, want := range []string{
+			common + "b.F0(${1:a int}, ${2:b int}, ${3:c float64})\r\n",
+			common + "b.F1(${1:_ int}, ${2:_ chan *string})\r\n",
+		} {
+			loc := env.RegexpSearch("a/a.go", "b.F()")
+			completions := env.Completion(loc)
+			if len(completions.Items) == 0 {
+				t.Fatalf("no completion items")
+			}
+			saved := env.BufferText("a/a.go")
+			env.AcceptCompletion(loc, completions.Items[i])
+			env.Await(env.DoneWithChange())
+			got := env.BufferText("a/a.go")
+			if diff := cmp.Diff(want, got); diff != "" {
+				t.Errorf("%d: unimported completion (-want +got):\n%s", i, diff)
+			}
+			env.SetBufferContent("a/a.go", saved) // restore
+		}
+	})
+}
+
 func TestPackageMemberCompletionAfterSyntaxError(t *testing.T) {
 	// This test documents the current broken behavior due to golang/go#58833.
 	const src = `
diff --git a/gopls/internal/regtest/diagnostics/diagnostics_test.go b/gopls/internal/regtest/diagnostics/diagnostics_test.go
index f8e59a0..de675a5 100644
--- a/gopls/internal/regtest/diagnostics/diagnostics_test.go
+++ b/gopls/internal/regtest/diagnostics/diagnostics_test.go
@@ -1506,7 +1506,13 @@
 	bob.Hello()
 }
 `
-	Run(t, mod, func(t *testing.T, env *Env) {
+	WithOptions(
+		Settings{
+			// Now that we don't watch subdirs by default (except for VS Code),
+			// we must explicitly ask gopls to requests subdir watch patterns.
+			"subdirWatchPatterns": "on",
+		},
+	).Run(t, mod, func(t *testing.T, env *Env) {
 		env.OnceMet(
 			InitialWorkspaceLoad,
 			FileWatchMatching("bob"),
@@ -1695,8 +1701,7 @@
 		env.OpenFile("nested/hello/hello.go")
 		env.AfterChange(
 			Diagnostics(env.AtRegexp("nested/hello/hello.go", "helloHelper")),
-			Diagnostics(env.AtRegexp("nested/hello/hello.go", "package hello"), WithMessage("nested module")),
-			OutstandingWork(lsp.WorkspaceLoadFailure, "nested module"),
+			Diagnostics(env.AtRegexp("nested/hello/hello.go", "package (hello)"), WithMessage("not included in your workspace")),
 		)
 	})
 }
diff --git a/gopls/internal/regtest/misc/configuration_test.go b/gopls/internal/regtest/misc/configuration_test.go
index 6cbfe37..853abcd 100644
--- a/gopls/internal/regtest/misc/configuration_test.go
+++ b/gopls/internal/regtest/misc/configuration_test.go
@@ -57,9 +57,7 @@
 //
 // Gopls should not get confused about buffer content when recreating the view.
 func TestMajorOptionsChange(t *testing.T) {
-	t.Skip("broken due to golang/go#57934")
-
-	testenv.NeedsGo1Point(t, 17)
+	testenv.NeedsGo1Point(t, 19) // needs staticcheck
 
 	const files = `
 -- go.mod --
diff --git a/gopls/internal/regtest/misc/failures_test.go b/gopls/internal/regtest/misc/failures_test.go
index 42aa372..b5da9b0 100644
--- a/gopls/internal/regtest/misc/failures_test.go
+++ b/gopls/internal/regtest/misc/failures_test.go
@@ -15,7 +15,6 @@
 // that includes a line directive, which makes no difference since
 // gopls ignores line directives.
 func TestHoverFailure(t *testing.T) {
-	t.Skip("line directives //line ")
 	const mod = `
 -- go.mod --
 module mod.com
@@ -48,7 +47,6 @@
 // This test demonstrates a case where gopls is not at all confused by
 // line directives, because it completely ignores them.
 func TestFailingDiagnosticClearingOnEdit(t *testing.T) {
-	t.Skip("line directives //line ")
 	// badPackageDup contains a duplicate definition of the 'a' const.
 	// This is a minor variant of TestDiagnosticClearingOnEdit from
 	// diagnostics_test.go, with a line directive, which makes no difference.
diff --git a/gopls/internal/regtest/misc/hover_test.go b/gopls/internal/regtest/misc/hover_test.go
index 24ee6d8..41c6529 100644
--- a/gopls/internal/regtest/misc/hover_test.go
+++ b/gopls/internal/regtest/misc/hover_test.go
@@ -84,12 +84,6 @@
 }
 
 func TestHoverIntLiteral(t *testing.T) {
-	// TODO(rfindley): this behavior doesn't actually make sense for vars. It is
-	// misleading to format their value when it is (of course) variable.
-	//
-	// Instead, we should allow hovering on numeric literals.
-	t.Skip("golang/go#58220: broken due to new hover logic")
-
 	const source = `
 -- main.go --
 package main
@@ -106,13 +100,13 @@
 	Run(t, source, func(t *testing.T, env *Env) {
 		env.OpenFile("main.go")
 		hexExpected := "58190"
-		got, _ := env.Hover(env.RegexpSearch("main.go", "hex"))
+		got, _ := env.Hover(env.RegexpSearch("main.go", "0xe"))
 		if got != nil && !strings.Contains(got.Value, hexExpected) {
 			t.Errorf("Hover: missing expected field '%s'. Got:\n%q", hexExpected, got.Value)
 		}
 
 		binExpected := "73"
-		got, _ = env.Hover(env.RegexpSearch("main.go", "bigBin"))
+		got, _ = env.Hover(env.RegexpSearch("main.go", "0b1"))
 		if got != nil && !strings.Contains(got.Value, binExpected) {
 			t.Errorf("Hover: missing expected field '%s'. Got:\n%q", binExpected, got.Value)
 		}
diff --git a/gopls/internal/regtest/misc/leak_test.go b/gopls/internal/regtest/misc/leak_test.go
deleted file mode 100644
index 586ffcc..0000000
--- a/gopls/internal/regtest/misc/leak_test.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2022 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 misc
-
-import (
-	"context"
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-	"golang.org/x/tools/gopls/internal/hooks"
-	"golang.org/x/tools/gopls/internal/lsp/cache"
-	"golang.org/x/tools/gopls/internal/lsp/debug"
-	"golang.org/x/tools/gopls/internal/lsp/fake"
-	"golang.org/x/tools/gopls/internal/lsp/lsprpc"
-	. "golang.org/x/tools/gopls/internal/lsp/regtest"
-	"golang.org/x/tools/internal/jsonrpc2"
-	"golang.org/x/tools/internal/jsonrpc2/servertest"
-)
-
-// Test for golang/go#57222.
-func TestCacheLeak(t *testing.T) {
-	// TODO(rfindley): either fix this test with additional instrumentation, or
-	// delete it.
-	t.Skip("This test races with cache eviction.")
-	const files = `-- a.go --
-package a
-
-func _() {
-	println("1")
-}
-`
-	c := cache.New(nil)
-	env := setupEnv(t, files, c)
-	env.Await(InitialWorkspaceLoad)
-	env.OpenFile("a.go")
-
-	// Make a couple edits to stabilize cache state.
-	//
-	// For some reason, after only one edit we're left with two parsed files
-	// (perhaps because something had to ParseHeader). If this test proves flaky,
-	// we'll need to investigate exactly what is causing various parse modes to
-	// be present (or rewrite the test to be more tolerant, for example make ~100
-	// modifications and assert that we're within a few of where we're started).
-	env.RegexpReplace("a.go", "1", "2")
-	env.RegexpReplace("a.go", "2", "3")
-	env.AfterChange()
-
-	// Capture cache state, make an arbitrary change, and wait for gopls to do
-	// its work. Afterward, we should have the exact same number of parsed
-	before := c.MemStats()
-	env.RegexpReplace("a.go", "3", "4")
-	env.AfterChange()
-	after := c.MemStats()
-
-	if diff := cmp.Diff(before, after); diff != "" {
-		t.Errorf("store objects differ after change (-before +after)\n%s", diff)
-	}
-}
-
-// setupEnv creates a new sandbox environment for editing the txtar encoded
-// content of files. It uses a new gopls instance backed by the Cache c.
-func setupEnv(t *testing.T, files string, c *cache.Cache) *Env {
-	ctx := debug.WithInstance(context.Background(), "", "off")
-	server := lsprpc.NewStreamServer(c, false, hooks.Options)
-	ts := servertest.NewPipeServer(server, jsonrpc2.NewRawStream)
-	s, err := fake.NewSandbox(&fake.SandboxConfig{
-		Files: fake.UnpackTxt(files),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a := NewAwaiter(s.Workdir)
-	const skipApplyEdits = false
-	editor, err := fake.NewEditor(s, fake.EditorConfig{}).Connect(ctx, ts, a.Hooks(), skipApplyEdits)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return &Env{
-		T:       t,
-		Ctx:     ctx,
-		Editor:  editor,
-		Sandbox: s,
-		Awaiter: a,
-	}
-}
diff --git a/gopls/internal/regtest/modfile/modfile_test.go b/gopls/internal/regtest/modfile/modfile_test.go
index 03e60ac..855141a 100644
--- a/gopls/internal/regtest/modfile/modfile_test.go
+++ b/gopls/internal/regtest/modfile/modfile_test.go
@@ -498,14 +498,8 @@
 			ReadDiagnostics("a/go.mod", &modDiags),
 		)
 
-		// golang.go#57987: now that gopls is incremental, we must be careful where
-		// we request diagnostics. We must design a simpler way to correlate
-		// published diagnostics with subsequent code action requests (see also the
-		// comment in Server.codeAction).
-		const canRequestCodeActionsForWorkspaceDiagnostics = false
-		if canRequestCodeActionsForWorkspaceDiagnostics {
-			env.ApplyQuickFixes("a/go.mod", modDiags.Diagnostics)
-			const want = `module mod.com
+		env.ApplyQuickFixes("a/go.mod", modDiags.Diagnostics)
+		const want = `module mod.com
 
 go 1.12
 
@@ -514,11 +508,10 @@
 	example.com/blah/v2 v2.0.0
 )
 `
-			env.SaveBuffer("a/go.mod")
-			env.AfterChange(NoDiagnostics(ForFile("a/main.go")))
-			if got := env.BufferText("a/go.mod"); got != want {
-				t.Fatalf("suggested fixes failed:\n%s", compare.Text(want, got))
-			}
+		env.SaveBuffer("a/go.mod")
+		env.AfterChange(NoDiagnostics(ForFile("a/main.go")))
+		if got := env.BufferText("a/go.mod"); got != want {
+			t.Fatalf("suggested fixes failed:\n%s", compare.Text(want, got))
 		}
 	})
 }
diff --git a/gopls/internal/regtest/watch/setting_test.go b/gopls/internal/regtest/watch/setting_test.go
new file mode 100644
index 0000000..9ed7fde
--- /dev/null
+++ b/gopls/internal/regtest/watch/setting_test.go
@@ -0,0 +1,85 @@
+// 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 regtest
+
+import (
+	"fmt"
+	"testing"
+
+	. "golang.org/x/tools/gopls/internal/lsp/regtest"
+)
+
+func TestSubdirWatchPatterns(t *testing.T) {
+	const files = `
+-- go.mod --
+module mod.test
+
+go 1.18
+-- subdir/subdir.go --
+package subdir
+`
+
+	tests := []struct {
+		clientName          string
+		subdirWatchPatterns string
+		wantWatched         bool
+	}{
+		{"other client", "on", true},
+		{"other client", "off", false},
+		{"other client", "auto", false},
+		{"Visual Studio Code", "auto", true},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("%s_%s", test.clientName, test.subdirWatchPatterns), func(t *testing.T) {
+			WithOptions(
+				ClientName(test.clientName),
+				Settings{
+					"subdirWatchPatterns": test.subdirWatchPatterns,
+				},
+			).Run(t, files, func(t *testing.T, env *Env) {
+				var expectation Expectation
+				if test.wantWatched {
+					expectation = FileWatchMatching("subdir")
+				} else {
+					expectation = NoFileWatchMatching("subdir")
+				}
+				env.OnceMet(
+					InitialWorkspaceLoad,
+					expectation,
+				)
+			})
+		})
+	}
+}
+
+// This test checks that we surface errors for invalid subdir watch patterns,
+// as the triple of ("off"|"on"|"auto") may be confusing to users inclined to
+// use (true|false) or some other truthy value.
+func TestSubdirWatchPatterns_BadValues(t *testing.T) {
+	tests := []struct {
+		badValue    interface{}
+		wantMessage string
+	}{
+		{true, "invalid type bool, expect string"},
+		{false, "invalid type bool, expect string"},
+		{"yes", `invalid option "yes"`},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprint(test.badValue), func(t *testing.T) {
+			WithOptions(
+				Settings{
+					"subdirWatchPatterns": test.badValue,
+				},
+			).Run(t, "", func(t *testing.T, env *Env) {
+				env.OnceMet(
+					InitialWorkspaceLoad,
+					ShownMessage(test.wantMessage),
+				)
+			})
+		})
+	}
+}
diff --git a/gopls/internal/regtest/workspace/adhoc_test.go b/gopls/internal/regtest/workspace/adhoc_test.go
new file mode 100644
index 0000000..d726242
--- /dev/null
+++ b/gopls/internal/regtest/workspace/adhoc_test.go
@@ -0,0 +1,42 @@
+// Copyright 2022 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 workspace
+
+import (
+	"testing"
+
+	. "golang.org/x/tools/gopls/internal/lsp/regtest"
+	"golang.org/x/tools/internal/testenv"
+)
+
+// Test for golang/go#57209: editing a file in an ad-hoc package should not
+// trigger conflicting diagnostics.
+func TestAdhoc_Edits(t *testing.T) {
+	testenv.NeedsGo1Point(t, 18)
+
+	const files = `
+-- a.go --
+package foo
+
+const X = 1
+
+-- b.go --
+package foo
+
+// import "errors"
+
+const Y = X
+`
+
+	Run(t, files, func(t *testing.T, env *Env) {
+		env.OpenFile("b.go")
+
+		for i := 0; i < 10; i++ {
+			env.RegexpReplace("b.go", `// import "errors"`, `import "errors"`)
+			env.RegexpReplace("b.go", `import "errors"`, `// import "errors"`)
+			env.AfterChange(NoDiagnostics())
+		}
+	})
+}
diff --git a/gopls/internal/regtest/workspace/broken_test.go b/gopls/internal/regtest/workspace/broken_test.go
index 005a7e9..d7d54c4 100644
--- a/gopls/internal/regtest/workspace/broken_test.go
+++ b/gopls/internal/regtest/workspace/broken_test.go
@@ -23,10 +23,9 @@
 
 // Test for golang/go#53933
 func TestBrokenWorkspace_DuplicateModules(t *testing.T) {
-	testenv.NeedsGo1Point(t, 18)
-
-	// TODO(golang/go#57650): fix this feature.
-	t.Skip("we no longer detect duplicate modules")
+	// The go command error message was improved in Go 1.20 to mention multiple
+	// modules.
+	testenv.NeedsGo1Point(t, 20)
 
 	// This proxy module content is replaced by the workspace, but is still
 	// required for module resolution to function in the Go command.
@@ -98,8 +97,8 @@
 		ProxyFiles(proxy),
 	).Run(t, src, func(t *testing.T, env *Env) {
 		env.OpenFile("package1/main.go")
-		env.Await(
-			OutstandingWork(lsp.WorkspaceLoadFailure, `found module "example.com/foo" multiple times in the workspace`),
+		env.AfterChange(
+			OutstandingWork(lsp.WorkspaceLoadFailure, `module example.com/foo appears multiple times in workspace`),
 		)
 
 		// Remove the redundant vendored copy of example.com.
@@ -110,10 +109,10 @@
 			./package2/vendor/example.com/foo
 		)
 		`)
-		env.Await(NoOutstandingWork())
+		env.AfterChange(NoOutstandingWork())
 
 		// Check that definitions in package1 go to the copy vendored in package2.
-		location := env.GoToDefinition(env.RegexpSearch("package1/main.go", "CompleteMe")).URI.SpanURI().Filename()
+		location := string(env.GoToDefinition(env.RegexpSearch("package1/main.go", "CompleteMe")).URI)
 		const wantLocation = "package2/vendor/example.com/foo/foo.go"
 		if !strings.HasSuffix(location, wantLocation) {
 			t.Errorf("got definition of CompleteMe at %q, want %q", location, wantLocation)
diff --git a/gopls/internal/regtest/workspace/workspace_test.go b/gopls/internal/regtest/workspace/workspace_test.go
index 5a94e42..02e3a8c 100644
--- a/gopls/internal/regtest/workspace/workspace_test.go
+++ b/gopls/internal/regtest/workspace/workspace_test.go
@@ -183,29 +183,6 @@
 	})
 }
 
-// This test checks that gopls updates the set of files it watches when a
-// replace target is added to the go.mod.
-func TestWatchReplaceTargets(t *testing.T) {
-	t.Skipf("skipping known-flaky test: see https://go.dev/issue/50748")
-
-	WithOptions(
-		ProxyFiles(workspaceProxy),
-		WorkspaceFolders("pkg"),
-	).Run(t, workspaceModule, func(t *testing.T, env *Env) {
-		// Add a replace directive and expect the files that gopls is watching
-		// to change.
-		dir := env.Sandbox.Workdir.URI("goodbye").SpanURI().Filename()
-		goModWithReplace := fmt.Sprintf(`%s
-replace random.org => %s
-`, env.ReadWorkspaceFile("pkg/go.mod"), dir)
-		env.WriteWorkspaceFile("pkg/go.mod", goModWithReplace)
-		env.AfterChange(
-			UnregistrationMatching("didChangeWatchedFiles"),
-			RegistrationMatching("didChangeWatchedFiles"),
-		)
-	})
-}
-
 const workspaceModuleProxy = `
 -- example.com@v1.2.3/go.mod --
 module example.com
@@ -575,10 +552,18 @@
 `
 	WithOptions(
 		ProxyFiles(workspaceModuleProxy),
+		Settings{
+			"subdirWatchPatterns": "on",
+		},
 	).Run(t, multiModule, func(t *testing.T, env *Env) {
-		// Initially, the go.work should cause only the a.com module to be
-		// loaded. Validate this by jumping to a definition in b.com and ensuring
-		// that we go to the module cache.
+		// Initially, the go.work should cause only the a.com module to be loaded,
+		// so we shouldn't get any file watches for modb. Further validate this by
+		// jumping to a definition in b.com and ensuring that we go to the module
+		// cache.
+		env.OnceMet(
+			InitialWorkspaceLoad,
+			NoFileWatchMatching("modb"),
+		)
 		env.OpenFile("moda/a/a.go")
 		env.Await(env.DoneWithOpen())
 
@@ -610,9 +595,13 @@
 `)
 
 		// As of golang/go#54069, writing go.work to the workspace triggers a
-		// workspace reload.
+		// workspace reload, and new file watches.
 		env.AfterChange(
 			Diagnostics(env.AtRegexp("modb/b/b.go", "x")),
+			// TODO(golang/go#60340): we don't get a file watch yet, because
+			// updateWatchedDirectories runs before snapshot.load. Instead, we get it
+			// after the next change (the didOpen below).
+			// FileWatchMatching("modb"),
 		)
 
 		// Jumping to definition should now go to b.com in the workspace.
@@ -623,7 +612,13 @@
 		// Now, let's modify the go.work *overlay* (not on disk), and verify that
 		// this change is only picked up once it is saved.
 		env.OpenFile("go.work")
-		env.AfterChange()
+		env.AfterChange(
+			// TODO(golang/go#60340): delete this expectation in favor of
+			// the commented-out expectation above, once we fix the evaluation order
+			// of file watches. We should not have to wait for a second change to get
+			// the correct watches.
+			FileWatchMatching("modb"),
+		)
 		env.SetBufferContent("go.work", `go 1.17
 
 use (
@@ -1059,7 +1054,7 @@
 		// package declaration.
 		env.AfterChange(
 			NoDiagnostics(ForFile("main.go")),
-			Diagnostics(AtPosition("b/main.go", 0, 0)),
+			Diagnostics(env.AtRegexp("b/main.go", "package (main)")),
 		)
 		env.WriteWorkspaceFile("go.work", `go 1.16
 
@@ -1085,7 +1080,7 @@
 
 		env.AfterChange(
 			NoDiagnostics(ForFile("main.go")),
-			Diagnostics(AtPosition("b/main.go", 0, 0)),
+			Diagnostics(env.AtRegexp("b/main.go", "package (main)")),
 		)
 	})
 }
diff --git a/internal/lockedfile/internal/filelock/filelock.go b/internal/lockedfile/internal/filelock/filelock.go
deleted file mode 100644
index 05f27c3..0000000
--- a/internal/lockedfile/internal/filelock/filelock.go
+++ /dev/null
@@ -1,99 +0,0 @@
-// 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 filelock provides a platform-independent API for advisory file
-// locking. Calls to functions in this package on platforms that do not support
-// advisory locks will return errors for which IsNotSupported returns true.
-package filelock
-
-import (
-	"errors"
-	"io/fs"
-	"os"
-)
-
-// A File provides the minimal set of methods required to lock an open file.
-// File implementations must be usable as map keys.
-// The usual implementation is *os.File.
-type File interface {
-	// Name returns the name of the file.
-	Name() string
-
-	// Fd returns a valid file descriptor.
-	// (If the File is an *os.File, it must not be closed.)
-	Fd() uintptr
-
-	// Stat returns the FileInfo structure describing file.
-	Stat() (fs.FileInfo, error)
-}
-
-// Lock places an advisory write lock on the file, blocking until it can be
-// locked.
-//
-// If Lock returns nil, no other process will be able to place a read or write
-// lock on the file until this process exits, closes f, or calls Unlock on it.
-//
-// If f's descriptor is already read- or write-locked, the behavior of Lock is
-// unspecified.
-//
-// Closing the file may or may not release the lock promptly. Callers should
-// ensure that Unlock is always called when Lock succeeds.
-func Lock(f File) error {
-	return lock(f, writeLock)
-}
-
-// RLock places an advisory read lock on the file, blocking until it can be locked.
-//
-// If RLock returns nil, no other process will be able to place a write lock on
-// the file until this process exits, closes f, or calls Unlock on it.
-//
-// If f is already read- or write-locked, the behavior of RLock is unspecified.
-//
-// Closing the file may or may not release the lock promptly. Callers should
-// ensure that Unlock is always called if RLock succeeds.
-func RLock(f File) error {
-	return lock(f, readLock)
-}
-
-// Unlock removes an advisory lock placed on f by this process.
-//
-// The caller must not attempt to unlock a file that is not locked.
-func Unlock(f File) error {
-	return unlock(f)
-}
-
-// String returns the name of the function corresponding to lt
-// (Lock, RLock, or Unlock).
-func (lt lockType) String() string {
-	switch lt {
-	case readLock:
-		return "RLock"
-	case writeLock:
-		return "Lock"
-	default:
-		return "Unlock"
-	}
-}
-
-// IsNotSupported returns a boolean indicating whether the error is known to
-// report that a function is not supported (possibly for a specific input).
-// It is satisfied by ErrNotSupported as well as some syscall errors.
-func IsNotSupported(err error) bool {
-	return isNotSupported(underlyingError(err))
-}
-
-var ErrNotSupported = errors.New("operation not supported")
-
-// underlyingError returns the underlying error for known os error types.
-func underlyingError(err error) error {
-	switch err := err.(type) {
-	case *fs.PathError:
-		return err.Err
-	case *os.LinkError:
-		return err.Err
-	case *os.SyscallError:
-		return err.Err
-	}
-	return err
-}
diff --git a/internal/lockedfile/internal/filelock/filelock_fcntl.go b/internal/lockedfile/internal/filelock/filelock_fcntl.go
deleted file mode 100644
index 3098519..0000000
--- a/internal/lockedfile/internal/filelock/filelock_fcntl.go
+++ /dev/null
@@ -1,215 +0,0 @@
-// 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.
-
-//go:build aix || (solaris && !illumos)
-// +build aix solaris,!illumos
-
-// This code implements the filelock API using POSIX 'fcntl' locks, which attach
-// to an (inode, process) pair rather than a file descriptor. To avoid unlocking
-// files prematurely when the same file is opened through different descriptors,
-// we allow only one read-lock at a time.
-//
-// Most platforms provide some alternative API, such as an 'flock' system call
-// or an F_OFD_SETLK command for 'fcntl', that allows for better concurrency and
-// does not require per-inode bookkeeping in the application.
-
-package filelock
-
-import (
-	"errors"
-	"io"
-	"io/fs"
-	"math/rand"
-	"sync"
-	"syscall"
-	"time"
-)
-
-type lockType int16
-
-const (
-	readLock  lockType = syscall.F_RDLCK
-	writeLock lockType = syscall.F_WRLCK
-)
-
-type inode = uint64 // type of syscall.Stat_t.Ino
-
-type inodeLock struct {
-	owner File
-	queue []<-chan File
-}
-
-var (
-	mu     sync.Mutex
-	inodes = map[File]inode{}
-	locks  = map[inode]inodeLock{}
-)
-
-func lock(f File, lt lockType) (err error) {
-	// POSIX locks apply per inode and process, and the lock for an inode is
-	// released when *any* descriptor for that inode is closed. So we need to
-	// synchronize access to each inode internally, and must serialize lock and
-	// unlock calls that refer to the same inode through different descriptors.
-	fi, err := f.Stat()
-	if err != nil {
-		return err
-	}
-	ino := fi.Sys().(*syscall.Stat_t).Ino
-
-	mu.Lock()
-	if i, dup := inodes[f]; dup && i != ino {
-		mu.Unlock()
-		return &fs.PathError{
-			Op:   lt.String(),
-			Path: f.Name(),
-			Err:  errors.New("inode for file changed since last Lock or RLock"),
-		}
-	}
-	inodes[f] = ino
-
-	var wait chan File
-	l := locks[ino]
-	if l.owner == f {
-		// This file already owns the lock, but the call may change its lock type.
-	} else if l.owner == nil {
-		// No owner: it's ours now.
-		l.owner = f
-	} else {
-		// Already owned: add a channel to wait on.
-		wait = make(chan File)
-		l.queue = append(l.queue, wait)
-	}
-	locks[ino] = l
-	mu.Unlock()
-
-	if wait != nil {
-		wait <- f
-	}
-
-	// Spurious EDEADLK errors arise on platforms that compute deadlock graphs at
-	// the process, rather than thread, level. Consider processes P and Q, with
-	// threads P.1, P.2, and Q.3. The following trace is NOT a deadlock, but will be
-	// reported as a deadlock on systems that consider only process granularity:
-	//
-	// 	P.1 locks file A.
-	// 	Q.3 locks file B.
-	// 	Q.3 blocks on file A.
-	// 	P.2 blocks on file B. (This is erroneously reported as a deadlock.)
-	// 	P.1 unlocks file A.
-	// 	Q.3 unblocks and locks file A.
-	// 	Q.3 unlocks files A and B.
-	// 	P.2 unblocks and locks file B.
-	// 	P.2 unlocks file B.
-	//
-	// These spurious errors were observed in practice on AIX and Solaris in
-	// cmd/go: see https://golang.org/issue/32817.
-	//
-	// We work around this bug by treating EDEADLK as always spurious. If there
-	// really is a lock-ordering bug between the interacting processes, it will
-	// become a livelock instead, but that's not appreciably worse than if we had
-	// a proper flock implementation (which generally does not even attempt to
-	// diagnose deadlocks).
-	//
-	// In the above example, that changes the trace to:
-	//
-	// 	P.1 locks file A.
-	// 	Q.3 locks file B.
-	// 	Q.3 blocks on file A.
-	// 	P.2 spuriously fails to lock file B and goes to sleep.
-	// 	P.1 unlocks file A.
-	// 	Q.3 unblocks and locks file A.
-	// 	Q.3 unlocks files A and B.
-	// 	P.2 wakes up and locks file B.
-	// 	P.2 unlocks file B.
-	//
-	// We know that the retry loop will not introduce a *spurious* livelock
-	// because, according to the POSIX specification, EDEADLK is only to be
-	// returned when “the lock is blocked by a lock from another process”.
-	// If that process is blocked on some lock that we are holding, then the
-	// resulting livelock is due to a real deadlock (and would manifest as such
-	// when using, for example, the flock implementation of this package).
-	// If the other process is *not* blocked on some other lock that we are
-	// holding, then it will eventually release the requested lock.
-
-	nextSleep := 1 * time.Millisecond
-	const maxSleep = 500 * time.Millisecond
-	for {
-		err = setlkw(f.Fd(), lt)
-		if err != syscall.EDEADLK {
-			break
-		}
-		time.Sleep(nextSleep)
-
-		nextSleep += nextSleep
-		if nextSleep > maxSleep {
-			nextSleep = maxSleep
-		}
-		// Apply 10% jitter to avoid synchronizing collisions when we finally unblock.
-		nextSleep += time.Duration((0.1*rand.Float64() - 0.05) * float64(nextSleep))
-	}
-
-	if err != nil {
-		unlock(f)
-		return &fs.PathError{
-			Op:   lt.String(),
-			Path: f.Name(),
-			Err:  err,
-		}
-	}
-
-	return nil
-}
-
-func unlock(f File) error {
-	var owner File
-
-	mu.Lock()
-	ino, ok := inodes[f]
-	if ok {
-		owner = locks[ino].owner
-	}
-	mu.Unlock()
-
-	if owner != f {
-		panic("unlock called on a file that is not locked")
-	}
-
-	err := setlkw(f.Fd(), syscall.F_UNLCK)
-
-	mu.Lock()
-	l := locks[ino]
-	if len(l.queue) == 0 {
-		// No waiters: remove the map entry.
-		delete(locks, ino)
-	} else {
-		// The first waiter is sending us their file now.
-		// Receive it and update the queue.
-		l.owner = <-l.queue[0]
-		l.queue = l.queue[1:]
-		locks[ino] = l
-	}
-	delete(inodes, f)
-	mu.Unlock()
-
-	return err
-}
-
-// setlkw calls FcntlFlock with F_SETLKW for the entire file indicated by fd.
-func setlkw(fd uintptr, lt lockType) error {
-	for {
-		err := syscall.FcntlFlock(fd, syscall.F_SETLKW, &syscall.Flock_t{
-			Type:   int16(lt),
-			Whence: io.SeekStart,
-			Start:  0,
-			Len:    0, // All bytes.
-		})
-		if err != syscall.EINTR {
-			return err
-		}
-	}
-}
-
-func isNotSupported(err error) bool {
-	return err == syscall.ENOSYS || err == syscall.ENOTSUP || err == syscall.EOPNOTSUPP || err == ErrNotSupported
-}
diff --git a/internal/lockedfile/internal/filelock/filelock_other.go b/internal/lockedfile/internal/filelock/filelock_other.go
deleted file mode 100644
index cde868f..0000000
--- a/internal/lockedfile/internal/filelock/filelock_other.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-//go:build !(aix || darwin || dragonfly || freebsd || illumos || linux || netbsd || openbsd || solaris) && !plan9 && !windows
-// +build !aix,!darwin,!dragonfly,!freebsd,!illumos,!linux,!netbsd,!openbsd,!solaris,!plan9,!windows
-
-package filelock
-
-import "io/fs"
-
-type lockType int8
-
-const (
-	readLock = iota + 1
-	writeLock
-)
-
-func lock(f File, lt lockType) error {
-	return &fs.PathError{
-		Op:   lt.String(),
-		Path: f.Name(),
-		Err:  ErrNotSupported,
-	}
-}
-
-func unlock(f File) error {
-	return &fs.PathError{
-		Op:   "Unlock",
-		Path: f.Name(),
-		Err:  ErrNotSupported,
-	}
-}
-
-func isNotSupported(err error) bool {
-	return err == ErrNotSupported
-}
diff --git a/internal/lockedfile/internal/filelock/filelock_plan9.go b/internal/lockedfile/internal/filelock/filelock_plan9.go
deleted file mode 100644
index 908afb6..0000000
--- a/internal/lockedfile/internal/filelock/filelock_plan9.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-//go:build plan9
-// +build plan9
-
-package filelock
-
-import "io/fs"
-
-type lockType int8
-
-const (
-	readLock = iota + 1
-	writeLock
-)
-
-func lock(f File, lt lockType) error {
-	return &fs.PathError{
-		Op:   lt.String(),
-		Path: f.Name(),
-		Err:  ErrNotSupported,
-	}
-}
-
-func unlock(f File) error {
-	return &fs.PathError{
-		Op:   "Unlock",
-		Path: f.Name(),
-		Err:  ErrNotSupported,
-	}
-}
-
-func isNotSupported(err error) bool {
-	return err == ErrNotSupported
-}
diff --git a/internal/lockedfile/internal/filelock/filelock_test.go b/internal/lockedfile/internal/filelock/filelock_test.go
deleted file mode 100644
index 6c3f393..0000000
--- a/internal/lockedfile/internal/filelock/filelock_test.go
+++ /dev/null
@@ -1,209 +0,0 @@
-// 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.
-
-//go:build unix || aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
-// +build unix aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
-
-package filelock_test
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"testing"
-	"time"
-
-	"golang.org/x/tools/internal/lockedfile/internal/filelock"
-)
-
-func lock(t *testing.T, f *os.File) {
-	t.Helper()
-	err := filelock.Lock(f)
-	t.Logf("Lock(fd %d) = %v", f.Fd(), err)
-	if err != nil {
-		t.Fail()
-	}
-}
-
-func rLock(t *testing.T, f *os.File) {
-	t.Helper()
-	err := filelock.RLock(f)
-	t.Logf("RLock(fd %d) = %v", f.Fd(), err)
-	if err != nil {
-		t.Fail()
-	}
-}
-
-func unlock(t *testing.T, f *os.File) {
-	t.Helper()
-	err := filelock.Unlock(f)
-	t.Logf("Unlock(fd %d) = %v", f.Fd(), err)
-	if err != nil {
-		t.Fail()
-	}
-}
-
-func mustTempFile(t *testing.T) (f *os.File, remove func()) {
-	t.Helper()
-
-	base := filepath.Base(t.Name())
-	f, err := os.CreateTemp("", base)
-	if err != nil {
-		t.Fatalf(`os.CreateTemp("", %q) = %v`, base, err)
-	}
-	t.Logf("fd %d = %s", f.Fd(), f.Name())
-
-	return f, func() {
-		f.Close()
-		os.Remove(f.Name())
-	}
-}
-
-func mustOpen(t *testing.T, name string) *os.File {
-	t.Helper()
-
-	f, err := os.OpenFile(name, os.O_RDWR, 0)
-	if err != nil {
-		t.Fatalf("os.Open(%q) = %v", name, err)
-	}
-
-	t.Logf("fd %d = os.Open(%q)", f.Fd(), name)
-	return f
-}
-
-const (
-	quiescent            = 10 * time.Millisecond
-	probablyStillBlocked = 10 * time.Second
-)
-
-func mustBlock(t *testing.T, op string, f *os.File) (wait func(*testing.T)) {
-	t.Helper()
-
-	desc := fmt.Sprintf("%s(fd %d)", op, f.Fd())
-
-	done := make(chan struct{})
-	go func() {
-		t.Helper()
-		switch op {
-		case "Lock":
-			lock(t, f)
-		case "RLock":
-			rLock(t, f)
-		default:
-			panic("invalid op: " + op)
-		}
-		close(done)
-	}()
-
-	select {
-	case <-done:
-		t.Fatalf("%s unexpectedly did not block", desc)
-		return nil
-
-	case <-time.After(quiescent):
-		t.Logf("%s is blocked (as expected)", desc)
-		return func(t *testing.T) {
-			t.Helper()
-			select {
-			case <-time.After(probablyStillBlocked):
-				t.Fatalf("%s is unexpectedly still blocked", desc)
-			case <-done:
-			}
-		}
-	}
-}
-
-func TestLockExcludesLock(t *testing.T) {
-	t.Parallel()
-
-	f, remove := mustTempFile(t)
-	defer remove()
-
-	other := mustOpen(t, f.Name())
-	defer other.Close()
-
-	lock(t, f)
-	lockOther := mustBlock(t, "Lock", other)
-	unlock(t, f)
-	lockOther(t)
-	unlock(t, other)
-}
-
-func TestLockExcludesRLock(t *testing.T) {
-	t.Parallel()
-
-	f, remove := mustTempFile(t)
-	defer remove()
-
-	other := mustOpen(t, f.Name())
-	defer other.Close()
-
-	lock(t, f)
-	rLockOther := mustBlock(t, "RLock", other)
-	unlock(t, f)
-	rLockOther(t)
-	unlock(t, other)
-}
-
-func TestRLockExcludesOnlyLock(t *testing.T) {
-	t.Parallel()
-
-	f, remove := mustTempFile(t)
-	defer remove()
-	rLock(t, f)
-
-	f2 := mustOpen(t, f.Name())
-	defer f2.Close()
-
-	doUnlockTF := false
-	switch runtime.GOOS {
-	case "aix", "solaris":
-		// When using POSIX locks (as on Solaris), we can't safely read-lock the
-		// same inode through two different descriptors at the same time: when the
-		// first descriptor is closed, the second descriptor would still be open but
-		// silently unlocked. So a second RLock must block instead of proceeding.
-		lockF2 := mustBlock(t, "RLock", f2)
-		unlock(t, f)
-		lockF2(t)
-	default:
-		rLock(t, f2)
-		doUnlockTF = true
-	}
-
-	other := mustOpen(t, f.Name())
-	defer other.Close()
-	lockOther := mustBlock(t, "Lock", other)
-
-	unlock(t, f2)
-	if doUnlockTF {
-		unlock(t, f)
-	}
-	lockOther(t)
-	unlock(t, other)
-}
-
-func TestLockNotDroppedByExecCommand(t *testing.T) {
-	f, remove := mustTempFile(t)
-	defer remove()
-
-	lock(t, f)
-
-	other := mustOpen(t, f.Name())
-	defer other.Close()
-
-	// Some kinds of file locks are dropped when a duplicated or forked file
-	// descriptor is unlocked. Double-check that the approach used by os/exec does
-	// not accidentally drop locks.
-	cmd := exec.Command(os.Args[0], "-test.run=^$")
-	if err := cmd.Run(); err != nil {
-		t.Fatalf("exec failed: %v", err)
-	}
-
-	lockOther := mustBlock(t, "Lock", other)
-	unlock(t, f)
-	lockOther(t)
-	unlock(t, other)
-}
diff --git a/internal/lockedfile/internal/filelock/filelock_unix.go b/internal/lockedfile/internal/filelock/filelock_unix.go
deleted file mode 100644
index 878a1e7..0000000
--- a/internal/lockedfile/internal/filelock/filelock_unix.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// 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.
-
-//go:build darwin || dragonfly || freebsd || illumos || linux || netbsd || openbsd
-// +build darwin dragonfly freebsd illumos linux netbsd openbsd
-
-package filelock
-
-import (
-	"io/fs"
-	"syscall"
-)
-
-type lockType int16
-
-const (
-	readLock  lockType = syscall.LOCK_SH
-	writeLock lockType = syscall.LOCK_EX
-)
-
-func lock(f File, lt lockType) (err error) {
-	for {
-		err = syscall.Flock(int(f.Fd()), int(lt))
-		if err != syscall.EINTR {
-			break
-		}
-	}
-	if err != nil {
-		return &fs.PathError{
-			Op:   lt.String(),
-			Path: f.Name(),
-			Err:  err,
-		}
-	}
-	return nil
-}
-
-func unlock(f File) error {
-	return lock(f, syscall.LOCK_UN)
-}
-
-func isNotSupported(err error) bool {
-	return err == syscall.ENOSYS || err == syscall.ENOTSUP || err == syscall.EOPNOTSUPP || err == ErrNotSupported
-}
diff --git a/internal/lockedfile/internal/filelock/filelock_windows.go b/internal/lockedfile/internal/filelock/filelock_windows.go
deleted file mode 100644
index 3273a81..0000000
--- a/internal/lockedfile/internal/filelock/filelock_windows.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// 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.
-
-//go:build windows
-// +build windows
-
-package filelock
-
-import (
-	"io/fs"
-
-	"golang.org/x/sys/windows"
-)
-
-type lockType uint32
-
-const (
-	readLock  lockType = 0
-	writeLock lockType = windows.LOCKFILE_EXCLUSIVE_LOCK
-)
-
-const (
-	reserved = 0
-	allBytes = ^uint32(0)
-)
-
-func lock(f File, lt lockType) error {
-	// Per https://golang.org/issue/19098, “Programs currently expect the Fd
-	// method to return a handle that uses ordinary synchronous I/O.”
-	// However, LockFileEx still requires an OVERLAPPED structure,
-	// which contains the file offset of the beginning of the lock range.
-	// We want to lock the entire file, so we leave the offset as zero.
-	ol := new(windows.Overlapped)
-
-	err := windows.LockFileEx(windows.Handle(f.Fd()), uint32(lt), reserved, allBytes, allBytes, ol)
-	if err != nil {
-		return &fs.PathError{
-			Op:   lt.String(),
-			Path: f.Name(),
-			Err:  err,
-		}
-	}
-	return nil
-}
-
-func unlock(f File) error {
-	ol := new(windows.Overlapped)
-	err := windows.UnlockFileEx(windows.Handle(f.Fd()), reserved, allBytes, allBytes, ol)
-	if err != nil {
-		return &fs.PathError{
-			Op:   "Unlock",
-			Path: f.Name(),
-			Err:  err,
-		}
-	}
-	return nil
-}
-
-func isNotSupported(err error) bool {
-	switch err {
-	case windows.ERROR_NOT_SUPPORTED, windows.ERROR_CALL_NOT_IMPLEMENTED, ErrNotSupported:
-		return true
-	default:
-		return false
-	}
-}
diff --git a/internal/lockedfile/lockedfile.go b/internal/lockedfile/lockedfile.go
deleted file mode 100644
index 82e1a89..0000000
--- a/internal/lockedfile/lockedfile.go
+++ /dev/null
@@ -1,187 +0,0 @@
-// 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 lockedfile creates and manipulates files whose contents should only
-// change atomically.
-package lockedfile
-
-import (
-	"fmt"
-	"io"
-	"io/fs"
-	"os"
-	"runtime"
-)
-
-// A File is a locked *os.File.
-//
-// Closing the file releases the lock.
-//
-// If the program exits while a file is locked, the operating system releases
-// the lock but may not do so promptly: callers must ensure that all locked
-// files are closed before exiting.
-type File struct {
-	osFile
-	closed bool
-}
-
-// osFile embeds a *os.File while keeping the pointer itself unexported.
-// (When we close a File, it must be the same file descriptor that we opened!)
-type osFile struct {
-	*os.File
-}
-
-// OpenFile is like os.OpenFile, but returns a locked file.
-// If flag includes os.O_WRONLY or os.O_RDWR, the file is write-locked;
-// otherwise, it is read-locked.
-func OpenFile(name string, flag int, perm fs.FileMode) (*File, error) {
-	var (
-		f   = new(File)
-		err error
-	)
-	f.osFile.File, err = openFile(name, flag, perm)
-	if err != nil {
-		return nil, err
-	}
-
-	// Although the operating system will drop locks for open files when the go
-	// command exits, we want to hold locks for as little time as possible, and we
-	// especially don't want to leave a file locked after we're done with it. Our
-	// Close method is what releases the locks, so use a finalizer to report
-	// missing Close calls on a best-effort basis.
-	runtime.SetFinalizer(f, func(f *File) {
-		panic(fmt.Sprintf("lockedfile.File %s became unreachable without a call to Close", f.Name()))
-	})
-
-	return f, nil
-}
-
-// Open is like os.Open, but returns a read-locked file.
-func Open(name string) (*File, error) {
-	return OpenFile(name, os.O_RDONLY, 0)
-}
-
-// Create is like os.Create, but returns a write-locked file.
-func Create(name string) (*File, error) {
-	return OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
-}
-
-// Edit creates the named file with mode 0666 (before umask),
-// but does not truncate existing contents.
-//
-// If Edit succeeds, methods on the returned File can be used for I/O.
-// The associated file descriptor has mode O_RDWR and the file is write-locked.
-func Edit(name string) (*File, error) {
-	return OpenFile(name, os.O_RDWR|os.O_CREATE, 0666)
-}
-
-// Close unlocks and closes the underlying file.
-//
-// Close may be called multiple times; all calls after the first will return a
-// non-nil error.
-func (f *File) Close() error {
-	if f.closed {
-		return &fs.PathError{
-			Op:   "close",
-			Path: f.Name(),
-			Err:  fs.ErrClosed,
-		}
-	}
-	f.closed = true
-
-	err := closeFile(f.osFile.File)
-	runtime.SetFinalizer(f, nil)
-	return err
-}
-
-// Read opens the named file with a read-lock and returns its contents.
-func Read(name string) ([]byte, error) {
-	f, err := Open(name)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	return io.ReadAll(f)
-}
-
-// Write opens the named file (creating it with the given permissions if needed),
-// then write-locks it and overwrites it with the given content.
-func Write(name string, content io.Reader, perm fs.FileMode) (err error) {
-	f, err := OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
-	if err != nil {
-		return err
-	}
-
-	_, err = io.Copy(f, content)
-	if closeErr := f.Close(); err == nil {
-		err = closeErr
-	}
-	return err
-}
-
-// Transform invokes t with the result of reading the named file, with its lock
-// still held.
-//
-// If t returns a nil error, Transform then writes the returned contents back to
-// the file, making a best effort to preserve existing contents on error.
-//
-// t must not modify the slice passed to it.
-func Transform(name string, t func([]byte) ([]byte, error)) (err error) {
-	f, err := Edit(name)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	old, err := io.ReadAll(f)
-	if err != nil {
-		return err
-	}
-
-	new, err := t(old)
-	if err != nil {
-		return err
-	}
-
-	if len(new) > len(old) {
-		// The overall file size is increasing, so write the tail first: if we're
-		// about to run out of space on the disk, we would rather detect that
-		// failure before we have overwritten the original contents.
-		if _, err := f.WriteAt(new[len(old):], int64(len(old))); err != nil {
-			// Make a best effort to remove the incomplete tail.
-			f.Truncate(int64(len(old)))
-			return err
-		}
-	}
-
-	// We're about to overwrite the old contents. In case of failure, make a best
-	// effort to roll back before we close the file.
-	defer func() {
-		if err != nil {
-			if _, err := f.WriteAt(old, 0); err == nil {
-				f.Truncate(int64(len(old)))
-			}
-		}
-	}()
-
-	if len(new) >= len(old) {
-		if _, err := f.WriteAt(new[:len(old)], 0); err != nil {
-			return err
-		}
-	} else {
-		if _, err := f.WriteAt(new, 0); err != nil {
-			return err
-		}
-		// The overall file size is decreasing, so shrink the file to its final size
-		// after writing. We do this after writing (instead of before) so that if
-		// the write fails, enough filesystem space will likely still be reserved
-		// to contain the previous contents.
-		if err := f.Truncate(int64(len(new))); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
diff --git a/internal/lockedfile/lockedfile_filelock.go b/internal/lockedfile/lockedfile_filelock.go
deleted file mode 100644
index 7c71672..0000000
--- a/internal/lockedfile/lockedfile_filelock.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// 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.
-
-//go:build !plan9
-// +build !plan9
-
-package lockedfile
-
-import (
-	"io/fs"
-	"os"
-
-	"golang.org/x/tools/internal/lockedfile/internal/filelock"
-)
-
-func openFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
-	// On BSD systems, we could add the O_SHLOCK or O_EXLOCK flag to the OpenFile
-	// call instead of locking separately, but we have to support separate locking
-	// calls for Linux and Windows anyway, so it's simpler to use that approach
-	// consistently.
-
-	f, err := os.OpenFile(name, flag&^os.O_TRUNC, perm)
-	if err != nil {
-		return nil, err
-	}
-
-	switch flag & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR) {
-	case os.O_WRONLY, os.O_RDWR:
-		err = filelock.Lock(f)
-	default:
-		err = filelock.RLock(f)
-	}
-	if err != nil {
-		f.Close()
-		return nil, err
-	}
-
-	if flag&os.O_TRUNC == os.O_TRUNC {
-		if err := f.Truncate(0); err != nil {
-			// The documentation for os.O_TRUNC says “if possible, truncate file when
-			// opened”, but doesn't define “possible” (golang.org/issue/28699).
-			// We'll treat regular files (and symlinks to regular files) as “possible”
-			// and ignore errors for the rest.
-			if fi, statErr := f.Stat(); statErr != nil || fi.Mode().IsRegular() {
-				filelock.Unlock(f)
-				f.Close()
-				return nil, err
-			}
-		}
-	}
-
-	return f, nil
-}
-
-func closeFile(f *os.File) error {
-	// Since locking syscalls operate on file descriptors, we must unlock the file
-	// while the descriptor is still valid — that is, before the file is closed —
-	// and avoid unlocking files that are already closed.
-	err := filelock.Unlock(f)
-
-	if closeErr := f.Close(); err == nil {
-		err = closeErr
-	}
-	return err
-}
diff --git a/internal/lockedfile/lockedfile_plan9.go b/internal/lockedfile/lockedfile_plan9.go
deleted file mode 100644
index 40871e6..0000000
--- a/internal/lockedfile/lockedfile_plan9.go
+++ /dev/null
@@ -1,95 +0,0 @@
-// 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.
-
-//go:build plan9
-// +build plan9
-
-package lockedfile
-
-import (
-	"io/fs"
-	"math/rand"
-	"os"
-	"strings"
-	"time"
-)
-
-// Opening an exclusive-use file returns an error.
-// The expected error strings are:
-//
-//   - "open/create -- file is locked" (cwfs, kfs)
-//   - "exclusive lock" (fossil)
-//   - "exclusive use file already open" (ramfs)
-var lockedErrStrings = [...]string{
-	"file is locked",
-	"exclusive lock",
-	"exclusive use file already open",
-}
-
-// Even though plan9 doesn't support the Lock/RLock/Unlock functions to
-// manipulate already-open files, IsLocked is still meaningful: os.OpenFile
-// itself may return errors that indicate that a file with the ModeExclusive bit
-// set is already open.
-func isLocked(err error) bool {
-	s := err.Error()
-
-	for _, frag := range lockedErrStrings {
-		if strings.Contains(s, frag) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func openFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
-	// Plan 9 uses a mode bit instead of explicit lock/unlock syscalls.
-	//
-	// Per http://man.cat-v.org/plan_9/5/stat: “Exclusive use files may be open
-	// for I/O by only one fid at a time across all clients of the server. If a
-	// second open is attempted, it draws an error.”
-	//
-	// So we can try to open a locked file, but if it fails we're on our own to
-	// figure out when it becomes available. We'll use exponential backoff with
-	// some jitter and an arbitrary limit of 500ms.
-
-	// If the file was unpacked or created by some other program, it might not
-	// have the ModeExclusive bit set. Set it before we call OpenFile, so that we
-	// can be confident that a successful OpenFile implies exclusive use.
-	if fi, err := os.Stat(name); err == nil {
-		if fi.Mode()&fs.ModeExclusive == 0 {
-			if err := os.Chmod(name, fi.Mode()|fs.ModeExclusive); err != nil {
-				return nil, err
-			}
-		}
-	} else if !os.IsNotExist(err) {
-		return nil, err
-	}
-
-	nextSleep := 1 * time.Millisecond
-	const maxSleep = 500 * time.Millisecond
-	for {
-		f, err := os.OpenFile(name, flag, perm|fs.ModeExclusive)
-		if err == nil {
-			return f, nil
-		}
-
-		if !isLocked(err) {
-			return nil, err
-		}
-
-		time.Sleep(nextSleep)
-
-		nextSleep += nextSleep
-		if nextSleep > maxSleep {
-			nextSleep = maxSleep
-		}
-		// Apply 10% jitter to avoid synchronizing collisions.
-		nextSleep += time.Duration((0.1*rand.Float64() - 0.05) * float64(nextSleep))
-	}
-}
-
-func closeFile(f *os.File) error {
-	return f.Close()
-}
diff --git a/internal/lockedfile/lockedfile_test.go b/internal/lockedfile/lockedfile_test.go
deleted file mode 100644
index edf8851..0000000
--- a/internal/lockedfile/lockedfile_test.go
+++ /dev/null
@@ -1,268 +0,0 @@
-// 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.
-
-//go:build unix || aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || plan9 || windows
-// +build unix aix darwin dragonfly freebsd linux netbsd openbsd solaris plan9 windows
-
-package lockedfile_test
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"golang.org/x/tools/internal/lockedfile"
-)
-
-func mustTempDir(t *testing.T) (dir string, remove func()) {
-	t.Helper()
-
-	dir, err := os.MkdirTemp("", filepath.Base(t.Name()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	return dir, func() { os.RemoveAll(dir) }
-}
-
-const (
-	quiescent            = 10 * time.Millisecond
-	probablyStillBlocked = 10 * time.Second
-)
-
-func mustBlock(t *testing.T, desc string, f func()) (wait func(*testing.T)) {
-	t.Helper()
-
-	done := make(chan struct{})
-	go func() {
-		f()
-		close(done)
-	}()
-
-	select {
-	case <-done:
-		t.Fatalf("%s unexpectedly did not block", desc)
-		return nil
-
-	case <-time.After(quiescent):
-		return func(t *testing.T) {
-			t.Helper()
-			select {
-			case <-time.After(probablyStillBlocked):
-				t.Fatalf("%s is unexpectedly still blocked after %v", desc, probablyStillBlocked)
-			case <-done:
-			}
-		}
-	}
-}
-
-func TestMutexExcludes(t *testing.T) {
-	t.Parallel()
-
-	dir, remove := mustTempDir(t)
-	defer remove()
-
-	path := filepath.Join(dir, "lock")
-
-	mu := lockedfile.MutexAt(path)
-	t.Logf("mu := MutexAt(_)")
-
-	unlock, err := mu.Lock()
-	if err != nil {
-		t.Fatalf("mu.Lock: %v", err)
-	}
-	t.Logf("unlock, _  := mu.Lock()")
-
-	mu2 := lockedfile.MutexAt(mu.Path)
-	t.Logf("mu2 := MutexAt(mu.Path)")
-
-	wait := mustBlock(t, "mu2.Lock()", func() {
-		unlock2, err := mu2.Lock()
-		if err != nil {
-			t.Errorf("mu2.Lock: %v", err)
-			return
-		}
-		t.Logf("unlock2, _ := mu2.Lock()")
-		t.Logf("unlock2()")
-		unlock2()
-	})
-
-	t.Logf("unlock()")
-	unlock()
-	wait(t)
-}
-
-func TestReadWaitsForLock(t *testing.T) {
-	t.Parallel()
-
-	dir, remove := mustTempDir(t)
-	defer remove()
-
-	path := filepath.Join(dir, "timestamp.txt")
-
-	f, err := lockedfile.Create(path)
-	if err != nil {
-		t.Fatalf("Create: %v", err)
-	}
-	defer f.Close()
-
-	const (
-		part1 = "part 1\n"
-		part2 = "part 2\n"
-	)
-	_, err = f.WriteString(part1)
-	if err != nil {
-		t.Fatalf("WriteString: %v", err)
-	}
-	t.Logf("WriteString(%q) = <nil>", part1)
-
-	wait := mustBlock(t, "Read", func() {
-		b, err := lockedfile.Read(path)
-		if err != nil {
-			t.Errorf("Read: %v", err)
-			return
-		}
-
-		const want = part1 + part2
-		got := string(b)
-		if got == want {
-			t.Logf("Read(_) = %q", got)
-		} else {
-			t.Errorf("Read(_) = %q, _; want %q", got, want)
-		}
-	})
-
-	_, err = f.WriteString(part2)
-	if err != nil {
-		t.Errorf("WriteString: %v", err)
-	} else {
-		t.Logf("WriteString(%q) = <nil>", part2)
-	}
-	f.Close()
-
-	wait(t)
-}
-
-func TestCanLockExistingFile(t *testing.T) {
-	t.Parallel()
-
-	dir, remove := mustTempDir(t)
-	defer remove()
-	path := filepath.Join(dir, "existing.txt")
-
-	if err := os.WriteFile(path, []byte("ok"), 0777); err != nil {
-		t.Fatalf("os.WriteFile: %v", err)
-	}
-
-	f, err := lockedfile.Edit(path)
-	if err != nil {
-		t.Fatalf("first Edit: %v", err)
-	}
-
-	wait := mustBlock(t, "Edit", func() {
-		other, err := lockedfile.Edit(path)
-		if err != nil {
-			t.Errorf("second Edit: %v", err)
-		}
-		other.Close()
-	})
-
-	f.Close()
-	wait(t)
-}
-
-// TestSpuriousEDEADLK verifies that the spurious EDEADLK reported in
-// https://golang.org/issue/32817 no longer occurs.
-func TestSpuriousEDEADLK(t *testing.T) {
-	// 	P.1 locks file A.
-	// 	Q.3 locks file B.
-	// 	Q.3 blocks on file A.
-	// 	P.2 blocks on file B. (Spurious EDEADLK occurs here.)
-	// 	P.1 unlocks file A.
-	// 	Q.3 unblocks and locks file A.
-	// 	Q.3 unlocks files A and B.
-	// 	P.2 unblocks and locks file B.
-	// 	P.2 unlocks file B.
-
-	dirVar := t.Name() + "DIR"
-
-	if dir := os.Getenv(dirVar); dir != "" {
-		// Q.3 locks file B.
-		b, err := lockedfile.Edit(filepath.Join(dir, "B"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer b.Close()
-
-		if err := os.WriteFile(filepath.Join(dir, "locked"), []byte("ok"), 0666); err != nil {
-			t.Fatal(err)
-		}
-
-		// Q.3 blocks on file A.
-		a, err := lockedfile.Edit(filepath.Join(dir, "A"))
-		// Q.3 unblocks and locks file A.
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer a.Close()
-
-		// Q.3 unlocks files A and B.
-		return
-	}
-
-	dir, remove := mustTempDir(t)
-	defer remove()
-
-	// P.1 locks file A.
-	a, err := lockedfile.Edit(filepath.Join(dir, "A"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := exec.Command(os.Args[0], "-test.run="+t.Name())
-	cmd.Env = append(os.Environ(), fmt.Sprintf("%s=%s", dirVar, dir))
-
-	qDone := make(chan struct{})
-	waitQ := mustBlock(t, "Edit A and B in subprocess", func() {
-		out, err := cmd.CombinedOutput()
-		if err != nil {
-			t.Errorf("%v:\n%s", err, out)
-		}
-		close(qDone)
-	})
-
-	// Wait until process Q has either failed or locked file B.
-	// Otherwise, P.2 might not block on file B as intended.
-locked:
-	for {
-		if _, err := os.Stat(filepath.Join(dir, "locked")); !os.IsNotExist(err) {
-			break locked
-		}
-		select {
-		case <-qDone:
-			break locked
-		case <-time.After(1 * time.Millisecond):
-		}
-	}
-
-	waitP2 := mustBlock(t, "Edit B", func() {
-		// P.2 blocks on file B. (Spurious EDEADLK occurs here.)
-		b, err := lockedfile.Edit(filepath.Join(dir, "B"))
-		// P.2 unblocks and locks file B.
-		if err != nil {
-			t.Error(err)
-			return
-		}
-		// P.2 unlocks file B.
-		b.Close()
-	})
-
-	// P.1 unlocks file A.
-	a.Close()
-
-	waitQ(t)
-	waitP2(t)
-}
diff --git a/internal/lockedfile/mutex.go b/internal/lockedfile/mutex.go
deleted file mode 100644
index 180a36c..0000000
--- a/internal/lockedfile/mutex.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// 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 lockedfile
-
-import (
-	"fmt"
-	"os"
-	"sync"
-)
-
-// A Mutex provides mutual exclusion within and across processes by locking a
-// well-known file. Such a file generally guards some other part of the
-// filesystem: for example, a Mutex file in a directory might guard access to
-// the entire tree rooted in that directory.
-//
-// Mutex does not implement sync.Locker: unlike a sync.Mutex, a lockedfile.Mutex
-// can fail to lock (e.g. if there is a permission error in the filesystem).
-//
-// Like a sync.Mutex, a Mutex may be included as a field of a larger struct but
-// must not be copied after first use. The Path field must be set before first
-// use and must not be change thereafter.
-type Mutex struct {
-	Path string     // The path to the well-known lock file. Must be non-empty.
-	mu   sync.Mutex // A redundant mutex. The race detector doesn't know about file locking, so in tests we may need to lock something that it understands.
-}
-
-// MutexAt returns a new Mutex with Path set to the given non-empty path.
-func MutexAt(path string) *Mutex {
-	if path == "" {
-		panic("lockedfile.MutexAt: path must be non-empty")
-	}
-	return &Mutex{Path: path}
-}
-
-func (mu *Mutex) String() string {
-	return fmt.Sprintf("lockedfile.Mutex(%s)", mu.Path)
-}
-
-// Lock attempts to lock the Mutex.
-//
-// If successful, Lock returns a non-nil unlock function: it is provided as a
-// return-value instead of a separate method to remind the caller to check the
-// accompanying error. (See https://golang.org/issue/20803.)
-func (mu *Mutex) Lock() (unlock func(), err error) {
-	if mu.Path == "" {
-		panic("lockedfile.Mutex: missing Path during Lock")
-	}
-
-	// We could use either O_RDWR or O_WRONLY here. If we choose O_RDWR and the
-	// file at mu.Path is write-only, the call to OpenFile will fail with a
-	// permission error. That's actually what we want: if we add an RLock method
-	// in the future, it should call OpenFile with O_RDONLY and will require the
-	// files must be readable, so we should not let the caller make any
-	// assumptions about Mutex working with write-only files.
-	f, err := OpenFile(mu.Path, os.O_RDWR|os.O_CREATE, 0666)
-	if err != nil {
-		return nil, err
-	}
-	mu.mu.Lock()
-
-	return func() {
-		mu.mu.Unlock()
-		f.Close()
-	}, nil
-}
diff --git a/internal/lockedfile/transform_test.go b/internal/lockedfile/transform_test.go
deleted file mode 100644
index 2c0cd53..0000000
--- a/internal/lockedfile/transform_test.go
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2019 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.
-
-//go:build unix || aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || plan9 || windows
-// +build unix aix darwin dragonfly freebsd linux netbsd openbsd solaris plan9 windows
-
-package lockedfile_test
-
-import (
-	"bytes"
-	"encoding/binary"
-	"math/rand"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"golang.org/x/tools/internal/lockedfile"
-)
-
-func isPowerOf2(x int) bool {
-	return x > 0 && x&(x-1) == 0
-}
-
-func roundDownToPowerOf2(x int) int {
-	if x <= 0 {
-		panic("nonpositive x")
-	}
-	bit := 1
-	for x != bit {
-		x = x &^ bit
-		bit <<= 1
-	}
-	return x
-}
-
-func TestTransform(t *testing.T) {
-	dir, remove := mustTempDir(t)
-	defer remove()
-	path := filepath.Join(dir, "blob.bin")
-
-	const maxChunkWords = 8 << 10
-	buf := make([]byte, 2*maxChunkWords*8)
-	for i := uint64(0); i < 2*maxChunkWords; i++ {
-		binary.LittleEndian.PutUint64(buf[i*8:], i)
-	}
-	if err := lockedfile.Write(path, bytes.NewReader(buf[:8]), 0666); err != nil {
-		t.Fatal(err)
-	}
-
-	var attempts int64 = 128
-	if !testing.Short() {
-		attempts *= 16
-	}
-	const parallel = 32
-
-	var sem = make(chan bool, parallel)
-
-	for n := attempts; n > 0; n-- {
-		sem <- true
-		go func() {
-			defer func() { <-sem }()
-
-			time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
-			chunkWords := roundDownToPowerOf2(rand.Intn(maxChunkWords) + 1)
-			offset := rand.Intn(chunkWords)
-
-			err := lockedfile.Transform(path, func(data []byte) (chunk []byte, err error) {
-				chunk = buf[offset*8 : (offset+chunkWords)*8]
-
-				if len(data)&^7 != len(data) {
-					t.Errorf("read %d bytes, but each write is an integer multiple of 8 bytes", len(data))
-					return chunk, nil
-				}
-
-				words := len(data) / 8
-				if !isPowerOf2(words) {
-					t.Errorf("read %d 8-byte words, but each write is a power-of-2 number of words", words)
-					return chunk, nil
-				}
-
-				u := binary.LittleEndian.Uint64(data)
-				for i := 1; i < words; i++ {
-					next := binary.LittleEndian.Uint64(data[i*8:])
-					if next != u+1 {
-						t.Errorf("wrote sequential integers, but read integer out of sequence at offset %d", i)
-						return chunk, nil
-					}
-					u = next
-				}
-
-				return chunk, nil
-			})
-
-			if err != nil {
-				t.Errorf("unexpected error from Transform: %v", err)
-			}
-		}()
-	}
-
-	for n := parallel; n > 0; n-- {
-		sem <- true
-	}
-}
diff --git a/internal/typesinternal/types.go b/internal/typesinternal/types.go
index 3c53fbc..ce7d435 100644
--- a/internal/typesinternal/types.go
+++ b/internal/typesinternal/types.go
@@ -11,8 +11,6 @@
 	"go/types"
 	"reflect"
 	"unsafe"
-
-	"golang.org/x/tools/go/types/objectpath"
 )
 
 func SetUsesCgo(conf *types.Config) bool {
@@ -52,10 +50,3 @@
 }
 
 var SetGoVersion = func(conf *types.Config, version string) bool { return false }
-
-// NewObjectpathEncoder returns a function closure equivalent to
-// objectpath.For but amortized for multiple (sequential) calls.
-// It is a temporary workaround, pending the approval of proposal 58668.
-//
-//go:linkname NewObjectpathFunc golang.org/x/tools/go/types/objectpath.newEncoderFor
-func NewObjectpathFunc() func(types.Object) (objectpath.Path, error)
diff --git a/present/doc.go b/present/doc.go
index 71f758f..2c88fb9 100644
--- a/present/doc.go
+++ b/present/doc.go
@@ -200,8 +200,11 @@
 a single marker character becomes a space and a doubled single
 marker quotes the marker character.
 
-Links can be included in any text with the form [[url][label]], or
-[[url]] to use the URL itself as the label.
+Links can be included in any text with either explicit labels
+or the URL itself as the label. For example:
+
+	[[url][label]]
+	[[url]]
 
 # Command Invocations