diff --git a/go/internal/packagesdriver/sizes.go b/go/internal/packagesdriver/sizes.go
index 35bc6a4..f4d73b2 100644
--- a/go/internal/packagesdriver/sizes.go
+++ b/go/internal/packagesdriver/sizes.go
@@ -6,12 +6,9 @@
 package packagesdriver
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"go/types"
-	"os/exec"
 	"strings"
 
 	"golang.org/x/tools/internal/gocommand"
@@ -19,67 +16,6 @@
 
 var debug = false
 
-func GetSizes(ctx context.Context, buildFlags, env []string, gocmdRunner *gocommand.Runner, dir string) (types.Sizes, error) {
-	// TODO(matloob): Clean this up. This code is mostly a copy of packages.findExternalDriver.
-	const toolPrefix = "GOPACKAGESDRIVER="
-	tool := ""
-	for _, env := range env {
-		if val := strings.TrimPrefix(env, toolPrefix); val != env {
-			tool = val
-		}
-	}
-
-	if tool == "" {
-		var err error
-		tool, err = exec.LookPath("gopackagesdriver")
-		if err != nil {
-			// We did not find the driver, so use "go list".
-			tool = "off"
-		}
-	}
-
-	if tool == "off" {
-		inv := gocommand.Invocation{
-			BuildFlags: buildFlags,
-			Env:        env,
-			WorkingDir: dir,
-		}
-		return GetSizesGolist(ctx, inv, gocmdRunner)
-	}
-
-	req, err := json.Marshal(struct {
-		Command    string   `json:"command"`
-		Env        []string `json:"env"`
-		BuildFlags []string `json:"build_flags"`
-	}{
-		Command:    "sizes",
-		Env:        env,
-		BuildFlags: buildFlags,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
-	}
-
-	buf := new(bytes.Buffer)
-	cmd := exec.CommandContext(ctx, tool)
-	cmd.Dir = dir
-	cmd.Env = env
-	cmd.Stdin = bytes.NewReader(req)
-	cmd.Stdout = buf
-	cmd.Stderr = new(bytes.Buffer)
-	if err := cmd.Run(); err != nil {
-		return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
-	}
-	var response struct {
-		// Sizes, if not nil, is the types.Sizes to use when type checking.
-		Sizes *types.StdSizes
-	}
-	if err := json.Unmarshal(buf.Bytes(), &response); err != nil {
-		return nil, err
-	}
-	return response.Sizes, nil
-}
-
 func GetSizesGolist(ctx context.Context, inv gocommand.Invocation, gocmdRunner *gocommand.Runner) (types.Sizes, error) {
 	inv.Verb = "list"
 	inv.Args = []string{"-f", "{{context.GOARCH}} {{context.Compiler}}", "--", "unsafe"}
diff --git a/go/packages/external.go b/go/packages/external.go
index 8c8473f..7db1d12 100644
--- a/go/packages/external.go
+++ b/go/packages/external.go
@@ -89,7 +89,7 @@
 			return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
 		}
 		if len(stderr.Bytes()) != 0 && os.Getenv("GOPACKAGESPRINTDRIVERERRORS") != "" {
-			fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cmd, words...), stderr)
+			fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cmd), stderr)
 		}
 
 		var response driverResponse
diff --git a/go/packages/golist.go b/go/packages/golist.go
index 81381fa..c83ca09 100644
--- a/go/packages/golist.go
+++ b/go/packages/golist.go
@@ -827,6 +827,7 @@
 		BuildFlags: cfg.BuildFlags,
 		ModFile:    cfg.modFile,
 		ModFlag:    cfg.modFlag,
+		CleanEnv:   cfg.Env != nil,
 		Env:        cfg.Env,
 		Logf:       cfg.Logf,
 		WorkingDir: cfg.Dir,
@@ -901,8 +902,13 @@
 			return unicode.IsOneOf([]*unicode.RangeTable{unicode.L, unicode.M, unicode.N, unicode.P, unicode.S}, r) &&
 				!strings.ContainsRune("!\"#$%&'()*,:;<=>?[\\]^`{|}\uFFFD", r)
 		}
+		// golang/go#36770: Handle case where cmd/go prints module download messages before the error.
+		msg := stderr.String()
+		for strings.HasPrefix(msg, "go: downloading") {
+			msg = msg[strings.IndexRune(msg, '\n')+1:]
+		}
 		if len(stderr.String()) > 0 && strings.HasPrefix(stderr.String(), "# ") {
-			msg := stderr.String()[len("# "):]
+			msg := msg[len("# "):]
 			if strings.HasPrefix(strings.TrimLeftFunc(msg, isPkgPathRune), "\n") {
 				return stdout, nil
 			}
@@ -1069,17 +1075,22 @@
 	return false
 }
 
-func cmdDebugStr(cmd *exec.Cmd, args ...string) string {
+func cmdDebugStr(cmd *exec.Cmd) string {
 	env := make(map[string]string)
 	for _, kv := range cmd.Env {
-		split := strings.Split(kv, "=")
+		split := strings.SplitN(kv, "=", 2)
 		k, v := split[0], split[1]
 		env[k] = v
 	}
-	var quotedArgs []string
-	for _, arg := range args {
-		quotedArgs = append(quotedArgs, strconv.Quote(arg))
-	}
 
-	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v PWD=%v go %s", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["PWD"], strings.Join(quotedArgs, " "))
+	var args []string
+	for _, arg := range cmd.Args {
+		quoted := strconv.Quote(arg)
+		if quoted[1:len(quoted)-1] != arg || strings.Contains(arg, " ") {
+			args = append(args, quoted)
+		} else {
+			args = append(args, arg)
+		}
+	}
+	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
 }
diff --git a/go/packages/packages_test.go b/go/packages/packages_test.go
index a5351ab..06b01f6 100644
--- a/go/packages/packages_test.go
+++ b/go/packages/packages_test.go
@@ -86,8 +86,8 @@
 	hash := initial[0]
 	// Even though the hash package has imports,
 	// they are not reported.
-	got := fmt.Sprintf("iamashamedtousethedisabledqueryname=%s srcs=%v imports=%v", hash.Name, srcs(hash), hash.Imports)
-	want := "iamashamedtousethedisabledqueryname=hash srcs=[hash.go] imports=map[]"
+	got := fmt.Sprintf("srcs=%v imports=%v", srcs(hash), hash.Imports)
+	want := "srcs=[hash.go] imports=map[]"
 	if got != want {
 		t.Fatalf("got %s, want %s", got, want)
 	}
@@ -2628,6 +2628,16 @@
 	}
 }
 
+func TestEmptyEnvironment(t *testing.T) {
+	cfg := &packages.Config{
+		Env: []string{"FOO=BAR"},
+	}
+	_, err := packages.Load(cfg, "fmt")
+	if err == nil {
+		t.Fatal("Load with explicitly empty environment should fail")
+	}
+}
+
 func errorMessages(errors []packages.Error) []string {
 	var msgs []string
 	for _, err := range errors {
diff --git a/go/ssa/mode.go b/go/ssa/mode.go
index d2a2698..298f24b 100644
--- a/go/ssa/mode.go
+++ b/go/ssa/mode.go
@@ -66,6 +66,9 @@
 	if m&BuildSerially != 0 {
 		buf.WriteByte('L')
 	}
+	if m&BareInits != 0 {
+		buf.WriteByte('I')
+	}
 	return buf.String()
 }
 
@@ -88,6 +91,8 @@
 			mode |= NaiveForm
 		case 'L':
 			mode |= BuildSerially
+		case 'I':
+			mode |= BareInits
 		default:
 			return fmt.Errorf("unknown BuilderMode option: %q", c)
 		}
diff --git a/gopls/doc/settings.md b/gopls/doc/settings.md
index 1735953..98a8221 100644
--- a/gopls/doc/settings.md
+++ b/gopls/doc/settings.md
@@ -249,9 +249,12 @@
 
 Default: `false`.
 ### **expandWorkspaceToModule** *bool*
-expandWorkspaceToModule instructs `gopls` to expand the scope of the workspace to include the
-modules containing the workspace folders. Set this to false to avoid loading
-your entire module. This is particularly useful for those working in a monorepo.
+expandWorkspaceToModule instructs `gopls` to adjust the scope of the
+workspace to find the best available module root. `gopls` first looks for
+a go.mod file in any parent directory of the workspace folder, expanding
+the scope to that directory if it exists. If no viable parent directory is
+found, gopls will check if there is exactly one child directory containing
+a go.mod file, narrowing the scope to that directory if it exists.
 
 
 Default: `true`.
@@ -281,7 +284,7 @@
 comprehensively test.
 
 
-Default: `false`.
+Default: `true`.
 <!-- END Experimental: DO NOT MANUALLY EDIT THIS SECTION -->
 
 ## Debugging
diff --git a/gopls/internal/regtest/diagnostics_test.go b/gopls/internal/regtest/diagnostics_test.go
index d3685dd..90d0938 100644
--- a/gopls/internal/regtest/diagnostics_test.go
+++ b/gopls/internal/regtest/diagnostics_test.go
@@ -852,28 +852,29 @@
 
 // Reproduce golang/go#40690.
 func TestCreateOnlyXTest(t *testing.T) {
-	t.Skip("golang/go#40690 is not resolved yet.")
-
 	const mod = `
-	-- go.mod --
-	module mod.com
-	-- foo/foo.go --
-	package foo
-	-- foo/bar_test.go --
-	`
+-- go.mod --
+module mod.com
+-- foo/foo.go --
+package foo
+-- foo/bar_test.go --
+`
 	run(t, mod, func(t *testing.T, env *Env) {
 		env.OpenFile("foo/bar_test.go")
-		env.EditBuffer("foo/bar_test.go", fake.NewEdit(0, 0, 0, 0, `package foo
-	`))
+		env.EditBuffer("foo/bar_test.go", fake.NewEdit(0, 0, 0, 0, "package foo"))
 		env.Await(
 			CompletedWork(lsp.DiagnosticWorkTitle(lsp.FromDidChange), 1),
 		)
-		env.RegexpReplace("foo/bar_test.go", "package foo", "package foo_test")
+		env.RegexpReplace("foo/bar_test.go", "package foo", `package foo_test
+
+import "testing"
+
+func TestX(t *testing.T) {
+	var x int
+}
+`)
 		env.Await(
-			OnceMet(
-				CompletedWork(lsp.DiagnosticWorkTitle(lsp.FromDidChange), 2),
-				NoErrorLogs(),
-			),
+			env.DiagnosticAtRegexp("foo/bar_test.go", "x"),
 		)
 	})
 }
@@ -1246,7 +1247,7 @@
 			env.DiagnosticAtRegexp("main.go", "x"),
 		)
 	})
-	withOptions(WithRootPath("a"), WithLimitWorkspaceScope()).run(t, mod, func(t *testing.T, env *Env) {
+	withOptions(WithRootPath("a"), LimitWorkspaceScope()).run(t, mod, func(t *testing.T, env *Env) {
 		env.OpenFile("a/main.go")
 		env.Await(
 			NoDiagnostics("main.go"),
@@ -1422,7 +1423,7 @@
 		env.Await(
 			OnceMet(
 				InitialWorkspaceLoad,
-				NoDiagnosticWithMessage("illegal character U+0023 '#'"),
+				NoDiagnosticWithMessage("", "illegal character U+0023 '#'"),
 			),
 		)
 	})
@@ -1452,3 +1453,65 @@
 		)
 	})
 }
+
+// TestProgressBarErrors confirms that critical workspace load errors are shown
+// and updated via progress reports.
+func TestProgressBarErrors(t *testing.T) {
+	testenv.NeedsGo1Point(t, 14)
+
+	const pkg = `
+-- go.mod --
+modul mod.com
+
+go 1.12
+-- main.go --
+package main
+`
+	run(t, pkg, func(t *testing.T, env *Env) {
+		env.OpenFile("go.mod")
+		env.Await(
+			OutstandingWork("Error loading workspace", "unknown directive"),
+		)
+		env.EditBuffer("go.mod", fake.NewEdit(0, 0, 3, 0, `module mod.com
+
+go 1.hello
+`))
+		env.Await(
+			OutstandingWork("Error loading workspace", "invalid go version"),
+		)
+		env.RegexpReplace("go.mod", "go 1.hello", "go 1.12")
+		env.Await(
+			NoOutstandingWork(),
+		)
+	})
+}
+
+func TestDeleteDirectory(t *testing.T) {
+	testenv.NeedsGo1Point(t, 14)
+
+	const mod = `
+-- bob/bob.go --
+package bob
+
+func Hello() {
+	var x int
+}
+-- go.mod --
+module mod.com
+-- main.go --
+package main
+
+import "mod.com/bob"
+
+func main() {
+	bob.Hello()
+}
+`
+	run(t, mod, func(t *testing.T, env *Env) {
+		env.RemoveWorkspaceFile("bob")
+		env.Await(
+			env.DiagnosticAtRegexp("main.go", `"mod.com/bob"`),
+			EmptyDiagnostics("bob/bob.go"),
+		)
+	})
+}
diff --git a/gopls/internal/regtest/env.go b/gopls/internal/regtest/env.go
index f1b958d..70859fd 100644
--- a/gopls/internal/regtest/env.go
+++ b/gopls/internal/regtest/env.go
@@ -58,8 +58,8 @@
 }
 
 type workProgress struct {
-	title   string
-	percent float64
+	title, msg string
+	percent    float64
 }
 
 func (s State) String() string {
@@ -200,10 +200,16 @@
 	switch kind := v["kind"]; kind {
 	case "begin":
 		work.title = v["title"].(string)
+		if msg, ok := v["message"]; ok {
+			work.msg = msg.(string)
+		}
 	case "report":
 		if pct, ok := v["percentage"]; ok {
 			work.percent = pct.(float64)
 		}
+		if msg, ok := v["message"]; ok {
+			work.msg = msg.(string)
+		}
 	case "end":
 		title := e.state.outstandingWork[m.Token].title
 		e.state.completedWork[title] = e.state.completedWork[title] + 1
diff --git a/gopls/internal/regtest/expectation.go b/gopls/internal/regtest/expectation.go
index 70601cc..f895e8c 100644
--- a/gopls/internal/regtest/expectation.go
+++ b/gopls/internal/regtest/expectation.go
@@ -10,8 +10,8 @@
 	"strings"
 
 	"golang.org/x/tools/internal/lsp"
+	"golang.org/x/tools/internal/lsp/fake"
 	"golang.org/x/tools/internal/lsp/protocol"
-	"golang.org/x/tools/internal/span"
 )
 
 // An Expectation asserts that the state of the editor at a point in time
@@ -202,6 +202,24 @@
 	}
 }
 
+// OutstandingWork expects a work item to be outstanding. The given title must
+// be an exact match, whereas the given msg must only be contained in the work
+// item's message.
+func OutstandingWork(title, msg string) SimpleExpectation {
+	check := func(s State) Verdict {
+		for _, work := range s.outstandingWork {
+			if work.title == title && strings.Contains(work.msg, msg) {
+				return Met
+			}
+		}
+		return Unmet
+	}
+	return SimpleExpectation{
+		check:       check,
+		description: fmt.Sprintf("outstanding work: %s", title),
+	}
+}
+
 // LogExpectation is an expectation on the log messages received by the editor
 // from gopls.
 type LogExpectation struct {
@@ -362,18 +380,47 @@
 // A DiagnosticExpectation is a condition that must be met by the current set
 // of diagnostics for a file.
 type DiagnosticExpectation struct {
-	// IsMet determines whether the diagnostics for this file version satisfy our
-	// expectation.
-	isMet func(*protocol.PublishDiagnosticsParams) bool
-	// Description is a human-readable description of the diagnostic expectation.
-	description string
-	// Path is the scratch workdir-relative path to the file being asserted on.
+	// optionally, the position of the diagnostic and the regex used to calculate it.
+	pos *fake.Pos
+	re  string
+
+	// optionally, the message that the diagnostic should contain.
+	message string
+
+	// whether the expectation is that the diagnostic is present, or absent.
+	present bool
+
+	// path is the scratch workdir-relative path to the file being asserted on.
 	path string
 }
 
 // Check implements the Expectation interface.
 func (e DiagnosticExpectation) Check(s State) Verdict {
-	if diags, ok := s.diagnostics[e.path]; ok && e.isMet(diags) {
+	diags, ok := s.diagnostics[e.path]
+	if !ok {
+		if !e.present {
+			return Met
+		}
+		return Unmet
+	}
+
+	found := false
+	for _, d := range diags.Diagnostics {
+		if e.pos != nil {
+			if d.Range.Start.Line != float64(e.pos.Line) || d.Range.Start.Character != float64(e.pos.Column) {
+				continue
+			}
+		}
+		if e.message != "" {
+			if !strings.Contains(d.Message, e.message) {
+				continue
+			}
+		}
+		found = true
+		break
+	}
+
+	if found == e.present {
 		return Met
 	}
 	return Unmet
@@ -381,7 +428,21 @@
 
 // Description implements the Expectation interface.
 func (e DiagnosticExpectation) Description() string {
-	return fmt.Sprintf("%s: %s", e.path, e.description)
+	desc := e.path + ":"
+	if !e.present {
+		desc += " no"
+	}
+	desc += " diagnostic"
+	if e.pos != nil {
+		desc += fmt.Sprintf(" at {line:%d, column:%d}", e.pos.Line, e.pos.Column)
+		if e.re != "" {
+			desc += fmt.Sprintf(" (location of %q)", e.re)
+		}
+	}
+	if e.message != "" {
+		desc += fmt.Sprintf(" with message %q", e.message)
+	}
+	return desc
 }
 
 // EmptyDiagnostics asserts that empty diagnostics are sent for the
@@ -419,15 +480,18 @@
 // AnyDiagnosticAtCurrentVersion asserts that there is a diagnostic report for
 // the current edited version of the buffer corresponding to the given
 // workdir-relative pathname.
-func (e *Env) AnyDiagnosticAtCurrentVersion(name string) DiagnosticExpectation {
+func (e *Env) AnyDiagnosticAtCurrentVersion(name string) Expectation {
 	version := e.Editor.BufferVersion(name)
-	isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
-		return int(diags.Version) == version
+	check := func(s State) Verdict {
+		diags, ok := s.diagnostics[name]
+		if ok && diags.Version == float64(version) {
+			return Met
+		}
+		return Unmet
 	}
-	return DiagnosticExpectation{
-		isMet:       isMet,
+	return SimpleExpectation{
+		check:       check,
 		description: fmt.Sprintf("any diagnostics at version %d", version),
-		path:        name,
 	}
 }
 
@@ -437,27 +501,13 @@
 func (e *Env) DiagnosticAtRegexp(name, re string) DiagnosticExpectation {
 	e.T.Helper()
 	pos := e.RegexpSearch(name, re)
-	expectation := DiagnosticAt(name, pos.Line, pos.Column)
-	expectation.description += fmt.Sprintf(" (location of %q)", re)
-	return expectation
+	return DiagnosticExpectation{path: name, pos: &pos, re: re, present: true}
 }
 
 // DiagnosticAt asserts that there is a diagnostic entry at the position
 // specified by line and col, for the workdir-relative path name.
 func DiagnosticAt(name string, line, col int) DiagnosticExpectation {
-	isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
-		for _, d := range diags.Diagnostics {
-			if d.Range.Start.Line == float64(line) && d.Range.Start.Character == float64(col) {
-				return true
-			}
-		}
-		return false
-	}
-	return DiagnosticExpectation{
-		isMet:       isMet,
-		description: fmt.Sprintf("diagnostic at {line:%d, column:%d}", line, col),
-		path:        name,
-	}
+	return DiagnosticExpectation{path: name, pos: &fake.Pos{Line: line, Column: col}, present: true}
 }
 
 // NoDiagnosticAtRegexp expects that there is no diagnostic entry at the start
@@ -468,9 +518,7 @@
 func (e *Env) NoDiagnosticAtRegexp(name, re string) DiagnosticExpectation {
 	e.T.Helper()
 	pos := e.RegexpSearch(name, re)
-	expectation := NoDiagnosticAt(name, pos.Line, pos.Column)
-	expectation.description += fmt.Sprintf(" (location of %q)", re)
-	return expectation
+	return DiagnosticExpectation{path: name, pos: &pos, re: re, present: false}
 }
 
 // NoDiagnosticAt asserts that there is no diagnostic entry at the position
@@ -478,19 +526,7 @@
 // This should only be used in combination with OnceMet for a given condition,
 // otherwise it may always succeed.
 func NoDiagnosticAt(name string, line, col int) DiagnosticExpectation {
-	isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
-		for _, d := range diags.Diagnostics {
-			if d.Range.Start.Line == float64(line) && d.Range.Start.Character == float64(col) {
-				return false
-			}
-		}
-		return true
-	}
-	return DiagnosticExpectation{
-		isMet:       isMet,
-		description: fmt.Sprintf("no diagnostic at {line:%d, column:%d}", line, col),
-		path:        name,
-	}
+	return DiagnosticExpectation{path: name, pos: &fake.Pos{Line: line, Column: col}, present: false}
 }
 
 // NoDiagnosticWithMessage asserts that there is no diagnostic entry with the
@@ -498,23 +534,6 @@
 //
 // This should only be used in combination with OnceMet for a given condition,
 // otherwise it may always succeed.
-func NoDiagnosticWithMessage(msg string) DiagnosticExpectation {
-	var uri span.URI
-	isMet := func(diags *protocol.PublishDiagnosticsParams) bool {
-		for _, d := range diags.Diagnostics {
-			if d.Message == msg {
-				return true
-			}
-		}
-		return false
-	}
-	var path string
-	if uri != "" {
-		path = uri.Filename()
-	}
-	return DiagnosticExpectation{
-		isMet:       isMet,
-		description: fmt.Sprintf("no diagnostic with message %s", msg),
-		path:        path,
-	}
+func NoDiagnosticWithMessage(name, msg string) DiagnosticExpectation {
+	return DiagnosticExpectation{path: name, message: msg, present: false}
 }
diff --git a/gopls/internal/regtest/formatting_test.go b/gopls/internal/regtest/formatting_test.go
index 3a9ffdb..80344c1 100644
--- a/gopls/internal/regtest/formatting_test.go
+++ b/gopls/internal/regtest/formatting_test.go
@@ -4,6 +4,7 @@
 	"strings"
 	"testing"
 
+	"golang.org/x/tools/internal/lsp"
 	"golang.org/x/tools/internal/lsp/tests"
 )
 
@@ -174,6 +175,7 @@
 `
 		crlf := strings.ReplaceAll(want, "\n", "\r\n")
 		env.CreateBuffer("main.go", crlf)
+		env.Await(CompletedWork(lsp.DiagnosticWorkTitle(lsp.FromDidOpen), 1))
 		env.SaveBuffer("main.go")
 		got := env.Editor.BufferText("main.go")
 		if want != got {
@@ -181,3 +183,43 @@
 		}
 	})
 }
+
+func TestCRLF_42646(t *testing.T) {
+	runner.Run(t, "-- main.go --", func(t *testing.T, env *Env) {
+		want := `package main
+
+import (
+	"fmt"
+)
+
+/*
+func upload(c echo.Context) error {
+	if err := r.ParseForm(); err != nil {
+		fmt.Fprintf(w, "ParseForm() err: %v", err)
+		return
+	}
+	fmt.Fprintf(w, "POST request successful")
+	path_ver := r.FormValue("path_ver")
+	ukclin_ver := r.FormValue("ukclin_ver")
+
+	fmt.Fprintf(w, "Name = %s\n", path_ver)
+	fmt.Fprintf(w, "Address = %s\n", ukclin_ver)
+}
+*/
+
+func main() {
+	const server_port = 8080
+	fmt.Printf("port: %d\n", server_port)
+}
+`
+		crlf := strings.ReplaceAll(want, "\n", "\r\n")
+		env.CreateBuffer("main.go", crlf)
+		env.Await(CompletedWork(lsp.DiagnosticWorkTitle(lsp.FromDidOpen), 1))
+		env.OrganizeImports("main.go")
+		got := env.Editor.BufferText("main.go")
+		got = strings.ReplaceAll(got, "\r\n", "\n") // convert everything to LF for simplicity
+		if want != got {
+			t.Errorf("unexpected content after save:\n%s", tests.Diff(want, got))
+		}
+	})
+}
diff --git a/gopls/internal/regtest/link_test.go b/gopls/internal/regtest/link_test.go
index cfdeeb7..e5757cf 100644
--- a/gopls/internal/regtest/link_test.go
+++ b/gopls/internal/regtest/link_test.go
@@ -43,8 +43,8 @@
 		env.OpenFile("main.go")
 		env.OpenFile("go.mod")
 
-		modLink := "https://pkg.go.dev/mod/import.test@v1.2.3"
-		pkgLink := "https://pkg.go.dev/import.test@v1.2.3/pkg"
+		modLink := "https://pkg.go.dev/mod/import.test@v1.2.3?utm_source=gopls"
+		pkgLink := "https://pkg.go.dev/import.test@v1.2.3/pkg?utm_source=gopls"
 
 		// First, check that we get the expected links via hover and documentLink.
 		content, _ := env.Hover("main.go", env.RegexpSearch("main.go", "pkg.Hello"))
diff --git a/gopls/internal/regtest/modfile_test.go b/gopls/internal/regtest/modfile_test.go
index 2f897a2..923ffda 100644
--- a/gopls/internal/regtest/modfile_test.go
+++ b/gopls/internal/regtest/modfile_test.go
@@ -33,6 +33,15 @@
 const Name = "Hello"
 `
 
+func runModfileTest(t *testing.T, files, proxy string, f TestFunc) {
+	t.Run("normal", func(t *testing.T) {
+		withOptions(WithProxyFiles(proxy)).run(t, files, f)
+	})
+	t.Run("nested", func(t *testing.T) {
+		withOptions(WithProxyFiles(proxy), NestWorkdir(), WithModes(Singleton|Experimental)).run(t, files, f)
+	})
+}
+
 func TestModFileModification(t *testing.T) {
 	testenv.NeedsGo1Point(t, 14)
 
@@ -50,7 +59,7 @@
 }
 `
 	t.Run("basic", func(t *testing.T) {
-		withOptions(WithProxyFiles(proxy)).run(t, untidyModule, func(t *testing.T, env *Env) {
+		runModfileTest(t, untidyModule, proxy, func(t *testing.T, env *Env) {
 			// Open the file and make sure that the initial workspace load does not
 			// modify the go.mod file.
 			goModContent := env.ReadWorkspaceFile("go.mod")
@@ -77,7 +86,7 @@
 	t.Run("delete main.go", func(t *testing.T) {
 		t.Skip("This test will be flaky until golang/go#40269 is resolved.")
 
-		withOptions(WithProxyFiles(proxy)).run(t, untidyModule, func(t *testing.T, env *Env) {
+		runModfileTest(t, untidyModule, proxy, func(t *testing.T, env *Env) {
 			goModContent := env.ReadWorkspaceFile("go.mod")
 			mainContent := env.ReadWorkspaceFile("main.go")
 			env.OpenFile("main.go")
@@ -126,7 +135,7 @@
 require random.org v1.2.3
 `
 
-	withOptions(WithProxyFiles(proxy)).run(t, mod, func(t *testing.T, env *Env) {
+	runModfileTest(t, mod, proxy, func(t *testing.T, env *Env) {
 		env.OpenFile("main.go")
 		var d protocol.PublishDiagnosticsParams
 		env.Await(
@@ -172,7 +181,7 @@
 
 require example.com v1.2.3
 `
-	runner.Run(t, mod, func(t *testing.T, env *Env) {
+	runModfileTest(t, mod, proxy, func(t *testing.T, env *Env) {
 		env.OpenFile("go.mod")
 		var d protocol.PublishDiagnosticsParams
 		env.Await(
@@ -185,7 +194,7 @@
 		if got := env.Editor.BufferText("go.mod"); got != want {
 			t.Fatalf("unexpected go.mod content:\n%s", tests.Diff(want, got))
 		}
-	}, WithProxyFiles(proxy))
+	})
 }
 
 func TestUnusedDiag(t *testing.T) {
@@ -212,7 +221,7 @@
 go 1.14
 `
 
-	withOptions(WithProxyFiles(proxy)).run(t, files, func(t *testing.T, env *Env) {
+	runModfileTest(t, files, proxy, func(t *testing.T, env *Env) {
 		env.OpenFile("go.mod")
 		var d protocol.PublishDiagnosticsParams
 		env.Await(
@@ -266,7 +275,7 @@
 func _() {
     caire.RemoveTempImage()
 }`
-	runner.Run(t, repro, func(t *testing.T, env *Env) {
+	runModfileTest(t, repro, proxy, func(t *testing.T, env *Env) {
 		env.OpenFile("main.go")
 		var d protocol.PublishDiagnosticsParams
 		env.Await(
@@ -288,7 +297,7 @@
 		if got := env.ReadWorkspaceFile("go.mod"); got != want {
 			t.Fatalf("TestNewDepWithUnusedDep failed:\n%s", tests.Diff(want, got))
 		}
-	}, WithProxyFiles(proxy))
+	})
 }
 
 // TODO: For this test to be effective, the sandbox's file watcher must respect
@@ -310,13 +319,13 @@
 func main() {
 	fmt.Println(blah.Name)
 `
-	runner.Run(t, mod, func(t *testing.T, env *Env) {
+	runModfileTest(t, mod, proxy, func(t *testing.T, env *Env) {
 		env.Await(env.DiagnosticAtRegexp("go.mod", "require"))
 		env.RunGoCommand("mod", "tidy")
 		env.Await(
 			EmptyDiagnostics("go.mod"),
 		)
-	}, WithProxyFiles(proxy))
+	})
 }
 
 // Tests golang/go#39784: a missing indirect dependency, necessary
@@ -409,7 +418,7 @@
 
 	// Start from a bad state/bad IWL, and confirm that we recover.
 	t.Run("bad", func(t *testing.T) {
-		runner.Run(t, unknown, func(t *testing.T, env *Env) {
+		runModfileTest(t, unknown, proxy, func(t *testing.T, env *Env) {
 			env.OpenFile("go.mod")
 			env.Await(
 				env.DiagnosticAtRegexp("go.mod", "example.com v1.2.2"),
@@ -419,7 +428,7 @@
 			env.Await(
 				env.DiagnosticAtRegexp("main.go", "x = "),
 			)
-		}, WithProxyFiles(proxy))
+		})
 	})
 
 	const known = `
@@ -441,7 +450,7 @@
 	// Start from a good state, transform to a bad state, and confirm that we
 	// still recover.
 	t.Run("good", func(t *testing.T) {
-		runner.Run(t, known, func(t *testing.T, env *Env) {
+		runModfileTest(t, known, proxy, func(t *testing.T, env *Env) {
 			env.OpenFile("go.mod")
 			env.Await(
 				env.DiagnosticAtRegexp("main.go", "x = "),
@@ -456,7 +465,7 @@
 			env.Await(
 				env.DiagnosticAtRegexp("main.go", "x = "),
 			)
-		}, WithProxyFiles(proxy))
+		})
 	})
 }
 
@@ -501,7 +510,7 @@
 	println(blah.Name)
 }
 `
-	withOptions(WithProxyFiles(badProxy)).run(t, module, func(t *testing.T, env *Env) {
+	runModfileTest(t, module, badProxy, func(t *testing.T, env *Env) {
 		env.OpenFile("go.mod")
 		env.Await(
 			env.DiagnosticAtRegexp("go.mod", "require example.com v1.2.3"),
@@ -621,3 +630,23 @@
 		)
 	})
 }
+
+func TestModTypoDiagnostic(t *testing.T) {
+	const mod = `
+-- go.mod --
+module mod.com
+
+go 1.12
+-- main.go --
+package main
+
+func main() {}
+`
+	run(t, mod, func(t *testing.T, env *Env) {
+		env.OpenFile("go.mod")
+		env.RegexpReplace("go.mod", "module", "modul")
+		env.Await(
+			env.DiagnosticAtRegexp("go.mod", "modul"),
+		)
+	})
+}
diff --git a/gopls/internal/regtest/runner.go b/gopls/internal/regtest/runner.go
index 8c5efe0..6ec6ed1 100644
--- a/gopls/internal/regtest/runner.go
+++ b/gopls/internal/regtest/runner.go
@@ -39,7 +39,6 @@
 	// and communicates over pipes to mimic the gopls sidecar execution mode,
 	// which communicates over stdin/stderr.
 	Singleton Mode = 1 << iota
-
 	// Forwarded forwards connections to a shared in-process gopls instance.
 	Forwarded
 	// SeparateProcess forwards connection to a shared separate gopls process.
@@ -77,13 +76,14 @@
 }
 
 type runConfig struct {
-	editor    fake.EditorConfig
-	sandbox   fake.SandboxConfig
-	modes     Mode
-	timeout   time.Duration
-	debugAddr string
-	skipLogs  bool
-	skipHooks bool
+	editor      fake.EditorConfig
+	sandbox     fake.SandboxConfig
+	modes       Mode
+	timeout     time.Duration
+	debugAddr   string
+	skipLogs    bool
+	skipHooks   bool
+	nestWorkdir bool
 }
 
 func (r *Runner) defaultConfig() *runConfig {
@@ -153,7 +153,7 @@
 // tests need to check other cases.
 func WithRootPath(path string) RunOption {
 	return optionSetter(func(opts *runConfig) {
-		opts.editor.EditorRootPath = path
+		opts.editor.WorkspaceRoot = path
 	})
 }
 
@@ -209,13 +209,21 @@
 	})
 }
 
-// WithLimitWorkspaceScope sets the LimitWorkspaceScope configuration.
-func WithLimitWorkspaceScope() RunOption {
+// LimitWorkspaceScope sets the LimitWorkspaceScope configuration.
+func LimitWorkspaceScope() RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.editor.LimitWorkspaceScope = true
 	})
 }
 
+// NestWorkdir inserts the sandbox working directory in a subdirectory of the
+// editor workspace.
+func NestWorkdir() RunOption {
+	return optionSetter(func(opts *runConfig) {
+		opts.nestWorkdir = true
+	})
+}
+
 type TestFunc func(t *testing.T, env *Env)
 
 // Run executes the test function in the default configured gopls execution
@@ -262,16 +270,25 @@
 				di.MonitorMemory(ctx)
 			}
 
-			tempDir := filepath.Join(r.TempDir, filepath.FromSlash(t.Name()))
-			if err := os.MkdirAll(tempDir, 0755); err != nil {
+			rootDir := filepath.Join(r.TempDir, filepath.FromSlash(t.Name()))
+			if err := os.MkdirAll(rootDir, 0755); err != nil {
 				t.Fatal(err)
 			}
+			if config.nestWorkdir {
+				config.sandbox.Workdir = "work/nested"
+			}
 			config.sandbox.Files = files
-			config.sandbox.RootDir = tempDir
+			config.sandbox.RootDir = rootDir
 			sandbox, err := fake.NewSandbox(&config.sandbox)
 			if err != nil {
 				t.Fatal(err)
 			}
+			workdir := sandbox.Workdir.RootURI().SpanURI().Filename()
+			if config.nestWorkdir {
+				// Now that we know the actual workdir, set our workspace to be the
+				// parent directory.
+				config.editor.WorkspaceRoot = filepath.Clean(filepath.Join(workdir, ".."))
+			}
 			// Deferring the closure of ws until the end of the entire test suite
 			// has, in testing, given the LSP server time to properly shutdown and
 			// release any file locks held in workspace, which is a problem on
@@ -304,8 +321,8 @@
 }
 
 type loggingFramer struct {
-	mu      sync.Mutex
-	buffers []*safeBuffer
+	mu  sync.Mutex
+	buf *safeBuffer
 }
 
 // safeBuffer is a threadsafe buffer for logs.
@@ -323,11 +340,17 @@
 func (s *loggingFramer) framer(f jsonrpc2.Framer) jsonrpc2.Framer {
 	return func(nc net.Conn) jsonrpc2.Stream {
 		s.mu.Lock()
-		buf := &safeBuffer{buf: bytes.Buffer{}}
-		s.buffers = append(s.buffers, buf)
+		framed := false
+		if s.buf == nil {
+			s.buf = &safeBuffer{buf: bytes.Buffer{}}
+			framed = true
+		}
 		s.mu.Unlock()
 		stream := f(nc)
-		return protocol.LoggingStream(stream, buf)
+		if framed {
+			return protocol.LoggingStream(stream, s.buf)
+		}
+		return stream
 	}
 }
 
@@ -335,13 +358,14 @@
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	for i, buf := range s.buffers {
-		fmt.Fprintf(os.Stderr, "#### Start Gopls Test Logs %d of %d for %q\n", i+1, len(s.buffers), testname)
-		buf.mu.Lock()
-		io.Copy(w, &buf.buf)
-		buf.mu.Unlock()
-		fmt.Fprintf(os.Stderr, "#### End Gopls Test Logs %d of %d for %q\n", i+1, len(s.buffers), testname)
+	if s.buf == nil {
+		return
 	}
+	fmt.Fprintf(os.Stderr, "#### Start Gopls Test Logs for %q\n", testname)
+	s.buf.mu.Lock()
+	io.Copy(w, &s.buf.buf)
+	s.buf.mu.Unlock()
+	fmt.Fprintf(os.Stderr, "#### End Gopls Test Logs for %q\n", testname)
 }
 
 func singletonServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer {
diff --git a/gopls/internal/regtest/watch_test.go b/gopls/internal/regtest/watch_test.go
index 3b5b69d..46ed48a 100644
--- a/gopls/internal/regtest/watch_test.go
+++ b/gopls/internal/regtest/watch_test.go
@@ -45,11 +45,16 @@
 	t.Run("opened", func(t *testing.T) {
 		runner.Run(t, pkg, func(t *testing.T, env *Env) {
 			env.OpenFile("a/a.go")
+			// Insert a trivial edit so that we don't automatically update the buffer
+			// (see CL 267577).
+			env.EditBuffer("a/a.go", fake.NewEdit(0, 0, 0, 0, " "))
 			env.Await(CompletedWork(lsp.DiagnosticWorkTitle(lsp.FromDidOpen), 1))
 			env.WriteWorkspaceFile("a/a.go", `package a; func _() {};`)
 			env.Await(
-				env.DiagnosticAtRegexp("a/a.go", "x"),
-			)
+				OnceMet(
+					CompletedWork(lsp.DiagnosticWorkTitle(lsp.FromDidChangeWatchedFiles), 1),
+					env.DiagnosticAtRegexp("a/a.go", "x"),
+				))
 		})
 	})
 }
@@ -375,7 +380,9 @@
 package a
 `
 	t.Run("close then delete", func(t *testing.T) {
-		runner.Run(t, pkg, func(t *testing.T, env *Env) {
+		withOptions(EditorConfig{
+			VerboseOutput: true,
+		}).run(t, pkg, func(t *testing.T, env *Env) {
 			env.OpenFile("a/a.go")
 			env.OpenFile("a/a_unneeded.go")
 			env.Await(
@@ -407,7 +414,9 @@
 	})
 
 	t.Run("delete then close", func(t *testing.T) {
-		runner.Run(t, pkg, func(t *testing.T, env *Env) {
+		withOptions(EditorConfig{
+			VerboseOutput: true,
+		}).run(t, pkg, func(t *testing.T, env *Env) {
 			env.OpenFile("a/a.go")
 			env.OpenFile("a/a_unneeded.go")
 			env.Await(
diff --git a/internal/gocommand/invoke.go b/internal/gocommand/invoke.go
index 8ba2253..f65aad4 100644
--- a/internal/gocommand/invoke.go
+++ b/internal/gocommand/invoke.go
@@ -13,6 +13,7 @@
 	"os"
 	"os/exec"
 	"regexp"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -133,6 +134,9 @@
 	ModFlag    string
 	ModFile    string
 	Overlay    string
+	// If CleanEnv is set, the invocation will run only with the environment
+	// in Env, not starting with os.Environ.
+	CleanEnv   bool
 	Env        []string
 	WorkingDir string
 	Logf       func(format string, args ...interface{})
@@ -207,7 +211,10 @@
 	// The Go stdlib has a special feature where if the cwd and the PWD are the
 	// same node then it trusts the PWD, so by setting it in the env for the child
 	// process we fix up all the paths returned by the go command.
-	cmd.Env = append(os.Environ(), i.Env...)
+	if !i.CleanEnv {
+		cmd.Env = os.Environ()
+	}
+	cmd.Env = append(cmd.Env, i.Env...)
 	if i.WorkingDir != "" {
 		cmd.Env = append(cmd.Env, "PWD="+i.WorkingDir)
 		cmd.Dir = i.WorkingDir
@@ -248,10 +255,19 @@
 func cmdDebugStr(cmd *exec.Cmd) string {
 	env := make(map[string]string)
 	for _, kv := range cmd.Env {
-		split := strings.Split(kv, "=")
+		split := strings.SplitN(kv, "=", 2)
 		k, v := split[0], split[1]
 		env[k] = v
 	}
 
-	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v go %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], cmd.Args)
+	var args []string
+	for _, arg := range cmd.Args {
+		quoted := strconv.Quote(arg)
+		if quoted[1:len(quoted)-1] != arg || strings.Contains(arg, " ") {
+			args = append(args, quoted)
+		} else {
+			args = append(args, arg)
+		}
+	}
+	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
 }
diff --git a/internal/lsp/cache/cache.go b/internal/lsp/cache/cache.go
index 5e6180d..6d40ecb 100644
--- a/internal/lsp/cache/cache.go
+++ b/internal/lsp/cache/cache.go
@@ -59,6 +59,10 @@
 	err     error
 }
 
+func (h *fileHandle) Saved() bool {
+	return true
+}
+
 func (c *Cache) GetFile(ctx context.Context, uri span.URI) (source.FileHandle, error) {
 	return c.getFile(ctx, uri)
 }
diff --git a/internal/lsp/cache/imports.go b/internal/lsp/cache/imports.go
index 48216ab..524d581 100644
--- a/internal/lsp/cache/imports.go
+++ b/internal/lsp/cache/imports.go
@@ -4,69 +4,65 @@
 	"context"
 	"fmt"
 	"reflect"
+	"strings"
 	"sync"
 	"time"
 
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/event/keys"
+	"golang.org/x/tools/internal/gocommand"
 	"golang.org/x/tools/internal/imports"
 	"golang.org/x/tools/internal/lsp/source"
-	"golang.org/x/tools/internal/span"
 )
 
 type importsState struct {
 	ctx context.Context
 
-	mu                      sync.Mutex
-	processEnv              *imports.ProcessEnv
-	cleanupProcessEnv       func()
-	cacheRefreshDuration    time.Duration
-	cacheRefreshTimer       *time.Timer
-	cachedModFileIdentifier string
-	cachedBuildFlags        []string
+	mu                   sync.Mutex
+	processEnv           *imports.ProcessEnv
+	cleanupProcessEnv    func()
+	cacheRefreshDuration time.Duration
+	cacheRefreshTimer    *time.Timer
+	cachedModFileHash    string
+	cachedBuildFlags     []string
 }
 
 func (s *importsState) runProcessEnvFunc(ctx context.Context, snapshot *snapshot, fn func(*imports.Options) error) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	// Use temporary go.mod files, but always go to disk for the contents.
-	// Rebuilding the cache is expensive, and we don't want to do it for
-	// transient changes.
-	var modFH source.FileHandle
-	var gosum []byte
-	var modFileIdentifier string
-	var err error
-	// TODO(rfindley): Change the goimports logic to use a persistent workspace
-	// module for workspace module mode.
-	//
-	// Get the go.mod file that corresponds to this view's root URI. This is
-	// broken because it assumes that the view's root is a module, but this is
-	// not more broken than the previous state--it is a temporary hack that
-	// should be removed ASAP.
-	var matchURI span.URI
-	for modURI := range snapshot.workspace.activeModFiles() {
-		if dirURI(modURI) == snapshot.view.rootURI {
-			matchURI = modURI
+	// Find the hash of the active mod file, if any. Using the unsaved content
+	// is slightly wasteful, since we'll drop caches a little too often, but
+	// the mod file shouldn't be changing while people are autocompleting.
+	var modFileHash string
+	if snapshot.workspaceMode()&usesWorkspaceModule == 0 {
+		for m := range snapshot.workspace.activeModFiles() { // range to access the only element
+			modFH, err := snapshot.GetFile(ctx, m)
+			if err != nil {
+				return err
+			}
+			modFileHash = modFH.FileIdentity().Hash
 		}
-	}
-	// TODO(rFindley): should it be an error if matchURI is empty?
-	if matchURI != "" {
-		modFH, err = snapshot.GetFile(ctx, matchURI)
+	} else {
+		modFile, err := snapshot.workspace.modFile(ctx, snapshot)
 		if err != nil {
 			return err
 		}
-		modFileIdentifier = modFH.FileIdentity().Hash
-		gosum = snapshot.goSum(ctx, matchURI)
+		modBytes, err := modFile.Format()
+		if err != nil {
+			return err
+		}
+		modFileHash = hashContents(modBytes)
 	}
-	// v.goEnv is immutable -- changes make a new view. Options can change.
+
+	// view.goEnv is immutable -- changes make a new view. Options can change.
 	// We can't compare build flags directly because we may add -modfile.
 	snapshot.view.optionsMu.Lock()
 	localPrefix := snapshot.view.options.Local
 	currentBuildFlags := snapshot.view.options.BuildFlags
 	changed := !reflect.DeepEqual(currentBuildFlags, s.cachedBuildFlags) ||
 		snapshot.view.options.VerboseOutput != (s.processEnv.Logf != nil) ||
-		modFileIdentifier != s.cachedModFileIdentifier
+		modFileHash != s.cachedModFileHash
 	snapshot.view.optionsMu.Unlock()
 
 	// If anything relevant to imports has changed, clear caches and
@@ -82,9 +78,10 @@
 			}
 			s.cleanupProcessEnv()
 		}
-		s.cachedModFileIdentifier = modFileIdentifier
+		s.cachedModFileHash = modFileHash
 		s.cachedBuildFlags = currentBuildFlags
-		s.cleanupProcessEnv, err = s.populateProcessEnv(ctx, snapshot, modFH, gosum)
+		var err error
+		s.cleanupProcessEnv, err = s.populateProcessEnv(ctx, snapshot)
 		if err != nil {
 			return err
 		}
@@ -122,55 +119,44 @@
 
 // populateProcessEnv sets the dynamically configurable fields for the view's
 // process environment. Assumes that the caller is holding the s.view.importsMu.
-func (s *importsState) populateProcessEnv(ctx context.Context, snapshot *snapshot, modFH source.FileHandle, gosum []byte) (cleanup func(), err error) {
-	cleanup = func() {}
+func (s *importsState) populateProcessEnv(ctx context.Context, snapshot *snapshot) (cleanup func(), err error) {
 	pe := s.processEnv
 
-	snapshot.view.optionsMu.Lock()
-	pe.BuildFlags = append([]string(nil), snapshot.view.options.BuildFlags...)
-	if snapshot.view.options.VerboseOutput {
+	if snapshot.view.Options().VerboseOutput {
 		pe.Logf = func(format string, args ...interface{}) {
 			event.Log(ctx, fmt.Sprintf(format, args...))
 		}
 	} else {
 		pe.Logf = nil
 	}
-	snapshot.view.optionsMu.Unlock()
 
-	pe.Env = map[string]string{}
-	for k, v := range snapshot.view.goEnv {
-		pe.Env[k] = v
-	}
-	pe.Env["GO111MODULE"] = snapshot.view.go111module
-
-	var modURI span.URI
-	var modContent []byte
-	if modFH != nil {
-		modURI = modFH.URI()
-		modContent, err = modFH.Read()
-		if err != nil {
-			return nil, err
-		}
-	}
-	modmod, err := snapshot.needsModEqualsMod(ctx, modURI, modContent)
+	// Take an extra reference to the snapshot so that its workspace directory
+	// (if any) isn't destroyed while we're using it.
+	release := snapshot.generation.Acquire(ctx)
+	_, inv, cleanupInvocation, err := snapshot.goCommandInvocation(ctx, source.LoadWorkspace, &gocommand.Invocation{
+		WorkingDir: snapshot.view.rootURI.Filename(),
+	})
 	if err != nil {
-		return cleanup, err
+		return nil, err
 	}
-	if modmod {
-		pe.ModFlag = "mod"
-	}
-
-	// Add -modfile to the build flags, if we are using it.
-	if snapshot.workspaceMode()&tempModfile != 0 && modFH != nil {
-		var tmpURI span.URI
-		tmpURI, cleanup, err = tempModFile(modFH, gosum)
-		if err != nil {
-			return nil, err
+	pe.WorkingDir = inv.WorkingDir
+	pe.BuildFlags = inv.BuildFlags
+	pe.WorkingDir = inv.WorkingDir
+	pe.ModFile = inv.ModFile
+	pe.ModFlag = inv.ModFlag
+	pe.Env = map[string]string{}
+	for _, kv := range inv.Env {
+		split := strings.SplitN(kv, "=", 2)
+		if len(split) != 2 {
+			continue
 		}
-		pe.ModFile = tmpURI.Filename()
+		pe.Env[split[0]] = split[1]
 	}
 
-	return cleanup, nil
+	return func() {
+		cleanupInvocation()
+		release()
+	}, nil
 }
 
 func (s *importsState) refreshProcessEnv() {
@@ -194,3 +180,11 @@
 	s.cacheRefreshTimer = nil
 	s.mu.Unlock()
 }
+
+func (s *importsState) destroy() {
+	s.mu.Lock()
+	if s.cleanupProcessEnv != nil {
+		s.cleanupProcessEnv()
+	}
+	s.mu.Unlock()
+}
diff --git a/internal/lsp/cache/load.go b/internal/lsp/cache/load.go
index 9eed1c4..ec40b22 100644
--- a/internal/lsp/cache/load.go
+++ b/internal/lsp/cache/load.go
@@ -81,7 +81,7 @@
 			panic(fmt.Sprintf("unknown scope type %T", scope))
 		}
 		switch scope.(type) {
-		case viewLoadScope:
+		case viewLoadScope, moduleLoadScope:
 			containsDir = true
 		}
 	}
@@ -93,7 +93,7 @@
 	ctx, done := event.Start(ctx, "cache.view.load", tag.Query.Of(query))
 	defer done()
 
-	_, inv, cleanup, err := s.goCommandInvocation(ctx, source.ForTypeChecking, &gocommand.Invocation{
+	_, inv, cleanup, err := s.goCommandInvocation(ctx, source.LoadWorkspace, &gocommand.Invocation{
 		WorkingDir: s.view.rootURI.Filename(),
 	})
 	if err != nil {
diff --git a/internal/lsp/cache/mod.go b/internal/lsp/cache/mod.go
index 95a9132..ef01864 100644
--- a/internal/lsp/cache/mod.go
+++ b/internal/lsp/cache/mod.go
@@ -69,25 +69,24 @@
 			Converter: span.NewContentConverter(modFH.URI().Filename(), contents),
 			Content:   contents,
 		}
-		data := &parseModData{
+		file, err := modfile.Parse(modFH.URI().Filename(), contents, nil)
+
+		// Attempt to convert the error to a standardized parse error.
+		var parseErrors []source.Error
+		if err != nil {
+			if parseErr, extractErr := extractModParseErrors(modFH.URI(), m, err, contents); extractErr == nil {
+				parseErrors = []source.Error{*parseErr}
+			}
+		}
+		return &parseModData{
 			parsed: &source.ParsedModule{
-				Mapper: m,
+				URI:         modFH.URI(),
+				Mapper:      m,
+				File:        file,
+				ParseErrors: parseErrors,
 			},
+			err: err,
 		}
-		data.parsed.File, data.err = modfile.Parse(modFH.URI().Filename(), contents, nil)
-		if data.err != nil {
-			// Attempt to convert the error to a standardized parse error.
-			if parseErr, extractErr := extractModParseErrors(modFH.URI(), m, data.err, contents); extractErr == nil {
-				data.parsed.ParseErrors = []source.Error{*parseErr}
-			}
-			// If the file was still parsed, we don't want to treat this as a
-			// fatal error. Note: This currently cannot happen as modfile.Parse
-			// always returns an error when the file is nil.
-			if data.parsed.File != nil {
-				data.err = nil
-			}
-		}
-		return data
 	}, nil)
 
 	pmh := &parseModHandle{handle: h}
@@ -143,7 +142,7 @@
 	// The error returned from the modfile package only returns a line number,
 	// so we assume that the diagnostic should be for the entire line.
 	endOfLine := len(lines[line-1])
-	sOffset, err := m.Converter.ToOffset(line, 0)
+	sOffset, err := m.Converter.ToOffset(line, 1)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/lsp/cache/mod_tidy.go b/internal/lsp/cache/mod_tidy.go
index 76479ee..4d94090 100644
--- a/internal/lsp/cache/mod_tidy.go
+++ b/internal/lsp/cache/mod_tidy.go
@@ -53,13 +53,17 @@
 	return data.tidied, data.err
 }
 
-func (s *snapshot) ModTidy(ctx context.Context, fh source.FileHandle) (*source.TidiedModule, error) {
-	if fh.Kind() != source.Mod {
-		return nil, fmt.Errorf("%s is not a go.mod file", fh.URI())
+func (s *snapshot) ModTidy(ctx context.Context, pm *source.ParsedModule) (*source.TidiedModule, error) {
+	if pm.File == nil {
+		return nil, fmt.Errorf("cannot tidy unparseable go.mod file: %v", pm.URI)
 	}
-	if handle := s.getModTidyHandle(fh.URI()); handle != nil {
+	if handle := s.getModTidyHandle(pm.URI); handle != nil {
 		return handle.tidy(ctx, s)
 	}
+	fh, err := s.GetFile(ctx, pm.URI)
+	if err != nil {
+		return nil, err
+	}
 	// If the file handle is an overlay, it may not be written to disk.
 	// The go.mod file has to be on disk for `go mod tidy` to work.
 	if _, ok := fh.(*overlay); ok {
@@ -96,23 +100,6 @@
 		defer done()
 
 		snapshot := arg.(*snapshot)
-		pm, err := snapshot.ParseMod(ctx, fh)
-		if err != nil || len(pm.ParseErrors) > 0 {
-			if err == nil {
-				err = fmt.Errorf("could not parse module to tidy: %v", pm.ParseErrors)
-			}
-			var errors []source.Error
-			if pm != nil {
-				errors = pm.ParseErrors
-			}
-			return &modTidyData{
-				tidied: &source.TidiedModule{
-					Parsed: pm,
-					Errors: errors,
-				},
-				err: err,
-			}
-		}
 		inv := &gocommand.Invocation{
 			Verb:       "mod",
 			Args:       []string{"tidy"},
@@ -149,7 +136,6 @@
 		return &modTidyData{
 			tidied: &source.TidiedModule{
 				Errors:        errors,
-				Parsed:        pm,
 				TidiedContent: tempContents,
 			},
 		}
@@ -187,7 +173,6 @@
 			return nil, false
 		}
 		return &source.TidiedModule{
-			Parsed: pmf,
 			Errors: []source.Error{{
 				URI:   fh.URI(),
 				Range: rng,
diff --git a/internal/lsp/cache/session.go b/internal/lsp/cache/session.go
index 36bfc50..4e22543 100644
--- a/internal/lsp/cache/session.go
+++ b/internal/lsp/cache/session.go
@@ -106,6 +106,10 @@
 	}
 }
 
+func (c *closedFile) Saved() bool {
+	return true
+}
+
 func (c *closedFile) Session() string {
 	return ""
 }
@@ -169,9 +173,16 @@
 	if err != nil {
 		return nil, nil, func() {}, err
 	}
+	root := folder
+	if options.ExpandWorkspaceToModule {
+		root, err = findWorkspaceRoot(ctx, root, s, options.ExperimentalWorkspaceModule)
+		if err != nil {
+			return nil, nil, func() {}, err
+		}
+	}
 
 	// Build the gopls workspace, collecting active modules in the view.
-	workspace, err := newWorkspace(ctx, ws.rootURI, s, options.ExperimentalWorkspaceModule)
+	workspace, err := newWorkspace(ctx, root, s, options.ExperimentalWorkspaceModule)
 	if err != nil {
 		return nil, nil, func() {}, err
 	}
@@ -194,6 +205,7 @@
 		folder:               folder,
 		filesByURI:           make(map[span.URI]*fileBase),
 		filesByBase:          make(map[string][]*fileBase),
+		rootURI:              root,
 		workspaceInformation: *ws,
 		tempWorkspace:        tempWorkspace,
 	}
@@ -201,8 +213,6 @@
 		ctx: backgroundCtx,
 		processEnv: &imports.ProcessEnv{
 			GocmdRunner: s.gocmdRunner,
-			WorkingDir:  folder.Filename(),
-			Env:         ws.goEnv,
 		},
 	}
 	v.snapshot = &snapshot{
@@ -416,6 +426,10 @@
 	// have truly been deleted.
 	deletions := map[span.URI]struct{}{}
 
+	// If the set of changes included directories, expand those directories
+	// to their files.
+	changes = s.expandChangesToDirectories(ctx, changes)
+
 	overlays, err := s.updateOverlays(ctx, changes)
 	if err != nil {
 		return nil, nil, nil, nil, err
@@ -475,6 +489,8 @@
 					exists:     err == nil,
 					fileHandle: fh,
 				}
+				// If there was an error reading the file, assume it has been
+				// deleted.
 				if err != nil {
 					deletions[c.URI] = struct{}{}
 				}
@@ -496,6 +512,68 @@
 	return bestViews, snapshots, releases, deletionsSlice, nil
 }
 
+// expandChangesToDirectories returns the set of changes with the directory
+// changes removed and expanded to include all of the files in the directory.
+func (s *Session) expandChangesToDirectories(ctx context.Context, changes []source.FileModification) []source.FileModification {
+	var snapshots []*snapshot
+	for _, v := range s.views {
+		snapshot, release := v.getSnapshot(ctx)
+		defer release()
+		snapshots = append(snapshots, snapshot)
+	}
+	knownDirs := knownDirectories(ctx, snapshots)
+	var result []source.FileModification
+	for _, c := range changes {
+		if _, ok := knownDirs[c.URI]; !ok {
+			result = append(result, c)
+			continue
+		}
+		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
+}
+
+// knownDirectories returns all of the directories known to the given
+// snapshots, including workspace directories and their subdirectories.
+func knownDirectories(ctx context.Context, snapshots []*snapshot) map[span.URI]struct{} {
+	result := map[span.URI]struct{}{}
+	for _, snapshot := range snapshots {
+		dirs := snapshot.workspace.dirs(ctx, snapshot)
+		for _, dir := range dirs {
+			result[dir] = struct{}{}
+		}
+		subdirs := snapshot.allKnownSubdirs(ctx)
+		for dir := range subdirs {
+			result[dir] = struct{}{}
+		}
+	}
+	return result
+}
+
+// knownFilesInDir returns the files known to the snapshots in the session.
+// It does not respect symlinks.
+func knownFilesInDir(ctx context.Context, snapshots []*snapshot, dir span.URI) map[span.URI]struct{} {
+	files := map[span.URI]struct{}{}
+
+	for _, snapshot := range snapshots {
+		for _, uri := range snapshot.knownFilesInDir(ctx, dir) {
+			files[uri] = struct{}{}
+		}
+	}
+	return files
+}
+
 func (s *Session) updateOverlays(ctx context.Context, changes []source.FileModification) (map[span.URI]*overlay, error) {
 	s.overlayMu.Lock()
 	defer s.overlayMu.Unlock()
diff --git a/internal/lsp/cache/snapshot.go b/internal/lsp/cache/snapshot.go
index 045415f..0faaacd 100644
--- a/internal/lsp/cache/snapshot.go
+++ b/internal/lsp/cache/snapshot.go
@@ -190,10 +190,14 @@
 	verboseOutput := s.view.options.VerboseOutput
 	s.view.optionsMu.Unlock()
 
+	// Forcibly disable GOPACKAGESDRIVER. It's incompatible with the
+	// packagesinternal APIs we use, and we really only support the go commmand
+	// anyway.
+	env := append(append([]string{}, inv.Env...), "GOPACKAGESDRIVER=off")
 	cfg := &packages.Config{
 		Context:    ctx,
 		Dir:        inv.WorkingDir,
-		Env:        inv.Env,
+		Env:        env,
 		BuildFlags: inv.BuildFlags,
 		Mode: packages.NeedName |
 			packages.NeedFiles |
@@ -256,7 +260,7 @@
 		// If we're type checking, we need to use the workspace context, meaning
 		// the main (workspace) module. Otherwise, we should use the module for
 		// the passed-in working dir.
-		if mode == source.ForTypeChecking {
+		if mode == source.LoadWorkspace {
 			if s.workspaceMode()&usesWorkspaceModule == 0 {
 				for m := range s.workspace.activeModFiles() { // range to access the only element
 					modURI = m
@@ -604,6 +608,62 @@
 	return s.workspace.dirs(ctx, s)
 }
 
+// allKnownSubdirs returns all of the subdirectories within the snapshot's
+// workspace directories. None of the workspace directories are included.
+func (s *snapshot) allKnownSubdirs(ctx context.Context) map[span.URI]struct{} {
+	// Don't return results until the snapshot is loaded, otherwise it may not
+	// yet "know" its files.
+	if err := s.awaitLoaded(ctx); err != nil {
+		return nil
+	}
+
+	dirs := s.workspace.dirs(ctx, s)
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	seen := make(map[span.URI]struct{})
+	for uri := range s.files {
+		dir := filepath.Dir(uri.Filename())
+		var matched span.URI
+		for _, wsDir := range dirs {
+			// Note: InDir handles symlinks, but InDirLex does not--it's too
+			// expensive to call InDir on every file in the snapshot.
+			if source.InDirLex(wsDir.Filename(), dir) {
+				matched = wsDir
+				break
+			}
+		}
+		// Don't watch any directory outside of the workspace directories.
+		if matched == "" {
+			continue
+		}
+		for {
+			if dir == "" || dir == matched.Filename() {
+				break
+			}
+			uri := span.URIFromPath(dir)
+			if _, ok := seen[uri]; ok {
+				break
+			}
+			seen[uri] = struct{}{}
+			dir = filepath.Dir(dir)
+		}
+	}
+	return seen
+}
+
+// knownFilesInDir returns the files known to the given snapshot that are in
+// the given directory. It does not respect symlinks.
+func (s *snapshot) knownFilesInDir(ctx context.Context, dir span.URI) []span.URI {
+	var files []span.URI
+	for uri := range s.files {
+		if source.InDirLex(dir.Filename(), uri.Filename()) {
+			files = append(files, uri)
+		}
+	}
+	return files
+}
+
 func (s *snapshot) WorkspacePackages(ctx context.Context) ([]source.Package, error) {
 	if err := s.awaitLoaded(ctx); err != nil {
 		return nil, err
@@ -1102,6 +1162,7 @@
 		}
 	}
 
+	changedPkgNames := map[packageID][]span.URI{}
 	for uri, change := range changes {
 		// Maybe reinitialize the view if we see a change in the vendor
 		// directory.
@@ -1114,12 +1175,18 @@
 
 		// Check if the file's package name or imports have changed,
 		// and if so, invalidate this file's packages' metadata.
-		invalidateMetadata := forceReloadMetadata || s.shouldInvalidateMetadata(ctx, result, originalFH, change.fileHandle)
+		shouldInvalidateMetadata, pkgNameChanged := s.shouldInvalidateMetadata(ctx, result, originalFH, change.fileHandle)
+		invalidateMetadata := forceReloadMetadata || shouldInvalidateMetadata
 
 		// Mark all of the package IDs containing the given file.
 		// TODO: if the file has moved into a new package, we should invalidate that too.
-		filePackages := guessPackagesForURI(uri, s.ids)
-		for _, id := range filePackages {
+		filePackageIDs := guessPackageIDsForURI(uri, s.ids)
+		if pkgNameChanged {
+			for _, id := range filePackageIDs {
+				changedPkgNames[id] = append(changedPkgNames[id], uri)
+			}
+		}
+		for _, id := range filePackageIDs {
 			directIDs[id] = directIDs[id] || invalidateMetadata
 		}
 
@@ -1243,6 +1310,12 @@
 			}
 		}
 
+		// If the package name of a file in the package has changed, it's
+		// possible that the package ID may no longer exist.
+		if uris, ok := changedPkgNames[id]; ok && s.shouldDeleteWorkspacePackageID(id, uris) {
+			continue
+		}
+
 		result.workspacePackages[id] = pkgPath
 	}
 
@@ -1277,10 +1350,43 @@
 	return result, workspaceChanged
 }
 
-// guessPackagesForURI returns all packages related 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 not organized by directory.
-func guessPackagesForURI(uri span.URI, known map[span.URI][]packageID) []packageID {
+// shouldDeleteWorkspacePackageID reports whether the given package ID should
+// be removed from the set of workspace packages. If one of the files in the
+// package has changed package names, we check if it is the only file that
+// *only* belongs to this package. For example, in the case of a test variant,
+// confirm that it is the sole file constituting the test variant.
+func (s *snapshot) shouldDeleteWorkspacePackageID(id packageID, changedPkgNames []span.URI) bool {
+	m, ok := s.metadata[id]
+	if !ok {
+		return false
+	}
+	changedPkgName := func(uri span.URI) bool {
+		for _, changed := range changedPkgNames {
+			if uri == changed {
+				return true
+			}
+		}
+		return false
+	}
+	for _, uri := range m.compiledGoFiles {
+		if changedPkgName(uri) {
+			continue
+		}
+		// If there is at least one file remaining that belongs only to this
+		// package, and its package name has not changed, we shouldn't delete
+		// its package ID from the set of workspace packages.
+		if ids := guessPackageIDsForURI(uri, s.ids); len(ids) == 1 && ids[0] == id {
+			return false
+		}
+	}
+	return true
+}
+
+// guessPackageIDsForURI returns all packages related 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 not organized by
+// directory.
+func guessPackageIDsForURI(uri span.URI, known map[span.URI][]packageID) []packageID {
 	packages := known[uri]
 	if len(packages) > 0 {
 		// We've seen this file before.
@@ -1345,17 +1451,20 @@
 
 // shouldInvalidateMetadata reparses a file's package and import declarations to
 // determine if the file requires a metadata reload.
-func (s *snapshot) shouldInvalidateMetadata(ctx context.Context, newSnapshot *snapshot, originalFH, currentFH source.FileHandle) bool {
+func (s *snapshot) shouldInvalidateMetadata(ctx context.Context, newSnapshot *snapshot, originalFH, currentFH source.FileHandle) (invalidate, pkgNameChanged bool) {
 	if originalFH == nil {
-		return true
+		return true, false
 	}
 	// If the file hasn't changed, there's no need to reload.
 	if originalFH.FileIdentity() == currentFH.FileIdentity() {
-		return false
+		return false, false
 	}
 	// If a go.mod in the workspace has been changed, invalidate metadata.
 	if kind := originalFH.Kind(); kind == source.Mod {
-		return source.InDir(filepath.Dir(s.view.rootURI.Filename()), filepath.Dir(originalFH.URI().Filename()))
+		if !source.InDir(filepath.Dir(s.view.rootURI.Filename()), originalFH.URI().Filename()) {
+			return false, false
+		}
+		return currentFH.Saved(), false
 	}
 	// Get the original and current parsed files in order to check package name
 	// and imports. Use the new snapshot to parse to avoid modifying the
@@ -1363,13 +1472,13 @@
 	original, originalErr := newSnapshot.ParseGo(ctx, originalFH, source.ParseHeader)
 	current, currentErr := newSnapshot.ParseGo(ctx, currentFH, source.ParseHeader)
 	if originalErr != nil || currentErr != nil {
-		return (originalErr == nil) != (currentErr == nil)
+		return (originalErr == nil) != (currentErr == nil), false
 	}
 	// Check if the package's metadata has changed. The cases handled are:
 	//    1. A package's name has changed
 	//    2. A file's imports have changed
 	if original.File.Name.Name != current.File.Name.Name {
-		return true
+		return true, true
 	}
 	importSet := make(map[string]struct{})
 	for _, importSpec := range original.File.Imports {
@@ -1393,9 +1502,9 @@
 		if path[len(path)-1] == '/' {
 			continue
 		}
-		return true
+		return true, false
 	}
-	return false
+	return false, false
 }
 
 func (s *snapshot) BuiltinPackage(ctx context.Context) (*source.BuiltinPackage, error) {
@@ -1452,7 +1561,7 @@
 // BuildGoplsMod generates a go.mod file for all modules in the workspace. It
 // bypasses any existing gopls.mod.
 func BuildGoplsMod(ctx context.Context, root span.URI, fs source.FileSource) (*modfile.File, error) {
-	allModules, err := findAllModules(ctx, root)
+	allModules, err := findModules(ctx, root, 0, 0)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/lsp/cache/view.go b/internal/lsp/cache/view.go
index 489504b..9b4de73 100644
--- a/internal/lsp/cache/view.go
+++ b/internal/lsp/cache/view.go
@@ -85,6 +85,10 @@
 	// context is canceled.
 	initializationSema chan struct{}
 
+	// rootURI is the rootURI directory of this view. If we are in GOPATH mode, this
+	// is just the folder. If we are in module mode, this is the module rootURI.
+	rootURI span.URI
+
 	// workspaceInformation tracks various details about this view's
 	// environment variables, go version, and use of modules.
 	workspaceInformation
@@ -112,10 +116,6 @@
 	// goEnv is the `go env` output collected when a view is created.
 	// It includes the values of the environment variables above.
 	goEnv map[string]string
-
-	// rootURI is the rootURI directory of this view. If we are in GOPATH mode, this
-	// is just the folder. If we are in module mode, this is the module rootURI.
-	rootURI span.URI
 }
 
 type environmentVariables struct {
@@ -316,7 +316,7 @@
 }
 
 func (v *View) contains(uri span.URI) bool {
-	return strings.HasPrefix(string(uri), string(v.rootURI))
+	return source.InDir(v.rootURI.Filename(), uri.Filename()) || source.InDir(v.folder.Filename(), uri.Filename())
 }
 
 func (v *View) mapFile(uri span.URI, f *fileBase) {
@@ -426,6 +426,7 @@
 	v.snapshotMu.Lock()
 	go v.snapshot.generation.Destroy()
 	v.snapshotMu.Unlock()
+	v.importsState.destroy()
 	if v.tempWorkspace != "" {
 		if err := os.RemoveAll(v.tempWorkspace.Filename()); err != nil {
 			event.Error(ctx, "removing temp workspace", err)
@@ -433,6 +434,10 @@
 	}
 }
 
+func (v *View) Session() *Session {
+	return v.session
+}
+
 func (v *View) BackgroundContext() context.Context {
 	v.mu.Lock()
 	defer v.mu.Unlock()
@@ -477,6 +482,10 @@
 }
 
 func (v *View) Snapshot(ctx context.Context) (source.Snapshot, func()) {
+	return v.getSnapshot(ctx)
+}
+
+func (v *View) getSnapshot(ctx context.Context) (*snapshot, func()) {
 	v.snapshotMu.Lock()
 	defer v.snapshotMu.Unlock()
 	return v.snapshot, v.snapshot.generation.Acquire(ctx)
@@ -556,7 +565,6 @@
 
 // invalidateContent invalidates the content of a Go file,
 // including any position and type information that depends on it.
-// It returns true if we were already tracking the given file, false otherwise.
 func (v *View) invalidateContent(ctx context.Context, changes map[span.URI]*fileChange, forceReloadMetadata bool) (source.Snapshot, func()) {
 	// Detach the context so that content invalidation cannot be canceled.
 	ctx = xcontext.Detach(ctx)
@@ -665,28 +673,31 @@
 	tool, _ := exec.LookPath("gopackagesdriver")
 	hasGopackagesDriver := gopackagesdriver != "off" && (gopackagesdriver != "" || tool != "")
 
-	root := folder
-	if options.ExpandWorkspaceToModule {
-		wsRoot, err := findWorkspaceRoot(ctx, root, s)
-		if err != nil {
-			return nil, err
-		}
-		if wsRoot != "" {
-			root = wsRoot
-		}
-	}
 	return &workspaceInformation{
 		hasGopackagesDriver:  hasGopackagesDriver,
 		go111module:          go111module,
 		goversion:            goversion,
-		rootURI:              root,
 		environmentVariables: envVars,
 		goEnv:                env,
 	}, nil
 }
 
-func findWorkspaceRoot(ctx context.Context, folder span.URI, fs source.FileSource) (span.URI, error) {
-	for _, basename := range []string{"gopls.mod", "go.mod"} {
+// findWorkspaceRoot searches for the best workspace root according to the
+// following heuristics:
+//   - First, look for a parent directory containing a gopls.mod file
+//     (experimental only).
+//   - Then, a parent directory containing a go.mod file.
+//   - Then, a child directory containing a go.mod file, if there is exactly
+//     one (non-experimental only).
+// Otherwise, it returns folder.
+// TODO (rFindley): move this to workspace.go
+// TODO (rFindley): simplify this once workspace modules are enabled by default.
+func findWorkspaceRoot(ctx context.Context, folder span.URI, fs source.FileSource, experimental bool) (span.URI, error) {
+	patterns := []string{"go.mod"}
+	if experimental {
+		patterns = []string{"gopls.mod", "go.mod"}
+	}
+	for _, basename := range patterns {
 		dir, err := findRootPattern(ctx, folder, basename, fs)
 		if err != nil {
 			return "", errors.Errorf("finding %s: %w", basename, err)
@@ -695,7 +706,31 @@
 			return dir, nil
 		}
 	}
-	return "", nil
+
+	// The experimental workspace can handle nested modules at this point...
+	if experimental {
+		return folder, nil
+	}
+
+	// ...else we should check if there's exactly one nested module.
+	const filesToSearch = 10000
+	all, err := findModules(ctx, folder, 2, filesToSearch)
+	if err == errExhausted {
+		// Fall-back behavior: if we don't find any modules after searching 10000
+		// files, assume there are none.
+		event.Log(ctx, fmt.Sprintf("stopped searching for modules after %d files", filesToSearch))
+		return folder, nil
+	}
+	if err != nil {
+		return "", err
+	}
+	if len(all) == 1 {
+		// range to access first element.
+		for uri := range all {
+			return dirURI(uri), nil
+		}
+	}
+	return folder, nil
 }
 
 func findRootPattern(ctx context.Context, folder span.URI, basename string, fs source.FileSource) (span.URI, error) {
diff --git a/internal/lsp/cache/view_test.go b/internal/lsp/cache/view_test.go
index 39f2e86..d911c80 100644
--- a/internal/lsp/cache/view_test.go
+++ b/internal/lsp/cache/view_test.go
@@ -60,8 +60,10 @@
 module bc
 -- d/gopls.mod --
 module d-goplsworkspace
--- d/e/go.mod
+-- d/e/go.mod --
 module de
+-- f/g/go.mod --
+module fg
 `
 	dir, err := fake.Tempdir(workspace)
 	if err != nil {
@@ -71,26 +73,30 @@
 
 	tests := []struct {
 		folder, want string
+		experimental bool
 	}{
-		// no module at root.
-		{"", ""},
-		{"a", "a"},
-		{"a/x", "a"},
-		{"b/c", "b/c"},
-		{"d", "d"},
-		{"d/e", "d"},
+		{"", "", false}, // no module at root, and more than one nested module
+		{"a", "a", false},
+		{"a/x", "a", false},
+		{"b/c", "b/c", false},
+		{"d", "d/e", false},
+		{"d", "d", true},
+		{"d/e", "d/e", false},
+		{"d/e", "d", true},
+		{"f", "f/g", false},
+		{"f", "f", true},
 	}
 
 	for _, test := range tests {
 		ctx := context.Background()
 		rel := fake.RelativeTo(dir)
 		folderURI := span.URIFromPath(rel.AbsPath(test.folder))
-		got, err := findWorkspaceRoot(ctx, folderURI, osFileSource{})
+		got, err := findWorkspaceRoot(ctx, folderURI, osFileSource{}, test.experimental)
 		if err != nil {
 			t.Fatal(err)
 		}
-		if rel.RelPath(got.Filename()) != test.want {
-			t.Errorf("fileWorkspaceRoot(%q) = %q, want %q", test.folder, got, test.want)
+		if gotf, wantf := filepath.Clean(got.Filename()), rel.AbsPath(test.want); gotf != wantf {
+			t.Errorf("findWorkspaceRoot(%q, %t) = %q, want %q", test.folder, test.experimental, gotf, wantf)
 		}
 	}
 }
diff --git a/internal/lsp/cache/workspace.go b/internal/lsp/cache/workspace.go
index 4d05adc..d04fb83 100644
--- a/internal/lsp/cache/workspace.go
+++ b/internal/lsp/cache/workspace.go
@@ -101,7 +101,7 @@
 			moduleSource: goplsModWorkspace,
 		}, nil
 	}
-	modFiles, err := findAllModules(ctx, root)
+	modFiles, err := findModules(ctx, root, 0, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -234,7 +234,7 @@
 			} else {
 				// gopls.mod is deleted. search for modules again.
 				moduleSource = fileSystemWorkspace
-				modFiles, err = findAllModules(ctx, wm.root)
+				modFiles, err = findModules(ctx, wm.root, 0, 0)
 				// the modFile is no longer valid.
 				if err != nil {
 					event.Error(ctx, "finding file system modules", err)
@@ -308,11 +308,6 @@
 	return filepath.Base(uri.Filename()) == "go.mod"
 }
 
-// isGoMod reports if uri is a go.sum file.
-func isGoSum(uri span.URI) bool {
-	return filepath.Base(uri.Filename()) == "go.sum"
-}
-
 // fileExists reports if the file uri exists within source.
 func fileExists(ctx context.Context, uri span.URI, source source.FileSource) (bool, error) {
 	fh, err := source.GetFile(ctx, uri)
@@ -377,13 +372,21 @@
 	return modFile, modFiles, nil
 }
 
-// findAllModules recursively walks the root directory looking for go.mod
-// files, returning the set of modules it discovers.
+// errExhausted is returned by findModules if the file scan limit is reached.
+var errExhausted = errors.New("exhausted")
+
+// findModules recursively walks the root directory looking for go.mod files,
+// returning the set of modules it discovers. If modLimit is non-zero,
+// searching stops once modLimit modules have been found. If fileLimit is
+// non-zero, searching stops once fileLimit files have been checked.
 // TODO(rfindley): consider overlays.
-func findAllModules(ctx context.Context, root span.URI) (map[span.URI]struct{}, error) {
+func findModules(ctx context.Context, root span.URI, modLimit, fileLimit int) (map[span.URI]struct{}, error) {
 	// Walk the view's folder to find all modules in the view.
 	modFiles := make(map[span.URI]struct{})
-	return modFiles, filepath.Walk(root.Filename(), func(path string, info os.FileInfo, err error) error {
+	searched := 0
+
+	errDone := errors.New("done")
+	err := filepath.Walk(root.Filename(), func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			// Probably a permission error. Keep looking.
 			return filepath.SkipDir
@@ -404,6 +407,17 @@
 		if isGoMod(uri) {
 			modFiles[uri] = struct{}{}
 		}
+		if modLimit > 0 && len(modFiles) >= modLimit {
+			return errDone
+		}
+		searched++
+		if fileLimit > 0 && searched >= fileLimit {
+			return errExhausted
+		}
 		return nil
 	})
+	if err == errDone {
+		return modFiles, nil
+	}
+	return modFiles, err
 }
diff --git a/internal/lsp/command.go b/internal/lsp/command.go
index 20ae57f..7fc954b 100644
--- a/internal/lsp/command.go
+++ b/internal/lsp/command.go
@@ -192,11 +192,16 @@
 		}
 		// The flow for `go mod tidy` and `go mod vendor` is almost identical,
 		// so we combine them into one case for convenience.
-		a := "tidy"
+		action := "tidy"
 		if command == source.CommandVendor {
-			a = "vendor"
+			action = "vendor"
 		}
-		return s.directGoModCommand(ctx, uri, "mod", a)
+		snapshot, _, ok, release, err := s.beginFileRequest(ctx, uri, source.UnknownKind)
+		defer release()
+		if !ok {
+			return err
+		}
+		return runSimpleGoCommand(ctx, snapshot, source.UpdateUserModFile, uri.SpanURI(), "mod", []string{action})
 	case source.CommandAddDependency, source.CommandUpgradeDependency, source.CommandRemoveDependency:
 		var uri protocol.DocumentURI
 		var goCmdArgs []string
@@ -204,22 +209,18 @@
 		if err := source.UnmarshalArgs(args, &uri, &addRequire, &goCmdArgs); err != nil {
 			return err
 		}
-		if addRequire {
-			// Using go get to create a new dependency results in an
-			// `// indirect` comment we may not want. The only way to avoid it
-			// is to add the require as direct first. Then we can use go get to
-			// update go.sum and tidy up.
-			if err := s.directGoModCommand(ctx, uri, "mod", append([]string{"edit", "-require"}, goCmdArgs...)...); err != nil {
-				return err
-			}
+		snapshot, _, ok, release, err := s.beginFileRequest(ctx, uri, source.UnknownKind)
+		defer release()
+		if !ok {
+			return err
 		}
-		return s.directGoModCommand(ctx, uri, "get", append([]string{"-d"}, goCmdArgs...)...)
+		return s.runGoGetModule(ctx, snapshot, uri.SpanURI(), addRequire, goCmdArgs)
 	case source.CommandToggleDetails:
-		var fileURI span.URI
+		var fileURI protocol.DocumentURI
 		if err := source.UnmarshalArgs(args, &fileURI); err != nil {
 			return err
 		}
-		pkgDir := span.URIFromPath(filepath.Dir(fileURI.Filename()))
+		pkgDir := span.URIFromPath(filepath.Dir(fileURI.SpanURI().Filename()))
 		s.gcOptimizationDetailsMu.Lock()
 		if _, ok := s.gcOptimizationDetails[pkgDir]; ok {
 			delete(s.gcOptimizationDetails, pkgDir)
@@ -229,12 +230,11 @@
 		s.gcOptimizationDetailsMu.Unlock()
 		// need to recompute diagnostics.
 		// so find the snapshot
-		sv, err := s.session.ViewOf(fileURI)
-		if err != nil {
+		snapshot, _, ok, release, err := s.beginFileRequest(ctx, fileURI, source.UnknownKind)
+		defer release()
+		if !ok {
 			return err
 		}
-		snapshot, release := sv.Snapshot(ctx)
-		defer release()
 		s.diagnoseSnapshot(snapshot, nil, false)
 	case source.CommandGenerateGoplsMod:
 		var v source.View
@@ -275,21 +275,6 @@
 	return nil
 }
 
-func (s *Server) directGoModCommand(ctx context.Context, uri protocol.DocumentURI, verb string, args ...string) error {
-	view, err := s.session.ViewOf(uri.SpanURI())
-	if err != nil {
-		return err
-	}
-	snapshot, release := view.Snapshot(ctx)
-	defer release()
-	_, err = snapshot.RunGoCommandDirect(ctx, source.UpdateUserModFile, &gocommand.Invocation{
-		Verb:       verb,
-		Args:       args,
-		WorkingDir: filepath.Dir(uri.SpanURI().Filename()),
-	})
-	return err
-}
-
 func (s *Server) runTests(ctx context.Context, snapshot source.Snapshot, uri protocol.DocumentURI, work *workDone, tests, benchmarks []string) error {
 	pkgs, err := snapshot.PackagesForFile(ctx, uri.SpanURI(), source.TypecheckWorkspace)
 	if err != nil {
@@ -355,14 +340,12 @@
 	} else if failedBenchmarks > 0 {
 		message = fmt.Sprintf("%d / %d benchmarks failed", failedBenchmarks, len(benchmarks))
 	}
-	messageType := protocol.Info
 	if failedTests > 0 || failedBenchmarks > 0 {
-		messageType = protocol.Error
 		message += "\n" + buf.String()
 	}
 
 	return s.client.ShowMessage(ctx, &protocol.ShowMessageParams{
-		Type:    messageType,
+		Type:    protocol.Info,
 		Message: message,
 	})
 }
@@ -375,7 +358,7 @@
 
 	pattern := "."
 	if recursive {
-		pattern = "..."
+		pattern = "./..."
 	}
 
 	inv := &gocommand.Invocation{
@@ -389,3 +372,25 @@
 	}
 	return nil
 }
+
+func (s *Server) runGoGetModule(ctx context.Context, snapshot source.Snapshot, uri span.URI, addRequire bool, args []string) error {
+	if addRequire {
+		// Using go get to create a new dependency results in an
+		// `// indirect` comment we may not want. The only way to avoid it
+		// is to add the require as direct first. Then we can use go get to
+		// update go.sum and tidy up.
+		if err := runSimpleGoCommand(ctx, snapshot, source.UpdateUserModFile, uri, "mod", append([]string{"edit", "-require"}, args...)); err != nil {
+			return err
+		}
+	}
+	return runSimpleGoCommand(ctx, snapshot, source.UpdateUserModFile, uri, "get", append([]string{"-d"}, args...))
+}
+
+func runSimpleGoCommand(ctx context.Context, snapshot source.Snapshot, mode source.InvocationMode, uri span.URI, verb string, args []string) error {
+	_, err := snapshot.RunGoCommandDirect(ctx, mode, &gocommand.Invocation{
+		Verb:       verb,
+		Args:       args,
+		WorkingDir: filepath.Dir(uri.Filename()),
+	})
+	return err
+}
diff --git a/internal/lsp/debug/info.go b/internal/lsp/debug/info.go
index 53f5c11..a8b8ee4 100644
--- a/internal/lsp/debug/info.go
+++ b/internal/lsp/debug/info.go
@@ -99,6 +99,9 @@
 		fmt.Fprintf(w, "Debug address: %s\n", i.DebugAddress)
 	})
 	PrintVersionInfo(ctx, w, true, HTML)
+	section(w, HTML, "Command Line", func() {
+		fmt.Fprintf(w, "<a href=/debug/pprof/cmdline>cmdline</a>")
+	})
 }
 
 // PrintVersionInfo writes version information to w, using the output format
diff --git a/internal/lsp/debug/serve.go b/internal/lsp/debug/serve.go
index ae526ec..aa4df63 100644
--- a/internal/lsp/debug/serve.go
+++ b/internal/lsp/debug/serve.go
@@ -231,6 +231,36 @@
 	}
 }
 
+// an http.ResponseWriter that filters writes
+type filterResponse struct {
+	w    http.ResponseWriter
+	edit func([]byte) []byte
+}
+
+func (c filterResponse) Header() http.Header {
+	return c.w.Header()
+}
+
+func (c filterResponse) Write(buf []byte) (int, error) {
+	ans := c.edit(buf)
+	return c.w.Write(ans)
+}
+
+func (c filterResponse) WriteHeader(n int) {
+	c.w.WriteHeader(n)
+}
+
+// replace annoying nuls by spaces
+func cmdline(w http.ResponseWriter, r *http.Request) {
+	fake := filterResponse{
+		w: w,
+		edit: func(buf []byte) []byte {
+			return bytes.ReplaceAll(buf, []byte{0}, []byte{' '})
+		},
+	}
+	pprof.Cmdline(fake, r)
+}
+
 func (i *Instance) getCache(r *http.Request) interface{} {
 	return i.State.Cache(path.Base(r.URL.Path))
 }
@@ -354,6 +384,7 @@
 // It also logs the port the server starts on, to allow for :0 auto assigned
 // ports.
 func (i *Instance) Serve(ctx context.Context) error {
+	log.SetFlags(log.Lshortfile)
 	if i.DebugAddress == "" {
 		return nil
 	}
@@ -365,7 +396,7 @@
 
 	port := listener.Addr().(*net.TCPAddr).Port
 	if strings.HasSuffix(i.DebugAddress, ":0") {
-		log.Printf("debug server listening on port %d", port)
+		log.Printf("debug server listening at http://localhost:%d", port)
 	}
 	event.Log(ctx, "Debug serving", tag.Port.Of(port))
 	go func() {
@@ -373,7 +404,7 @@
 		mux.HandleFunc("/", render(mainTmpl, func(*http.Request) interface{} { return i }))
 		mux.HandleFunc("/debug/", render(debugTmpl, nil))
 		mux.HandleFunc("/debug/pprof/", pprof.Index)
-		mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
+		mux.HandleFunc("/debug/pprof/cmdline", cmdline)
 		mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
 		mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
 		mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
@@ -624,7 +655,7 @@
 {{define "serverlink"}}<a href="/server/{{.}}">Server {{.}}</a>{{end}}
 {{define "sessionlink"}}<a href="/session/{{.}}">Session {{.}}</a>{{end}}
 {{define "viewlink"}}<a href="/view/{{.}}">View {{.}}</a>{{end}}
-{{define "filelink"}}<a href="/file/{{.SessionID}}/{{.Identifier}}">{{.URI}}</a>{{end}}
+{{define "filelink"}}<a href="/file/{{.Session}}/{{.FileIdentity.Hash}}">{{.FileIdentity.URI}}</a>{{end}}
 `)).Funcs(template.FuncMap{
 	"fuint64":  fuint64,
 	"fuint32":  fuint32,
@@ -747,7 +778,7 @@
 <h2>Views</h2>
 <ul>{{range .Views}}<li>{{.Name}} is {{template "viewlink" .ID}} in {{.Folder}}</li>{{end}}</ul>
 <h2>Overlays</h2>
-<ul>{{range .Overlays}}<li>{{template "filelink" .Identity}}</li>{{end}}</ul>
+<ul>{{range .Overlays}}<li>{{template "filelink" .}}</li>{{end}}</ul>
 {{end}}
 `))
 
@@ -763,16 +794,16 @@
 `))
 
 var fileTmpl = template.Must(template.Must(baseTemplate.Clone()).Parse(`
-{{define "title"}}Overlay {{.Identity.Identifier}}{{end}}
+{{define "title"}}Overlay {{.FileIdentity.Hash}}{{end}}
 {{define "body"}}
-{{with .Identity}}
-	From: <b>{{template "sessionlink" .SessionID}}</b><br>
+{{with .}}
+	From: <b>{{template "sessionlink" .Session}}</b><br>
 	URI: <b>{{.URI}}</b><br>
-	Identifier: <b>{{.Identifier}}</b><br>
+	Identifier: <b>{{.FileIdentity.Hash}}</b><br>
 	Version: <b>{{.Version}}</b><br>
 	Kind: <b>{{.Kind}}</b><br>
 {{end}}
 <h3>Contents</h3>
-<pre>{{fcontent .Data}}</pre>
+<pre>{{fcontent .Read}}</pre>
 {{end}}
 `))
diff --git a/internal/lsp/diagnostics.go b/internal/lsp/diagnostics.go
index c54bdaa..e8e2868 100644
--- a/internal/lsp/diagnostics.go
+++ b/internal/lsp/diagnostics.go
@@ -182,34 +182,24 @@
 
 	// Diagnose all of the packages in the workspace.
 	wsPkgs, err := snapshot.WorkspacePackages(ctx)
-	if err != nil {
-		if errors.Is(err, context.Canceled) {
-			return nil, nil
-		}
-		// Some error messages can be displayed as diagnostics.
-		if errList := (*source.ErrorList)(nil); errors.As(err, &errList) {
-			if err := errorsToDiagnostic(ctx, snapshot, *errList, reports); err == nil {
-				return reports, nil
-			}
-		}
-		// Try constructing a more helpful error message out of this error.
-		if s.handleFatalErrors(ctx, snapshot, modErr, err) {
-			return nil, nil
-		}
-		event.Error(ctx, "errors diagnosing workspace", err, tag.Snapshot.Of(snapshot.ID()), tag.Directory.Of(snapshot.View().Folder()))
-		// Present any `go list` errors directly to the user.
-		if errors.Is(err, source.PackagesLoadError) {
-			if err := s.client.ShowMessage(ctx, &protocol.ShowMessageParams{
-				Type: protocol.Error,
-				Message: fmt.Sprintf(`The code in the workspace failed to compile (see the error message below).
-If you believe this is a mistake, please file an issue: https://github.com/golang/go/issues/new.
-%v`, err),
-			}); err != nil {
-				event.Error(ctx, "ShowMessage failed", err, tag.Directory.Of(snapshot.View().Folder().Filename()))
-			}
-		}
+	if s.shouldIgnoreError(ctx, snapshot, err) {
 		return nil, nil
 	}
+	// Show the error as a progress error report so that it appears in the
+	// status bar. If a client doesn't support progress reports, the error
+	// will still be shown as a ShowMessage. If there is no error, any running
+	// error progress reports will be closed.
+	s.showCriticalErrorStatus(ctx, err)
+
+	if err != nil {
+		// Some error messages can also be displayed as diagnostics.
+		if errList := (*source.ErrorList)(nil); errors.As(err, &errList) {
+			_ = errorsToDiagnostic(ctx, snapshot, *errList, reports)
+		}
+		event.Error(ctx, "errors diagnosing workspace", err, tag.Snapshot.Of(snapshot.ID()), tag.Directory.Of(snapshot.View().Folder()))
+		return reports, nil
+	}
+
 	var (
 		showMsgMu sync.Mutex
 		showMsg   *protocol.ShowMessageParams
@@ -299,6 +289,36 @@
 	return reports, showMsg
 }
 
+// showCriticalErrorStatus shows the error as a progress report.
+// If the error is nil, it clears any existing error progress report.
+func (s *Server) showCriticalErrorStatus(ctx context.Context, err error) {
+	s.criticalErrorStatusMu.Lock()
+	defer s.criticalErrorStatusMu.Unlock()
+
+	// Remove all newlines so that the error message can be formatted in a
+	// status bar.
+	var errMsg string
+	if err != nil {
+		errMsg = strings.Replace(err.Error(), "\n", " ", -1)
+	}
+
+	if s.criticalErrorStatus == nil {
+		if errMsg != "" {
+			s.criticalErrorStatus = s.progress.start(ctx, "Error loading workspace", errMsg, nil, nil)
+		}
+		return
+	}
+
+	// If an error is already shown to the user, update it or mark it as
+	// resolved.
+	if errMsg == "" {
+		s.criticalErrorStatus.end("Done.")
+		s.criticalErrorStatus = nil
+	} else {
+		s.criticalErrorStatus.report(errMsg, 0)
+	}
+}
+
 // checkForOrphanedFile checks that the given URIs can be mapped to packages.
 // If they cannot and the workspace is not otherwise unloaded, it also surfaces
 // a warning, suggesting that the user check the file for build tags.
@@ -470,7 +490,13 @@
 	return reports
 }
 
-func (s *Server) handleFatalErrors(ctx context.Context, snapshot source.Snapshot, modErr, loadErr error) bool {
+func (s *Server) shouldIgnoreError(ctx context.Context, snapshot source.Snapshot, err error) bool {
+	if err == nil { // if there is no error at all
+		return false
+	}
+	if errors.Is(err, context.Canceled) {
+		return true
+	}
 	// If the folder has no Go code in it, we shouldn't spam the user with a warning.
 	var hasGo bool
 	_ = filepath.Walk(snapshot.View().Folder().Filename(), func(path string, info os.FileInfo, err error) error {
diff --git a/internal/lsp/fake/editor.go b/internal/lsp/fake/editor.go
index 3cc1c06..2c4cdc0 100644
--- a/internal/lsp/fake/editor.go
+++ b/internal/lsp/fake/editor.go
@@ -81,9 +81,9 @@
 	// workspace folders nor a root URI.
 	WithoutWorkspaceFolders bool
 
-	// EditorRootPath specifies the root path of the workspace folder used when
+	// WorkspaceRoot specifies the root path of the workspace folder used when
 	// initializing gopls in the sandbox. If empty, the Workdir is used.
-	EditorRootPath string
+	WorkspaceRoot string
 
 	// EnableStaticcheck enables staticcheck analyzers.
 	EnableStaticcheck bool
@@ -95,6 +95,8 @@
 	// Whether to send the current process ID, for testing data that is joined to
 	// the PID. This can only be set by one test.
 	SendPID bool
+
+	VerboseOutput bool
 }
 
 // NewEditor Creates a new Editor.
@@ -121,7 +123,7 @@
 		protocol.Handlers(
 			protocol.ClientHandler(e.client,
 				jsonrpc2.MethodNotFound)))
-	if err := e.initialize(ctx, e.Config.WithoutWorkspaceFolders, e.Config.EditorRootPath); err != nil {
+	if err := e.initialize(ctx, e.Config.WithoutWorkspaceFolders, e.Config.WorkspaceRoot); err != nil {
 		return nil, err
 	}
 	e.sandbox.Workdir.AddWatcher(e.onFileChanges)
@@ -212,6 +214,10 @@
 		config["allExperiments"] = true
 	}
 
+	if e.Config.VerboseOutput {
+		config["verboseOutput"] = true
+	}
+
 	// TODO(rFindley): uncomment this if/when diagnostics delay is on by
 	// default... and probably change to the new settings name.
 	// config["experimentalDiagnosticsDelay"] = "10ms"
@@ -391,9 +397,9 @@
 
 func (e *Editor) SaveBufferWithoutActions(ctx context.Context, path string) error {
 	e.mu.Lock()
+	defer e.mu.Unlock()
 	buf, ok := e.buffers[path]
 	if !ok {
-		e.mu.Unlock()
 		return fmt.Errorf(fmt.Sprintf("unknown buffer: %q", path))
 	}
 	content := buf.text()
@@ -402,7 +408,6 @@
 	if ok {
 		includeText = syncOptions.Save.IncludeText
 	}
-	e.mu.Unlock()
 
 	docID := e.textDocumentIdentifier(buf.path)
 	if e.Server != nil {
@@ -417,10 +422,8 @@
 		return errors.Errorf("writing %q: %w", path, err)
 	}
 
-	e.mu.Lock()
 	buf.dirty = false
 	e.buffers[path] = buf
-	e.mu.Unlock()
 
 	if e.Server != nil {
 		params := &protocol.DidSaveTextDocumentParams{
@@ -806,6 +809,9 @@
 		return fmt.Errorf("before receipt of formatting edits, buffer version changed from %d to %d", version, versionAfter)
 	}
 	edits := convertEdits(resp)
+	if len(edits) == 0 {
+		return nil
+	}
 	return e.editBufferLocked(ctx, path, edits)
 }
 
diff --git a/internal/lsp/fake/sandbox.go b/internal/lsp/fake/sandbox.go
index f240f9b..3b92dc0 100644
--- a/internal/lsp/fake/sandbox.go
+++ b/internal/lsp/fake/sandbox.go
@@ -22,7 +22,7 @@
 // code in tests.
 type Sandbox struct {
 	gopath  string
-	basedir string
+	rootdir string
 	goproxy string
 	Workdir *Workdir
 }
@@ -42,9 +42,12 @@
 	// InGoPath specifies that the working directory should be within the
 	// temporary GOPATH.
 	InGoPath bool
-	// Workdir configures the working directory of the Sandbox, for running in a
-	// pre-existing directory. If unset, a new working directory will be created
-	// under RootDir.
+	// Workdir configures the working directory of the Sandbox. It behaves as
+	// follows:
+	//  - if set to an absolute path, use that path as the working directory.
+	//  - if set to a relative path, create and use that path relative to the
+	//    sandbox.
+	//  - if unset, default to a the 'work' subdirectory of the sandbox.
 	//
 	// This option is incompatible with InGoPath or Files.
 	Workdir string
@@ -70,13 +73,8 @@
 	if config == nil {
 		config = new(SandboxConfig)
 	}
-
-	if config.Workdir != "" && (config.Files != "" || config.InGoPath) {
-		return nil, fmt.Errorf("invalid SandboxConfig: Workdir cannot be used in conjunction with Files or InGoPath. Got %+v", config)
-	}
-
-	if config.GOPROXY != "" && config.ProxyFiles != "" {
-		return nil, fmt.Errorf("invalid SandboxConfig: GOPROXY cannot be set in conjunction with ProxyFiles. Got %+v", config)
+	if err := validateConfig(*config); err != nil {
+		return nil, fmt.Errorf("invalid SandboxConfig: %v", err)
 	}
 
 	sb := &Sandbox{}
@@ -87,19 +85,22 @@
 		}
 	}()
 
-	baseDir, err := ioutil.TempDir(config.RootDir, "gopls-sandbox-")
-	if err != nil {
-		return nil, fmt.Errorf("creating temporary workdir: %v", err)
+	rootDir := config.RootDir
+	if rootDir == "" {
+		rootDir, err = ioutil.TempDir(config.RootDir, "gopls-sandbox-")
+		if err != nil {
+			return nil, fmt.Errorf("creating temporary workdir: %v", err)
+		}
 	}
-	sb.basedir = baseDir
-	sb.gopath = filepath.Join(sb.basedir, "gopath")
+	sb.rootdir = rootDir
+	sb.gopath = filepath.Join(sb.rootdir, "gopath")
 	if err := os.Mkdir(sb.gopath, 0755); err != nil {
 		return nil, err
 	}
 	if config.GOPROXY != "" {
 		sb.goproxy = config.GOPROXY
 	} else {
-		proxydir := filepath.Join(sb.basedir, "proxy")
+		proxydir := filepath.Join(sb.rootdir, "proxy")
 		if err := os.Mkdir(proxydir, 0755); err != nil {
 			return nil, err
 		}
@@ -108,27 +109,32 @@
 			return nil, err
 		}
 	}
-	if config.Workdir != "" {
+	// Short-circuit writing the workdir if we're given an absolute path, since
+	// this is used for running in an existing directory.
+	// TODO(findleyr): refactor this to be less of a workaround.
+	if filepath.IsAbs(config.Workdir) {
 		sb.Workdir = NewWorkdir(config.Workdir)
-	} else {
-		workdir := config.Workdir
-		// If we don't have a pre-existing work dir, we want to create either
-		// $GOPATH/src or <RootDir/work>.
+		return sb, nil
+	}
+	var workdir string
+	if config.Workdir == "" {
 		if config.InGoPath {
 			// Set the working directory as $GOPATH/src.
 			workdir = filepath.Join(sb.gopath, "src")
 		} else if workdir == "" {
-			workdir = filepath.Join(sb.basedir, "work")
+			workdir = filepath.Join(sb.rootdir, "work")
 		}
-		if err := os.Mkdir(workdir, 0755); err != nil {
-			return nil, err
-		}
-		sb.Workdir = NewWorkdir(workdir)
-		if err := sb.Workdir.writeInitialFiles(config.Files); err != nil {
-			return nil, err
-		}
+	} else {
+		// relative path
+		workdir = filepath.Join(sb.rootdir, config.Workdir)
 	}
-
+	if err := os.MkdirAll(workdir, 0755); err != nil {
+		return nil, err
+	}
+	sb.Workdir = NewWorkdir(workdir)
+	if err := sb.Workdir.writeInitialFiles(config.Files); err != nil {
+		return nil, err
+	}
 	return sb, nil
 }
 
@@ -155,6 +161,19 @@
 	return dataMap
 }
 
+func validateConfig(config SandboxConfig) error {
+	if filepath.IsAbs(config.Workdir) && (config.Files != "" || config.InGoPath) {
+		return errors.New("absolute Workdir cannot be set in conjunction with Files or InGoPath")
+	}
+	if config.Workdir != "" && config.InGoPath {
+		return errors.New("Workdir cannot be set in conjunction with InGoPath")
+	}
+	if config.GOPROXY != "" && config.ProxyFiles != "" {
+		return errors.New("GOPROXY cannot be set in conjunction with ProxyFiles")
+	}
+	return nil
+}
+
 // splitModuleVersionPath extracts module information from files stored in the
 // directory structure modulePath@version/suffix.
 // For example:
@@ -174,6 +193,10 @@
 	return path, "", ""
 }
 
+func (sb *Sandbox) RootDir() string {
+	return sb.rootdir
+}
+
 // GOPATH returns the value of the Sandbox GOPATH.
 func (sb *Sandbox) GOPATH() string {
 	return sb.gopath
@@ -236,7 +259,7 @@
 	if sb.gopath != "" {
 		goCleanErr = sb.RunGoCommand(context.Background(), "", "clean", []string{"-modcache"})
 	}
-	err := os.RemoveAll(sb.basedir)
+	err := os.RemoveAll(sb.rootdir)
 	if err != nil || goCleanErr != nil {
 		return fmt.Errorf("error(s) cleaning sandbox: cleaning modcache: %v; removing files: %v", goCleanErr, err)
 	}
diff --git a/internal/lsp/fake/workdir.go b/internal/lsp/fake/workdir.go
index f036d42..84fa9a5 100644
--- a/internal/lsp/fake/workdir.go
+++ b/internal/lsp/fake/workdir.go
@@ -180,7 +180,7 @@
 // RemoveFile removes a workdir-relative file path.
 func (w *Workdir) RemoveFile(ctx context.Context, path string) error {
 	fp := w.AbsPath(path)
-	if err := os.Remove(fp); err != nil {
+	if err := os.RemoveAll(fp); err != nil {
 		return errors.Errorf("removing %q: %w", path, err)
 	}
 	evts := []FileEvent{{
diff --git a/internal/lsp/general.go b/internal/lsp/general.go
index 620140c..558767b 100644
--- a/internal/lsp/general.go
+++ b/internal/lsp/general.go
@@ -13,7 +13,6 @@
 	"os"
 	"path"
 	"path/filepath"
-	"strings"
 	"sync"
 
 	"golang.org/x/tools/internal/event"
@@ -172,8 +171,7 @@
 			},
 		}
 		if options.SemanticTokens {
-			registrations = append(registrations, semanticTokenRegistrations()...)
-
+			registrations = append(registrations, semanticTokenRegistration())
 		}
 		if err := s.client.RegisterCapability(ctx, &protocol.RegistrationParams{
 			Registrations: registrations,
@@ -409,27 +407,18 @@
 	return nil
 }
 
-func isSubdirectory(root, leaf string) bool {
-	rel, err := filepath.Rel(root, leaf)
-	return err == nil && !strings.HasPrefix(rel, "..")
-}
-
 func (s *Server) fetchConfig(ctx context.Context, name string, folder span.URI, o *source.Options) error {
 	if !s.session.Options().ConfigurationSupported {
 		return nil
 	}
-	v := protocol.ParamConfiguration{
+	configs, err := s.client.Configuration(ctx, &protocol.ParamConfiguration{
 		ConfigurationParams: protocol.ConfigurationParams{
 			Items: []protocol.ConfigurationItem{{
 				ScopeURI: string(folder),
 				Section:  "gopls",
-			}, {
-				ScopeURI: string(folder),
-				Section:  fmt.Sprintf("gopls-%s", name),
 			}},
 		},
-	}
-	configs, err := s.client.Configuration(ctx, &v)
+	})
 	if err != nil {
 		return fmt.Errorf("failed to get workspace configuration from client (%s): %v", folder, err)
 	}
diff --git a/internal/lsp/link.go b/internal/lsp/link.go
index 4868f71..87692fa 100644
--- a/internal/lsp/link.go
+++ b/internal/lsp/link.go
@@ -67,7 +67,7 @@
 		// Shift the start position to the location of the
 		// dependency within the require statement.
 		start, end := token.Pos(s+i), token.Pos(s+i+len(dep))
-		target := fmt.Sprintf("https://%s/mod/%s", snapshot.View().Options().LinkTarget, req.Mod.String())
+		target := source.BuildLink(snapshot.View().Options().LinkTarget, "mod/"+req.Mod.String(), "")
 		l, err := toProtocolLink(snapshot, pm.Mapper, target, start, end, source.Mod)
 		if err != nil {
 			return nil, err
@@ -143,7 +143,7 @@
 			// Account for the quotation marks in the positions.
 			start := imp.Path.Pos() + 1
 			end := imp.Path.End() - 1
-			target = fmt.Sprintf("https://%s/%s", view.Options().LinkTarget, target)
+			target = source.BuildLink(view.Options().LinkTarget, target, "")
 			l, err := toProtocolLink(snapshot, pgf.Mapper, target, start, end, source.Go)
 			if err != nil {
 				return nil, err
diff --git a/internal/lsp/mod/code_lens.go b/internal/lsp/mod/code_lens.go
index db2aea2..e3aa2f6 100644
--- a/internal/lsp/mod/code_lens.go
+++ b/internal/lsp/mod/code_lens.go
@@ -6,7 +6,6 @@
 	"os"
 	"path/filepath"
 
-	"golang.org/x/mod/modfile"
 	"golang.org/x/tools/internal/lsp/protocol"
 	"golang.org/x/tools/internal/lsp/source"
 	"golang.org/x/tools/internal/span"
@@ -23,93 +22,46 @@
 
 func upgradeLens(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {
 	pm, err := snapshot.ParseMod(ctx, fh)
-	if err != nil {
+	if err != nil || pm.File == nil {
 		return nil, err
 	}
-	module := pm.File.Module
-	if module == nil || module.Syntax == nil {
+	if len(pm.File.Require) == 0 {
+		// Nothing to upgrade.
 		return nil, nil
 	}
-	upgrades, err := snapshot.ModUpgrade(ctx, fh)
+	upgradeDepArgs, err := source.MarshalArgs(fh.URI(), false, []string{"-u", "all"})
 	if err != nil {
 		return nil, err
 	}
-	var (
-		codelenses  []protocol.CodeLens
-		allUpgrades []string
-	)
-	for _, req := range pm.File.Require {
-		dep := req.Mod.Path
-		latest, ok := upgrades[dep]
-		if !ok {
-			continue
-		}
-		if req.Syntax == nil {
-			continue
-		}
-		// Get the range of the require directive.
-		rng, err := positionsToRange(fh.URI(), pm.Mapper, req.Syntax.Start, req.Syntax.End)
-		if err != nil {
-			return nil, err
-		}
-		upgradeDepArgs, err := source.MarshalArgs(fh.URI(), false, []string{dep})
-		if err != nil {
-			return nil, err
-		}
-		codelenses = append(codelenses, protocol.CodeLens{
-			Range: rng,
-			Command: protocol.Command{
-				Title:     fmt.Sprintf("Upgrade dependency to %s", latest),
-				Command:   source.CommandUpgradeDependency.ID(),
-				Arguments: upgradeDepArgs,
-			},
-		})
-		allUpgrades = append(allUpgrades, dep)
+	rng, err := moduleStmtRange(fh, pm)
+	if err != nil {
+		return nil, err
 	}
-	// If there is at least 1 upgrade, add "Upgrade all dependencies" to
-	// the module statement.
-	if len(allUpgrades) > 0 {
-		upgradeDepArgs, err := source.MarshalArgs(fh.URI(), false, append([]string{"-u"}, allUpgrades...))
-		if err != nil {
-			return nil, err
-		}
-		// Get the range of the module directive.
-		moduleRng, err := positionsToRange(pm.Mapper.URI, pm.Mapper, module.Syntax.Start, module.Syntax.End)
-		if err != nil {
-			return nil, err
-		}
-		codelenses = append(codelenses, protocol.CodeLens{
-			Range: moduleRng,
-			Command: protocol.Command{
-				Title:     "Upgrade all dependencies",
-				Command:   source.CommandUpgradeDependency.ID(),
-				Arguments: upgradeDepArgs,
-			},
-		})
-	}
-	return codelenses, err
+	return []protocol.CodeLens{{
+		Range: rng,
+		Command: protocol.Command{
+			Title:     "Upgrade all dependencies",
+			Command:   source.CommandUpgradeDependency.ID(),
+			Arguments: upgradeDepArgs,
+		},
+	}}, nil
+
 }
 
 func tidyLens(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {
+	pm, err := snapshot.ParseMod(ctx, fh)
+	if err != nil || pm.File == nil {
+		return nil, err
+	}
+	if len(pm.File.Require) == 0 {
+		// Nothing to vendor.
+		return nil, nil
+	}
 	goModArgs, err := source.MarshalArgs(fh.URI())
 	if err != nil {
 		return nil, err
 	}
-	tidied, err := snapshot.ModTidy(ctx, fh)
-	if err != nil {
-		return nil, err
-	}
-	if len(tidied.Errors) == 0 {
-		return nil, nil
-	}
-	pm, err := snapshot.ParseMod(ctx, fh)
-	if err != nil {
-		return nil, err
-	}
-	if pm.File == nil || pm.File.Module == nil || pm.File.Module.Syntax == nil {
-		return nil, fmt.Errorf("no parsed go.mod for %s", fh.URI())
-	}
-	rng, err := positionsToRange(pm.Mapper.URI, pm.Mapper, pm.File.Module.Syntax.Start, pm.File.Module.Syntax.End)
+	rng, err := moduleStmtRange(fh, pm)
 	if err != nil {
 		return nil, err
 	}
@@ -120,22 +72,19 @@
 			Command:   source.CommandTidy.ID(),
 			Arguments: goModArgs,
 		},
-	}}, err
+	}}, nil
 }
 
 func vendorLens(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {
-	goModArgs, err := source.MarshalArgs(fh.URI())
-	if err != nil {
-		return nil, err
-	}
 	pm, err := snapshot.ParseMod(ctx, fh)
+	if err != nil || pm.File == nil {
+		return nil, err
+	}
+	rng, err := moduleStmtRange(fh, pm)
 	if err != nil {
 		return nil, err
 	}
-	if pm.File == nil || pm.File.Module == nil || pm.File.Module.Syntax == nil {
-		return nil, fmt.Errorf("no parsed go.mod for %s", fh.URI())
-	}
-	rng, err := positionsToRange(pm.Mapper.URI, pm.Mapper, pm.File.Module.Syntax.Start, pm.File.Module.Syntax.End)
+	goModArgs, err := source.MarshalArgs(fh.URI())
 	if err != nil {
 		return nil, err
 	}
@@ -156,18 +105,22 @@
 	}}, nil
 }
 
-func positionsToRange(uri span.URI, m *protocol.ColumnMapper, s, e modfile.Position) (protocol.Range, error) {
-	line, col, err := m.Converter.ToPosition(s.Byte)
+func moduleStmtRange(fh source.FileHandle, pm *source.ParsedModule) (protocol.Range, error) {
+	if pm.File == nil || pm.File.Module == nil || pm.File.Module.Syntax == nil {
+		return protocol.Range{}, fmt.Errorf("no module statement in %s", fh.URI())
+	}
+	syntax := pm.File.Module.Syntax
+	line, col, err := pm.Mapper.Converter.ToPosition(syntax.Start.Byte)
 	if err != nil {
 		return protocol.Range{}, err
 	}
-	start := span.NewPoint(line, col, s.Byte)
-	line, col, err = m.Converter.ToPosition(e.Byte)
+	start := span.NewPoint(line, col, syntax.Start.Byte)
+	line, col, err = pm.Mapper.Converter.ToPosition(syntax.End.Byte)
 	if err != nil {
 		return protocol.Range{}, err
 	}
-	end := span.NewPoint(line, col, e.Byte)
-	rng, err := m.Range(span.New(uri, start, end))
+	end := span.NewPoint(line, col, syntax.End.Byte)
+	rng, err := pm.Mapper.Range(span.New(fh.URI(), start, end))
 	if err != nil {
 		return protocol.Range{}, err
 	}
diff --git a/internal/lsp/mod/diagnostics.go b/internal/lsp/mod/diagnostics.go
index 41a462c..20fd606 100644
--- a/internal/lsp/mod/diagnostics.go
+++ b/internal/lsp/mod/diagnostics.go
@@ -52,7 +52,14 @@
 }
 
 func ErrorsForMod(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]source.Error, error) {
-	tidied, err := snapshot.ModTidy(ctx, fh)
+	pm, err := snapshot.ParseMod(ctx, fh)
+	if err != nil {
+		if pm == nil || len(pm.ParseErrors) == 0 {
+			return nil, err
+		}
+		return pm.ParseErrors, nil
+	}
+	tidied, err := snapshot.ModTidy(ctx, pm)
 
 	if source.IsNonFatalGoModError(err) {
 		return nil, nil
diff --git a/internal/lsp/mod/hover.go b/internal/lsp/mod/hover.go
index 739ebef..a12b22c 100644
--- a/internal/lsp/mod/hover.go
+++ b/internal/lsp/mod/hover.go
@@ -140,7 +140,7 @@
 		if strings.ToLower(options.LinkTarget) == "pkg.go.dev" {
 			target = strings.Replace(target, req.Mod.Path, req.Mod.String(), 1)
 		}
-		reference = fmt.Sprintf("[%s](https://%s/%s)", imp, options.LinkTarget, target)
+		reference = fmt.Sprintf("[%s](%s)", imp, source.BuildLink(options.LinkTarget, target, ""))
 	}
 	b.WriteString("This module is necessary because " + reference + " is imported in")
 
diff --git a/internal/lsp/progress.go b/internal/lsp/progress.go
index 4d18fd8..a8894f8 100644
--- a/internal/lsp/progress.go
+++ b/internal/lsp/progress.go
@@ -8,6 +8,7 @@
 	"context"
 	"math/rand"
 	"strconv"
+	"strings"
 	"sync"
 
 	"golang.org/x/tools/internal/event"
@@ -176,6 +177,7 @@
 		// to send incremental messages.
 		return
 	}
+	message = strings.TrimSuffix(message, "\n")
 	err := wd.client.Progress(wd.ctx, &protocol.ProgressParams{
 		Token: wd.token,
 		Value: &protocol.WorkDoneProgressReport{
diff --git a/internal/lsp/semantic.go b/internal/lsp/semantic.go
index b669fab..48700d2 100644
--- a/internal/lsp/semantic.go
+++ b/internal/lsp/semantic.go
@@ -126,8 +126,6 @@
 	tokOperator  tokenType = "operator"
 )
 
-var lastPosition token.Position
-
 func (e *encoded) token(start token.Pos, leng int, typ tokenType, mods []string) {
 	if start == 0 {
 		e.unexpected("token at token.NoPos")
diff --git a/internal/lsp/server.go b/internal/lsp/server.go
index c2f5004..905a408 100644
--- a/internal/lsp/server.go
+++ b/internal/lsp/server.go
@@ -96,13 +96,19 @@
 	gcOptimizationDetailsMu sync.Mutex
 	gcOptimizationDetails   map[span.URI]struct{}
 
-	// diagnosticsSema limits the concurrency of diagnostics runs, which can be expensive.
+	// diagnosticsSema limits the concurrency of diagnostics runs, which can be
+	// expensive.
 	diagnosticsSema chan struct{}
 
 	progress *progressTracker
 
 	// debouncer is used for debouncing diagnostics.
 	debouncer *debouncer
+
+	// When the workspace fails to load, we show its status through a progress
+	// report with an error message.
+	criticalErrorStatusMu sync.Mutex
+	criticalErrorStatus   *workDone
 }
 
 // sentDiagnostics is used to cache diagnostics that have been sent for a given file.
diff --git a/internal/lsp/source/api_json.go b/internal/lsp/source/api_json.go
index de5493f..af26cec 100755
--- a/internal/lsp/source/api_json.go
+++ b/internal/lsp/source/api_json.go
@@ -2,4 +2,4 @@
 
 package source
 
-const GeneratedAPIJSON = "{\"Options\":{\"Debugging\":[{\"Name\":\"verboseOutput\",\"Type\":\"bool\",\"Doc\":\"verboseOutput enables additional debug logging.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"completionBudget\",\"Type\":\"time.Duration\",\"Doc\":\"completionBudget is the soft latency goal for completion requests. Most\\nrequests finish in a couple milliseconds, but in some cases deep\\ncompletions can take much longer. As we use up our budget we\\ndynamically reduce the search scope to ensure we return timely\\nresults. Zero means unlimited.\\n\",\"EnumValues\":null,\"Default\":\"\\\"100ms\\\"\"}],\"Experimental\":[{\"Name\":\"analyses\",\"Type\":\"map[string]bool\",\"Doc\":\"analyses specify analyses that the user would like to enable or disable.\\nA map of the names of analysis passes that should be enabled/disabled.\\nA full list of analyzers that gopls uses can be found [here](analyzers.md)\\n\\nExample Usage:\\n```json5\\n...\\n\\\"analyses\\\": {\\n  \\\"unreachable\\\": false, // Disable the unreachable analyzer.\\n  \\\"unusedparams\\\": true  // Enable the unusedparams analyzer.\\n}\\n...\\n```\\n\",\"EnumValues\":null,\"Default\":\"{}\"},{\"Name\":\"codelens\",\"Type\":\"map[string]bool\",\"Doc\":\"codelens overrides the enabled/disabled state of code lenses. See the \\\"Code Lenses\\\"\\nsection of settings.md for the list of supported lenses.\\n\\nExample Usage:\\n```json5\\n\\\"gopls\\\": {\\n...\\n  \\\"codelens\\\": {\\n    \\\"generate\\\": false,  // Don't show the `go generate` lens.\\n    \\\"gc_details\\\": true  // Show a code lens toggling the display of gc's choices.\\n  }\\n...\\n}\\n```\\n\",\"EnumValues\":null,\"Default\":\"{\\\"gc_details\\\":false,\\\"generate\\\":true,\\\"regenerate_cgo\\\":true,\\\"tidy\\\":true,\\\"upgrade_dependency\\\":true,\\\"vendor\\\":true}\"},{\"Name\":\"completionDocumentation\",\"Type\":\"bool\",\"Doc\":\"completionDocumentation enables documentation with completion results.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"completeUnimported\",\"Type\":\"bool\",\"Doc\":\"completeUnimported enables completion for packages that you do not currently import.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"deepCompletion\",\"Type\":\"bool\",\"Doc\":\"deepCompletion enables the ability to return completions from deep inside relevant entities, rather than just the locally accessible ones.\\n\\nConsider this example:\\n\\n```go\\npackage main\\n\\nimport \\\"fmt\\\"\\n\\ntype wrapString struct {\\n    str string\\n}\\n\\nfunc main() {\\n    x := wrapString{\\\"hello world\\\"}\\n    fmt.Printf(\\u003c\\u003e)\\n}\\n```\\n\\nAt the location of the `\\u003c\\u003e` in this program, deep completion would suggest the result `x.str`.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"matcher\",\"Type\":\"enum\",\"Doc\":\"matcher sets the algorithm that is used when calculating completion candidates.\\n\",\"EnumValues\":[{\"Value\":\"\\\"CaseInsensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"CaseSensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Fuzzy\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"Fuzzy\\\"\"},{\"Name\":\"annotations\",\"Type\":\"map[string]bool\",\"Doc\":\"annotations suppress various kinds of optimization diagnostics\\nthat would be reported by the gc_details command.\\n * noNilcheck suppresses display of nilchecks.\\n * noEscape suppresses escape choices.\\n * noInline suppresses inlining choices.\\n * noBounds suppresses bounds checking diagnostics.\\n\",\"EnumValues\":null,\"Default\":\"{}\"},{\"Name\":\"staticcheck\",\"Type\":\"bool\",\"Doc\":\"staticcheck enables additional analyses from staticcheck.io.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"symbolMatcher\",\"Type\":\"enum\",\"Doc\":\"symbolMatcher sets the algorithm that is used when finding workspace symbols.\\n\",\"EnumValues\":[{\"Value\":\"\\\"CaseInsensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"CaseSensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Fuzzy\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"Fuzzy\\\"\"},{\"Name\":\"symbolStyle\",\"Type\":\"enum\",\"Doc\":\"symbolStyle controls how symbols are qualified in symbol responses.\\n\\nExample Usage:\\n```json5\\n\\\"gopls\\\": {\\n...\\n  \\\"symbolStyle\\\": \\\"dynamic\\\",\\n...\\n}\\n```\\n\",\"EnumValues\":[{\"Value\":\"\\\"Dynamic\\\"\",\"Doc\":\"`\\\"Dynamic\\\"` uses whichever qualifier results in the highest scoring\\nmatch for the given symbol query. Here a \\\"qualifier\\\" is any \\\"/\\\" or \\\".\\\"\\ndelimited suffix of the fully qualified symbol. i.e. \\\"to/pkg.Foo.Field\\\" or\\njust \\\"Foo.Field\\\".\\n\"},{\"Value\":\"\\\"Full\\\"\",\"Doc\":\"`\\\"Full\\\"` is fully qualified symbols, i.e.\\n\\\"path/to/pkg.Foo.Field\\\".\\n\"},{\"Value\":\"\\\"Package\\\"\",\"Doc\":\"`\\\"Package\\\"` is package qualified symbols i.e.\\n\\\"pkg.Foo.Field\\\".\\n\"}],\"Default\":\"\\\"Package\\\"\"},{\"Name\":\"linksInHover\",\"Type\":\"bool\",\"Doc\":\"linksInHover toggles the presence of links to documentation in hover.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"tempModfile\",\"Type\":\"bool\",\"Doc\":\"tempModfile controls the use of the -modfile flag in Go 1.14.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"importShortcut\",\"Type\":\"enum\",\"Doc\":\"importShortcut specifies whether import statements should link to\\ndocumentation or go to definitions.\\n\",\"EnumValues\":[{\"Value\":\"\\\"Both\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Definition\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Link\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"Both\\\"\"},{\"Name\":\"verboseWorkDoneProgress\",\"Type\":\"bool\",\"Doc\":\"verboseWorkDoneProgress controls whether the LSP server should send\\nprogress reports for all work done outside the scope of an RPC.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"semanticTokens\",\"Type\":\"bool\",\"Doc\":\"semanticTokens controls whether the LSP server will send\\nsemantic tokens to the client.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"expandWorkspaceToModule\",\"Type\":\"bool\",\"Doc\":\"expandWorkspaceToModule instructs `gopls` to expand the scope of the workspace to include the\\nmodules containing the workspace folders. Set this to false to avoid loading\\nyour entire module. This is particularly useful for those working in a monorepo.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"experimentalWorkspaceModule\",\"Type\":\"bool\",\"Doc\":\"experimentalWorkspaceModule opts a user into the experimental support\\nfor multi-module workspaces.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"experimentalDiagnosticsDelay\",\"Type\":\"time.Duration\",\"Doc\":\"experimentalDiagnosticsDelay controls the amount of time that gopls waits\\nafter the most recent file modification before computing deep diagnostics.\\nSimple diagnostics (parsing and type-checking) are always run immediately\\non recently modified packages.\\n\\nThis option must be set to a valid duration string, for example `\\\"250ms\\\"`.\\n\",\"EnumValues\":null,\"Default\":\"\\\"0s\\\"\"},{\"Name\":\"experimentalPackageCacheKey\",\"Type\":\"bool\",\"Doc\":\"experimentalPackageCacheKey controls whether to use a coarser cache key\\nfor package type information to increase cache hits. This setting removes\\nthe user's environment, build flags, and working directory from the cache\\nkey, which should be a safe change as all relevant inputs into the type\\nchecking pass are already hashed into the key. This is temporarily guarded\\nby an experiment because caching behavior is subtle and difficult to\\ncomprehensively test.\\n\",\"EnumValues\":null,\"Default\":\"false\"}],\"User\":[{\"Name\":\"buildFlags\",\"Type\":\"[]string\",\"Doc\":\"buildFlags is the set of flags passed on to the build system when invoked.\\nIt is applied to queries like `go list`, which is used when discovering files.\\nThe most common use is to set `-tags`.\\n\",\"EnumValues\":null,\"Default\":\"[]\"},{\"Name\":\"env\",\"Type\":\"map[string]string\",\"Doc\":\"env adds environment variables to external commands run by `gopls`, most notably `go list`.\\n\",\"EnumValues\":null,\"Default\":\"{}\"},{\"Name\":\"hoverKind\",\"Type\":\"enum\",\"Doc\":\"hoverKind controls the information that appears in the hover text.\\nSingleLine and Structured are intended for use only by authors of editor plugins.\\n\",\"EnumValues\":[{\"Value\":\"\\\"FullDocumentation\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"NoDocumentation\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"SingleLine\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Structured\\\"\",\"Doc\":\"`\\\"Structured\\\"` is an experimental setting that returns a structured hover format.\\nThis format separates the signature from the documentation, so that the client\\ncan do more manipulation of these fields.\\n\\nThis should only be used by clients that support this behavior.\\n\"},{\"Value\":\"\\\"SynopsisDocumentation\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"FullDocumentation\\\"\"},{\"Name\":\"usePlaceholders\",\"Type\":\"bool\",\"Doc\":\"placeholders enables placeholders for function parameters or struct fields in completion responses.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"linkTarget\",\"Type\":\"string\",\"Doc\":\"linkTarget controls where documentation links go.\\nIt might be one of:\\n\\n* `\\\"godoc.org\\\"`\\n* `\\\"pkg.go.dev\\\"`\\n\\nIf company chooses to use its own `godoc.org`, its address can be used as well.\\n\",\"EnumValues\":null,\"Default\":\"\\\"pkg.go.dev\\\"\"},{\"Name\":\"local\",\"Type\":\"string\",\"Doc\":\"local is the equivalent of the `goimports -local` flag, which puts imports beginning with this string after 3rd-party packages.\\nIt should be the prefix of the import path whose imports should be grouped separately.\\n\",\"EnumValues\":null,\"Default\":\"\\\"\\\"\"},{\"Name\":\"gofumpt\",\"Type\":\"bool\",\"Doc\":\"gofumpt indicates if we should run gofumpt formatting.\\n\",\"EnumValues\":null,\"Default\":\"false\"}]},\"Commands\":[{\"Command\":\"gopls.generate\",\"Title\":\"Run go generate\",\"Doc\":\"generate runs `go generate` for a given directory.\\n\"},{\"Command\":\"gopls.fill_struct\",\"Title\":\"Fill struct\",\"Doc\":\"fill_struct is a gopls command to fill a struct with default\\nvalues.\\n\"},{\"Command\":\"gopls.regenerate_cgo\",\"Title\":\"Regenerate cgo\",\"Doc\":\"regenerate_cgo regenerates cgo definitions.\\n\"},{\"Command\":\"gopls.test\",\"Title\":\"Run test(s)\",\"Doc\":\"test runs `go test` for a specific test function.\\n\"},{\"Command\":\"gopls.tidy\",\"Title\":\"Run go mod tidy\",\"Doc\":\"tidy runs `go mod tidy` for a module.\\n\"},{\"Command\":\"gopls.undeclared_name\",\"Title\":\"Undeclared name\",\"Doc\":\"undeclared_name adds a variable declaration for an undeclared\\nname.\\n\"},{\"Command\":\"gopls.add_dependency\",\"Title\":\"Add dependency\",\"Doc\":\"add_dependency adds a dependency.\\n\"},{\"Command\":\"gopls.upgrade_dependency\",\"Title\":\"Upgrade dependency\",\"Doc\":\"upgrade_dependency upgrades a dependency.\\n\"},{\"Command\":\"gopls.remove_dependency\",\"Title\":\"Remove dependency\",\"Doc\":\"remove_dependency removes a dependency.\\n\"},{\"Command\":\"gopls.vendor\",\"Title\":\"Run go mod vendor\",\"Doc\":\"vendor runs `go mod vendor` for a module.\\n\"},{\"Command\":\"gopls.extract_variable\",\"Title\":\"Extract to variable\",\"Doc\":\"extract_variable extracts an expression to a variable.\\n\"},{\"Command\":\"gopls.extract_function\",\"Title\":\"Extract to function\",\"Doc\":\"extract_function extracts statements to a function.\\n\"},{\"Command\":\"gopls.gc_details\",\"Title\":\"Toggle gc_details\",\"Doc\":\"gc_details controls calculation of gc annotations.\\n\"},{\"Command\":\"gopls.generate_gopls_mod\",\"Title\":\"Generate gopls.mod\",\"Doc\":\"generate_gopls_mod (re)generates the gopls.mod file.\\n\"}],\"Lenses\":[{\"Lens\":\"generate\",\"Title\":\"Run go generate\",\"Doc\":\"generate runs `go generate` for a given directory.\\n\"},{\"Lens\":\"regenerate_cgo\",\"Title\":\"Regenerate cgo\",\"Doc\":\"regenerate_cgo regenerates cgo definitions.\\n\"},{\"Lens\":\"test\",\"Title\":\"Run test(s)\",\"Doc\":\"test runs `go test` for a specific test function.\\n\"},{\"Lens\":\"tidy\",\"Title\":\"Run go mod tidy\",\"Doc\":\"tidy runs `go mod tidy` for a module.\\n\"},{\"Lens\":\"upgrade_dependency\",\"Title\":\"Upgrade dependency\",\"Doc\":\"upgrade_dependency upgrades a dependency.\\n\"},{\"Lens\":\"vendor\",\"Title\":\"Run go mod vendor\",\"Doc\":\"vendor runs `go mod vendor` for a module.\\n\"},{\"Lens\":\"gc_details\",\"Title\":\"Toggle gc_details\",\"Doc\":\"gc_details controls calculation of gc annotations.\\n\"}]}"
+const GeneratedAPIJSON = "{\"Options\":{\"Debugging\":[{\"Name\":\"verboseOutput\",\"Type\":\"bool\",\"Doc\":\"verboseOutput enables additional debug logging.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"completionBudget\",\"Type\":\"time.Duration\",\"Doc\":\"completionBudget is the soft latency goal for completion requests. Most\\nrequests finish in a couple milliseconds, but in some cases deep\\ncompletions can take much longer. As we use up our budget we\\ndynamically reduce the search scope to ensure we return timely\\nresults. Zero means unlimited.\\n\",\"EnumValues\":null,\"Default\":\"\\\"100ms\\\"\"}],\"Experimental\":[{\"Name\":\"analyses\",\"Type\":\"map[string]bool\",\"Doc\":\"analyses specify analyses that the user would like to enable or disable.\\nA map of the names of analysis passes that should be enabled/disabled.\\nA full list of analyzers that gopls uses can be found [here](analyzers.md)\\n\\nExample Usage:\\n```json5\\n...\\n\\\"analyses\\\": {\\n  \\\"unreachable\\\": false, // Disable the unreachable analyzer.\\n  \\\"unusedparams\\\": true  // Enable the unusedparams analyzer.\\n}\\n...\\n```\\n\",\"EnumValues\":null,\"Default\":\"{}\"},{\"Name\":\"codelens\",\"Type\":\"map[string]bool\",\"Doc\":\"codelens overrides the enabled/disabled state of code lenses. See the \\\"Code Lenses\\\"\\nsection of settings.md for the list of supported lenses.\\n\\nExample Usage:\\n```json5\\n\\\"gopls\\\": {\\n...\\n  \\\"codelens\\\": {\\n    \\\"generate\\\": false,  // Don't show the `go generate` lens.\\n    \\\"gc_details\\\": true  // Show a code lens toggling the display of gc's choices.\\n  }\\n...\\n}\\n```\\n\",\"EnumValues\":null,\"Default\":\"{\\\"gc_details\\\":false,\\\"generate\\\":true,\\\"regenerate_cgo\\\":true,\\\"tidy\\\":true,\\\"upgrade_dependency\\\":true,\\\"vendor\\\":true}\"},{\"Name\":\"completionDocumentation\",\"Type\":\"bool\",\"Doc\":\"completionDocumentation enables documentation with completion results.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"completeUnimported\",\"Type\":\"bool\",\"Doc\":\"completeUnimported enables completion for packages that you do not currently import.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"deepCompletion\",\"Type\":\"bool\",\"Doc\":\"deepCompletion enables the ability to return completions from deep inside relevant entities, rather than just the locally accessible ones.\\n\\nConsider this example:\\n\\n```go\\npackage main\\n\\nimport \\\"fmt\\\"\\n\\ntype wrapString struct {\\n    str string\\n}\\n\\nfunc main() {\\n    x := wrapString{\\\"hello world\\\"}\\n    fmt.Printf(\\u003c\\u003e)\\n}\\n```\\n\\nAt the location of the `\\u003c\\u003e` in this program, deep completion would suggest the result `x.str`.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"matcher\",\"Type\":\"enum\",\"Doc\":\"matcher sets the algorithm that is used when calculating completion candidates.\\n\",\"EnumValues\":[{\"Value\":\"\\\"CaseInsensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"CaseSensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Fuzzy\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"Fuzzy\\\"\"},{\"Name\":\"annotations\",\"Type\":\"map[string]bool\",\"Doc\":\"annotations suppress various kinds of optimization diagnostics\\nthat would be reported by the gc_details command.\\n * noNilcheck suppresses display of nilchecks.\\n * noEscape suppresses escape choices.\\n * noInline suppresses inlining choices.\\n * noBounds suppresses bounds checking diagnostics.\\n\",\"EnumValues\":null,\"Default\":\"{}\"},{\"Name\":\"staticcheck\",\"Type\":\"bool\",\"Doc\":\"staticcheck enables additional analyses from staticcheck.io.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"symbolMatcher\",\"Type\":\"enum\",\"Doc\":\"symbolMatcher sets the algorithm that is used when finding workspace symbols.\\n\",\"EnumValues\":[{\"Value\":\"\\\"CaseInsensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"CaseSensitive\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Fuzzy\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"Fuzzy\\\"\"},{\"Name\":\"symbolStyle\",\"Type\":\"enum\",\"Doc\":\"symbolStyle controls how symbols are qualified in symbol responses.\\n\\nExample Usage:\\n```json5\\n\\\"gopls\\\": {\\n...\\n  \\\"symbolStyle\\\": \\\"dynamic\\\",\\n...\\n}\\n```\\n\",\"EnumValues\":[{\"Value\":\"\\\"Dynamic\\\"\",\"Doc\":\"`\\\"Dynamic\\\"` uses whichever qualifier results in the highest scoring\\nmatch for the given symbol query. Here a \\\"qualifier\\\" is any \\\"/\\\" or \\\".\\\"\\ndelimited suffix of the fully qualified symbol. i.e. \\\"to/pkg.Foo.Field\\\" or\\njust \\\"Foo.Field\\\".\\n\"},{\"Value\":\"\\\"Full\\\"\",\"Doc\":\"`\\\"Full\\\"` is fully qualified symbols, i.e.\\n\\\"path/to/pkg.Foo.Field\\\".\\n\"},{\"Value\":\"\\\"Package\\\"\",\"Doc\":\"`\\\"Package\\\"` is package qualified symbols i.e.\\n\\\"pkg.Foo.Field\\\".\\n\"}],\"Default\":\"\\\"Package\\\"\"},{\"Name\":\"linksInHover\",\"Type\":\"bool\",\"Doc\":\"linksInHover toggles the presence of links to documentation in hover.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"tempModfile\",\"Type\":\"bool\",\"Doc\":\"tempModfile controls the use of the -modfile flag in Go 1.14.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"importShortcut\",\"Type\":\"enum\",\"Doc\":\"importShortcut specifies whether import statements should link to\\ndocumentation or go to definitions.\\n\",\"EnumValues\":[{\"Value\":\"\\\"Both\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Definition\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Link\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"Both\\\"\"},{\"Name\":\"verboseWorkDoneProgress\",\"Type\":\"bool\",\"Doc\":\"verboseWorkDoneProgress controls whether the LSP server should send\\nprogress reports for all work done outside the scope of an RPC.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"semanticTokens\",\"Type\":\"bool\",\"Doc\":\"semanticTokens controls whether the LSP server will send\\nsemantic tokens to the client.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"expandWorkspaceToModule\",\"Type\":\"bool\",\"Doc\":\"expandWorkspaceToModule instructs `gopls` to adjust the scope of the\\nworkspace to find the best available module root. `gopls` first looks for\\na go.mod file in any parent directory of the workspace folder, expanding\\nthe scope to that directory if it exists. If no viable parent directory is\\nfound, gopls will check if there is exactly one child directory containing\\na go.mod file, narrowing the scope to that directory if it exists.\\n\",\"EnumValues\":null,\"Default\":\"true\"},{\"Name\":\"experimentalWorkspaceModule\",\"Type\":\"bool\",\"Doc\":\"experimentalWorkspaceModule opts a user into the experimental support\\nfor multi-module workspaces.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"experimentalDiagnosticsDelay\",\"Type\":\"time.Duration\",\"Doc\":\"experimentalDiagnosticsDelay controls the amount of time that gopls waits\\nafter the most recent file modification before computing deep diagnostics.\\nSimple diagnostics (parsing and type-checking) are always run immediately\\non recently modified packages.\\n\\nThis option must be set to a valid duration string, for example `\\\"250ms\\\"`.\\n\",\"EnumValues\":null,\"Default\":\"\\\"0s\\\"\"},{\"Name\":\"experimentalPackageCacheKey\",\"Type\":\"bool\",\"Doc\":\"experimentalPackageCacheKey controls whether to use a coarser cache key\\nfor package type information to increase cache hits. This setting removes\\nthe user's environment, build flags, and working directory from the cache\\nkey, which should be a safe change as all relevant inputs into the type\\nchecking pass are already hashed into the key. This is temporarily guarded\\nby an experiment because caching behavior is subtle and difficult to\\ncomprehensively test.\\n\",\"EnumValues\":null,\"Default\":\"true\"}],\"User\":[{\"Name\":\"buildFlags\",\"Type\":\"[]string\",\"Doc\":\"buildFlags is the set of flags passed on to the build system when invoked.\\nIt is applied to queries like `go list`, which is used when discovering files.\\nThe most common use is to set `-tags`.\\n\",\"EnumValues\":null,\"Default\":\"[]\"},{\"Name\":\"env\",\"Type\":\"map[string]string\",\"Doc\":\"env adds environment variables to external commands run by `gopls`, most notably `go list`.\\n\",\"EnumValues\":null,\"Default\":\"{}\"},{\"Name\":\"hoverKind\",\"Type\":\"enum\",\"Doc\":\"hoverKind controls the information that appears in the hover text.\\nSingleLine and Structured are intended for use only by authors of editor plugins.\\n\",\"EnumValues\":[{\"Value\":\"\\\"FullDocumentation\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"NoDocumentation\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"SingleLine\\\"\",\"Doc\":\"\"},{\"Value\":\"\\\"Structured\\\"\",\"Doc\":\"`\\\"Structured\\\"` is an experimental setting that returns a structured hover format.\\nThis format separates the signature from the documentation, so that the client\\ncan do more manipulation of these fields.\\n\\nThis should only be used by clients that support this behavior.\\n\"},{\"Value\":\"\\\"SynopsisDocumentation\\\"\",\"Doc\":\"\"}],\"Default\":\"\\\"FullDocumentation\\\"\"},{\"Name\":\"usePlaceholders\",\"Type\":\"bool\",\"Doc\":\"placeholders enables placeholders for function parameters or struct fields in completion responses.\\n\",\"EnumValues\":null,\"Default\":\"false\"},{\"Name\":\"linkTarget\",\"Type\":\"string\",\"Doc\":\"linkTarget controls where documentation links go.\\nIt might be one of:\\n\\n* `\\\"godoc.org\\\"`\\n* `\\\"pkg.go.dev\\\"`\\n\\nIf company chooses to use its own `godoc.org`, its address can be used as well.\\n\",\"EnumValues\":null,\"Default\":\"\\\"pkg.go.dev\\\"\"},{\"Name\":\"local\",\"Type\":\"string\",\"Doc\":\"local is the equivalent of the `goimports -local` flag, which puts imports beginning with this string after 3rd-party packages.\\nIt should be the prefix of the import path whose imports should be grouped separately.\\n\",\"EnumValues\":null,\"Default\":\"\\\"\\\"\"},{\"Name\":\"gofumpt\",\"Type\":\"bool\",\"Doc\":\"gofumpt indicates if we should run gofumpt formatting.\\n\",\"EnumValues\":null,\"Default\":\"false\"}]},\"Commands\":[{\"Command\":\"gopls.generate\",\"Title\":\"Run go generate\",\"Doc\":\"generate runs `go generate` for a given directory.\\n\"},{\"Command\":\"gopls.fill_struct\",\"Title\":\"Fill struct\",\"Doc\":\"fill_struct is a gopls command to fill a struct with default\\nvalues.\\n\"},{\"Command\":\"gopls.regenerate_cgo\",\"Title\":\"Regenerate cgo\",\"Doc\":\"regenerate_cgo regenerates cgo definitions.\\n\"},{\"Command\":\"gopls.test\",\"Title\":\"Run test(s)\",\"Doc\":\"test runs `go test` for a specific test function.\\n\"},{\"Command\":\"gopls.tidy\",\"Title\":\"Run go mod tidy\",\"Doc\":\"tidy runs `go mod tidy` for a module.\\n\"},{\"Command\":\"gopls.undeclared_name\",\"Title\":\"Undeclared name\",\"Doc\":\"undeclared_name adds a variable declaration for an undeclared\\nname.\\n\"},{\"Command\":\"gopls.add_dependency\",\"Title\":\"Add dependency\",\"Doc\":\"add_dependency adds a dependency.\\n\"},{\"Command\":\"gopls.upgrade_dependency\",\"Title\":\"Upgrade dependency\",\"Doc\":\"upgrade_dependency upgrades a dependency.\\n\"},{\"Command\":\"gopls.remove_dependency\",\"Title\":\"Remove dependency\",\"Doc\":\"remove_dependency removes a dependency.\\n\"},{\"Command\":\"gopls.vendor\",\"Title\":\"Run go mod vendor\",\"Doc\":\"vendor runs `go mod vendor` for a module.\\n\"},{\"Command\":\"gopls.extract_variable\",\"Title\":\"Extract to variable\",\"Doc\":\"extract_variable extracts an expression to a variable.\\n\"},{\"Command\":\"gopls.extract_function\",\"Title\":\"Extract to function\",\"Doc\":\"extract_function extracts statements to a function.\\n\"},{\"Command\":\"gopls.gc_details\",\"Title\":\"Toggle gc_details\",\"Doc\":\"gc_details controls calculation of gc annotations.\\n\"},{\"Command\":\"gopls.generate_gopls_mod\",\"Title\":\"Generate gopls.mod\",\"Doc\":\"generate_gopls_mod (re)generates the gopls.mod file.\\n\"}],\"Lenses\":[{\"Lens\":\"generate\",\"Title\":\"Run go generate\",\"Doc\":\"generate runs `go generate` for a given directory.\\n\"},{\"Lens\":\"regenerate_cgo\",\"Title\":\"Regenerate cgo\",\"Doc\":\"regenerate_cgo regenerates cgo definitions.\\n\"},{\"Lens\":\"test\",\"Title\":\"Run test(s)\",\"Doc\":\"test runs `go test` for a specific test function.\\n\"},{\"Lens\":\"tidy\",\"Title\":\"Run go mod tidy\",\"Doc\":\"tidy runs `go mod tidy` for a module.\\n\"},{\"Lens\":\"upgrade_dependency\",\"Title\":\"Upgrade dependency\",\"Doc\":\"upgrade_dependency upgrades a dependency.\\n\"},{\"Lens\":\"vendor\",\"Title\":\"Run go mod vendor\",\"Doc\":\"vendor runs `go mod vendor` for a module.\\n\"},{\"Lens\":\"gc_details\",\"Title\":\"Toggle gc_details\",\"Doc\":\"gc_details controls calculation of gc annotations.\\n\"}]}"
diff --git a/internal/lsp/source/completion/completion.go b/internal/lsp/source/completion/completion.go
index 78dac5b..b87154a 100644
--- a/internal/lsp/source/completion/completion.go
+++ b/internal/lsp/source/completion/completion.go
@@ -1522,6 +1522,7 @@
 		}
 	}
 
+	deltaScore := 0.0001
 	switch t := clInfo.clType.(type) {
 	case *types.Struct:
 		for i := 0; i < t.NumFields(); i++ {
@@ -1529,7 +1530,7 @@
 			if !addedFields[field] {
 				c.deepState.enqueue(candidate{
 					obj:   field,
-					score: highScore,
+					score: highScore - float64(i)*deltaScore,
 				})
 			}
 		}
diff --git a/internal/lsp/source/completion/deep_completion.go b/internal/lsp/source/completion/deep_completion.go
index 61b29c3..71a6726 100644
--- a/internal/lsp/source/completion/deep_completion.go
+++ b/internal/lsp/source/completion/deep_completion.go
@@ -121,12 +121,16 @@
 		cand := c.deepState.dequeue()
 		obj := cand.obj
 
+		if obj == nil {
+			continue
+		}
+
 		// At the top level, dedupe by object.
 		if len(cand.path) == 0 {
-			if c.seen[cand.obj] {
+			if c.seen[obj] {
 				continue
 			}
-			c.seen[cand.obj] = true
+			c.seen[obj] = true
 		}
 
 		// If obj is not accessible because it lives in another package and is
diff --git a/internal/lsp/source/format.go b/internal/lsp/source/format.go
index f4c6957..522f522 100644
--- a/internal/lsp/source/format.go
+++ b/internal/lsp/source/format.go
@@ -14,6 +14,7 @@
 	"go/parser"
 	"go/token"
 	"strings"
+	"text/scanner"
 
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/imports"
@@ -228,12 +229,17 @@
 	}
 	for _, c := range f.Comments {
 		if end := tok.Offset(c.End()); end > importEnd {
-			// Work-around golang/go#41197: For multi-line comments add +2 to
-			// the offset. The end position does not account for the */ at the
-			// end.
+			startLine := tok.Position(c.Pos()).Line
 			endLine := tok.Position(c.End()).Line
-			if end+2 <= tok.Size() && tok.Position(tok.Pos(end+2)).Line == endLine {
-				end += 2
+
+			// Work around golang/go#41197 by checking if the comment might
+			// contain "\r", and if so, find the actual end position of the
+			// comment by scanning the content of the file.
+			startOffset := tok.Offset(c.Pos())
+			if startLine != endLine && bytes.Contains(src[startOffset:], []byte("\r")) {
+				if commentEnd := scanForCommentEnd(tok, src[startOffset:]); commentEnd > 0 {
+					end = startOffset + commentEnd
+				}
 			}
 			importEnd = maybeAdjustToLineEnd(tok.Pos(end), true)
 		}
@@ -244,6 +250,20 @@
 	return string(src[:importEnd])
 }
 
+// scanForCommentEnd returns the offset of the end of the multi-line comment
+// at the start of the given byte slice.
+func scanForCommentEnd(tok *token.File, src []byte) int {
+	var s scanner.Scanner
+	s.Init(bytes.NewReader(src))
+	s.Mode ^= scanner.SkipComments
+
+	t := s.Scan()
+	if t == scanner.Comment {
+		return s.Pos().Offset
+	}
+	return 0
+}
+
 func computeTextEdits(ctx context.Context, snapshot Snapshot, pgf *ParsedGoFile, formatted string) ([]protocol.TextEdit, error) {
 	_, done := event.Start(ctx, "source.computeTextEdits")
 	defer done()
diff --git a/internal/lsp/source/hover.go b/internal/lsp/source/hover.go
index be6edb1..1e3e789 100644
--- a/internal/lsp/source/hover.go
+++ b/internal/lsp/source/hover.go
@@ -33,15 +33,20 @@
 	// FullDocumentation is the symbol's full documentation.
 	FullDocumentation string `json:"fullDocumentation"`
 
-	// ImportPath is the import path for the package containing the given symbol.
-	ImportPath string
+	// LinkPath is the pkg.go.dev link for the given symbol.
+	// For example, the "go/ast" part of "pkg.go.dev/go/ast#Node".
+	LinkPath string `json:"linkPath"`
 
-	// Link is the pkg.go.dev anchor for the given symbol.
-	// For example, "go/ast#Node".
-	Link string `json:"link"`
+	// LinkAnchor is the pkg.go.dev link anchor for the given symbol.
+	// For example, the "Node" part of "pkg.go.dev/go/ast#Node".
+	LinkAnchor string `json:"linkAnchor"`
 
-	// SymbolName is the types.Object.Name for the given symbol.
-	SymbolName string
+	// importPath is the import path for the package containing the given
+	// symbol.
+	importPath string
+
+	// symbolName is the types.Object.Name for the given symbol.
+	symbolName string
 
 	source  interface{}
 	comment *ast.CommentGroup
@@ -65,8 +70,8 @@
 		return nil, err
 	}
 	// See golang/go#36998: don't link to modules matching GOPRIVATE.
-	if snapshot.View().IsGoPrivatePath(h.ImportPath) {
-		h.Link = ""
+	if snapshot.View().IsGoPrivatePath(h.importPath) {
+		h.LinkPath = ""
 	}
 	hover, err := FormatHover(h, snapshot.View().Options())
 	if err != nil {
@@ -115,38 +120,37 @@
 	if obj := i.Declaration.obj; obj != nil {
 		h.SingleLine = objectString(obj, i.qf)
 	}
-	h.ImportPath, h.Link, h.SymbolName = pathLinkAndSymbolName(i)
-
-	return h, nil
-}
-
-func pathLinkAndSymbolName(i *IdentifierInfo) (string, string, string) {
 	obj := i.Declaration.obj
 	if obj == nil {
-		return "", "", ""
+		return h, nil
 	}
 	switch obj := obj.(type) {
 	case *types.PkgName:
-		path := obj.Imported().Path()
-		link := path
-		if mod, version, ok := moduleAtVersion(path, i); ok {
-			link = strings.Replace(path, mod, mod+"@"+version, 1)
+		h.importPath = obj.Imported().Path()
+		h.LinkPath = h.importPath
+		h.symbolName = obj.Name()
+		if mod, version, ok := moduleAtVersion(h.LinkPath, i); ok {
+			h.LinkPath = strings.Replace(h.LinkPath, mod, mod+"@"+version, 1)
 		}
-		return path, link, obj.Name()
+		return h, nil
 	case *types.Builtin:
-		return "builtin", fmt.Sprintf("builtin#%s", obj.Name()), obj.Name()
+		h.importPath = "builtin"
+		h.LinkPath = h.importPath
+		h.LinkAnchor = obj.Name()
+		h.symbolName = h.LinkAnchor
+		return h, nil
 	}
 	// Check if the identifier is test-only (and is therefore not part of a
 	// package's API). This is true if the request originated in a test package,
 	// and if the declaration is also found in the same test package.
 	if i.pkg != nil && obj.Pkg() != nil && i.pkg.ForTest() != "" {
 		if _, err := i.pkg.File(i.Declaration.MappedRange[0].URI()); err == nil {
-			return "", "", ""
+			return h, nil
 		}
 	}
 	// Don't return links for other unexported types.
 	if !obj.Exported() {
-		return "", "", ""
+		return h, nil
 	}
 	var rTypeName string
 	switch obj := obj.(type) {
@@ -161,7 +165,7 @@
 	case *types.Func:
 		typ, ok := obj.Type().(*types.Signature)
 		if !ok {
-			return "", "", ""
+			return h, nil
 		}
 		if r := typ.Recv(); r != nil {
 			switch rtyp := Deref(r.Type()).(type) {
@@ -175,7 +179,7 @@
 					if named, ok := i.enclosing.(*types.Named); ok && named.Obj().Exported() {
 						rTypeName = named.Obj().Name()
 					} else {
-						return "", "", ""
+						return h, nil
 					}
 				} else {
 					rTypeName = rtyp.Obj().Name()
@@ -183,20 +187,20 @@
 			}
 		}
 	}
-	path := obj.Pkg().Path()
-	link := path
-	if mod, version, ok := moduleAtVersion(path, i); ok {
-		link = strings.Replace(path, mod, mod+"@"+version, 1)
+	h.importPath = obj.Pkg().Path()
+	h.LinkPath = h.importPath
+	if mod, version, ok := moduleAtVersion(h.LinkPath, i); ok {
+		h.LinkPath = strings.Replace(h.LinkPath, mod, mod+"@"+version, 1)
 	}
 	if rTypeName != "" {
-		link = fmt.Sprintf("%s#%s.%s", link, rTypeName, obj.Name())
-		symbol := fmt.Sprintf("(%s.%s).%s", obj.Pkg().Name(), rTypeName, obj.Name())
-		return path, link, symbol
+		h.LinkAnchor = fmt.Sprintf("%s.%s", rTypeName, obj.Name())
+		h.symbolName = fmt.Sprintf("(%s.%s).%s", obj.Pkg().Name(), rTypeName, obj.Name())
+		return h, nil
 	}
 	// For most cases, the link is "package/path#symbol".
-	link = fmt.Sprintf("%s#%s", link, obj.Name())
-	symbolName := fmt.Sprintf("%s.%s", obj.Pkg().Name(), obj.Name())
-	return path, link, symbolName
+	h.LinkAnchor = obj.Name()
+	h.symbolName = fmt.Sprintf("%s.%s", obj.Pkg().Name(), obj.Name())
+	return h, nil
 }
 
 func moduleAtVersion(path string, i *IdentifierInfo) (string, string, bool) {
@@ -404,13 +408,13 @@
 }
 
 func formatLink(h *HoverInformation, options *Options) string {
-	if !options.LinksInHover || options.LinkTarget == "" || h.Link == "" {
+	if !options.LinksInHover || options.LinkTarget == "" || h.LinkPath == "" {
 		return ""
 	}
-	plainLink := fmt.Sprintf("https://%s/%s", options.LinkTarget, h.Link)
+	plainLink := BuildLink(options.LinkTarget, h.LinkPath, h.LinkAnchor)
 	switch options.PreferredContentFormat {
 	case protocol.Markdown:
-		return fmt.Sprintf("[`%s` on %s](%s)", h.SymbolName, options.LinkTarget, plainLink)
+		return fmt.Sprintf("[`%s` on %s](%s)", h.symbolName, options.LinkTarget, plainLink)
 	case protocol.PlainText:
 		return ""
 	default:
@@ -418,6 +422,18 @@
 	}
 }
 
+// BuildLink constructs a link with the given target, path, and anchor.
+func BuildLink(target, path, anchor string) string {
+	link := fmt.Sprintf("https://%s/%s", target, path)
+	if target == "pkg.go.dev" {
+		link += "?utm_source=gopls"
+	}
+	if anchor == "" {
+		return link
+	}
+	return link + "#" + anchor
+}
+
 func formatDoc(doc string, options *Options) string {
 	if options.PreferredContentFormat == protocol.Markdown {
 		return CommentToMarkdown(doc)
diff --git a/internal/lsp/source/identifier.go b/internal/lsp/source/identifier.go
index 753d12b..362604e 100644
--- a/internal/lsp/source/identifier.go
+++ b/internal/lsp/source/identifier.go
@@ -157,14 +157,6 @@
 		enclosing: searchForEnclosing(pkg.GetTypesInfo(), path),
 	}
 
-	var wasEmbeddedField bool
-	for _, n := range path[1:] {
-		if field, ok := n.(*ast.Field); ok {
-			wasEmbeddedField = len(field.Names) == 0
-			break
-		}
-	}
-
 	result.Name = result.ident.Name
 	var err error
 	if result.MappedRange, err = posToMappedRange(snapshot, pkg, result.ident.Pos(), result.ident.End()); err != nil {
@@ -253,13 +245,12 @@
 		}
 	}
 
-	if wasEmbeddedField {
-		// The original position was on the embedded field declaration, so we
-		// try to dig out the type and jump to that instead.
-		if v, ok := result.Declaration.obj.(*types.Var); ok {
-			if typObj := typeToObject(v.Type()); typObj != nil {
-				result.Declaration.obj = typObj
-			}
+	// If the original position was an embedded field, we want to jump
+	// to the field's type definition, not the field's definition.
+	if v, ok := result.Declaration.obj.(*types.Var); ok && v.Embedded() {
+		// types.Info.Uses contains the embedded field's *types.TypeName.
+		if typeName := pkg.GetTypesInfo().Uses[ident]; typeName != nil {
+			result.Declaration.obj = typeName
 		}
 	}
 
diff --git a/internal/lsp/source/options.go b/internal/lsp/source/options.go
index 7126fb4..12e14d2 100644
--- a/internal/lsp/source/options.go
+++ b/internal/lsp/source/options.go
@@ -116,14 +116,15 @@
 					CommandUpgradeDependency.Name: true,
 					CommandVendor.Name:            true,
 				},
-				LinksInHover:            true,
-				CompleteUnimported:      true,
-				CompletionDocumentation: true,
-				DeepCompletion:          true,
-				ImportShortcut:          Both,
-				Matcher:                 Fuzzy,
-				SymbolMatcher:           SymbolFuzzy,
-				SymbolStyle:             PackageQualifiedSymbols,
+				LinksInHover:                true,
+				CompleteUnimported:          true,
+				CompletionDocumentation:     true,
+				DeepCompletion:              true,
+				ImportShortcut:              Both,
+				Matcher:                     Fuzzy,
+				SymbolMatcher:               SymbolFuzzy,
+				SymbolStyle:                 PackageQualifiedSymbols,
+				ExperimentalPackageCacheKey: true,
 			},
 			InternalOptions: InternalOptions{
 				LiteralCompletions: true,
@@ -354,9 +355,12 @@
 	// semantic tokens to the client.
 	SemanticTokens bool
 
-	// ExpandWorkspaceToModule instructs `gopls` to expand the scope of the workspace to include the
-	// modules containing the workspace folders. Set this to false to avoid loading
-	// your entire module. This is particularly useful for those working in a monorepo.
+	// ExpandWorkspaceToModule instructs `gopls` to adjust the scope of the
+	// workspace to find the best available module root. `gopls` first looks for
+	// a go.mod file in any parent directory of the workspace folder, expanding
+	// the scope to that directory if it exists. If no viable parent directory is
+	// found, gopls will check if there is exactly one child directory containing
+	// a go.mod file, narrowing the scope to that directory if it exists.
 	ExpandWorkspaceToModule bool
 
 	// ExperimentalWorkspaceModule opts a user into the experimental support
@@ -607,7 +611,6 @@
 // enableAllExperimentMaps.
 func (o *Options) enableAllExperiments() {
 	o.ExperimentalDiagnosticsDelay = 200 * time.Millisecond
-	o.ExperimentalPackageCacheKey = true
 	o.SymbolStyle = DynamicSymbols
 }
 
diff --git a/internal/lsp/source/util.go b/internal/lsp/source/util.go
index b3d87f9..1fffda5 100644
--- a/internal/lsp/source/util.go
+++ b/internal/lsp/source/util.go
@@ -443,31 +443,29 @@
 }
 
 // InDir checks whether path is in the file tree rooted at dir.
-// If so, InDir returns an equivalent path relative to dir.
-// If not, InDir returns an empty string.
 // InDir makes some effort to succeed even in the presence of symbolic links.
 //
 // Copied and slightly adjusted from go/src/cmd/go/internal/search/search.go.
 func InDir(dir, path string) bool {
-	if rel := inDirLex(path, dir); rel != "" {
+	if InDirLex(dir, path) {
 		return true
 	}
 	xpath, err := filepath.EvalSymlinks(path)
 	if err != nil || xpath == path {
 		xpath = ""
 	} else {
-		if rel := inDirLex(xpath, dir); rel != "" {
+		if InDirLex(dir, xpath) {
 			return true
 		}
 	}
 
 	xdir, err := filepath.EvalSymlinks(dir)
 	if err == nil && xdir != dir {
-		if rel := inDirLex(path, xdir); rel != "" {
+		if InDirLex(xdir, path) {
 			return true
 		}
 		if xpath != "" {
-			if rel := inDirLex(xpath, xdir); rel != "" {
+			if InDirLex(xdir, xpath) {
 				return true
 			}
 		}
@@ -475,43 +473,40 @@
 	return false
 }
 
-// Copied from go/src/cmd/go/internal/search/search.go.
-//
-// inDirLex is like inDir but only checks the lexical form of the file names.
+// InDirLex is like inDir but only checks the lexical form of the file names.
 // It does not consider symbolic links.
-// TODO(rsc): This is a copy of str.HasFilePathPrefix, modified to
-// return the suffix. Most uses of str.HasFilePathPrefix should probably
-// be calling InDir instead.
-func inDirLex(path, dir string) string {
+//
+// Copied from go/src/cmd/go/internal/search/search.go.
+func InDirLex(dir, path string) bool {
 	pv := strings.ToUpper(filepath.VolumeName(path))
 	dv := strings.ToUpper(filepath.VolumeName(dir))
 	path = path[len(pv):]
 	dir = dir[len(dv):]
 	switch {
 	default:
-		return ""
+		return false
 	case pv != dv:
-		return ""
+		return false
 	case len(path) == len(dir):
 		if path == dir {
-			return "."
+			return true
 		}
-		return ""
+		return false
 	case dir == "":
-		return path
+		return path != ""
 	case len(path) > len(dir):
 		if dir[len(dir)-1] == filepath.Separator {
 			if path[:len(dir)] == dir {
-				return path[len(dir):]
+				return path[len(dir):] != ""
 			}
-			return ""
+			return false
 		}
 		if path[len(dir)] == filepath.Separator && path[:len(dir)] == dir {
 			if len(path) == len(dir)+1 {
-				return "."
+				return true
 			}
-			return path[len(dir)+1:]
+			return path[len(dir)+1:] != ""
 		}
-		return ""
+		return false
 	}
 }
diff --git a/internal/lsp/source/view.go b/internal/lsp/source/view.go
index fa307df..89f4c6a 100644
--- a/internal/lsp/source/view.go
+++ b/internal/lsp/source/view.go
@@ -111,7 +111,7 @@
 
 	// ModTidy returns the results of `go mod tidy` for the module specified by
 	// the given go.mod file.
-	ModTidy(ctx context.Context, fh FileHandle) (*TidiedModule, error)
+	ModTidy(ctx context.Context, pm *ParsedModule) (*TidiedModule, error)
 
 	// GoModForFile returns the URI of the go.mod file for the given URI.
 	GoModForFile(ctx context.Context, uri span.URI) span.URI
@@ -179,8 +179,9 @@
 	// modified version of the user's go.mod file, e.g. `go mod tidy` used to
 	// generate diagnostics.
 	WriteTemporaryModFile
-	// ForTypeChecking is for packages.Load.
-	ForTypeChecking
+	// LoadWorkspace is for packages.Load, and other operations that should
+	// consider the whole workspace at once.
+	LoadWorkspace
 )
 
 // View represents a single workspace.
@@ -248,6 +249,7 @@
 
 // A ParsedModule contains the results of parsing a go.mod file.
 type ParsedModule struct {
+	URI         span.URI
 	File        *modfile.File
 	Mapper      *protocol.ColumnMapper
 	ParseErrors []Error
@@ -255,8 +257,6 @@
 
 // A TidiedModule contains the results of running `go mod tidy` on a module.
 type TidiedModule struct {
-	// The parsed module, which is guaranteed to have parsed successfully.
-	Parsed *ParsedModule
 	// Diagnostics representing changes made by `go mod tidy`.
 	Errors []Error
 	// The bytes of the go.mod file after it was tidied.
@@ -306,9 +306,6 @@
 // Overlay is the type for a file held in memory on a session.
 type Overlay interface {
 	VersionedFileHandle
-
-	// Saved returns whether this overlay has been saved to disk.
-	Saved() bool
 }
 
 // FileModification represents a modification to a file.
@@ -438,6 +435,8 @@
 	// Read reads the contents of a file.
 	// If the file is not available, returns a nil slice and an error.
 	Read() ([]byte, error)
+	// Saved reports whether the file has the same content on disk.
+	Saved() bool
 }
 
 // FileIdentity uniquely identifies a file at a version from a FileSystem.
diff --git a/internal/lsp/testdata/cgo/declarecgo.go.golden b/internal/lsp/testdata/cgo/declarecgo.go.golden
index 779ca2f..773f3b7 100644
--- a/internal/lsp/testdata/cgo/declarecgo.go.golden
+++ b/internal/lsp/testdata/cgo/declarecgo.go.golden
@@ -3,7 +3,7 @@
 func Example()
 ```
 
-[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo#Example)
+[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo?utm_source=gopls#Example)
 -- funccgoexample-definition-json --
 {
 	"span": {
@@ -19,7 +19,7 @@
 			"offset": 158
 		}
 	},
-	"description": "```go\nfunc Example()\n```\n\n[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo#Example)"
+	"description": "```go\nfunc Example()\n```\n\n[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo?utm_source=gopls#Example)"
 }
 
 -- funccgoexample-hover --
@@ -27,4 +27,4 @@
 func Example()
 ```
 
-[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo#Example)
+[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo?utm_source=gopls#Example)
diff --git a/internal/lsp/testdata/cgoimport/usecgo.go.golden b/internal/lsp/testdata/cgoimport/usecgo.go.golden
index 2687d30..8f7518a 100644
--- a/internal/lsp/testdata/cgoimport/usecgo.go.golden
+++ b/internal/lsp/testdata/cgoimport/usecgo.go.golden
@@ -3,7 +3,7 @@
 func cgo.Example()
 ```
 
-[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo#Example)
+[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo?utm_source=gopls#Example)
 -- funccgoexample-definition-json --
 {
 	"span": {
@@ -19,7 +19,7 @@
 			"offset": 158
 		}
 	},
-	"description": "```go\nfunc cgo.Example()\n```\n\n[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo#Example)"
+	"description": "```go\nfunc cgo.Example()\n```\n\n[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo?utm_source=gopls#Example)"
 }
 
 -- funccgoexample-hover --
@@ -27,4 +27,4 @@
 func cgo.Example()
 ```
 
-[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo#Example)
+[`cgo.Example` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/cgo?utm_source=gopls#Example)
diff --git a/internal/lsp/testdata/godef/a/a.go.golden b/internal/lsp/testdata/godef/a/a.go.golden
index b5909a7..08a1882 100644
--- a/internal/lsp/testdata/godef/a/a.go.golden
+++ b/internal/lsp/testdata/godef/a/a.go.golden
@@ -3,7 +3,7 @@
 func (*sync.Mutex).Lock()
 ```
 
-[`(sync.Mutex).Lock` on pkg.go.dev](https://pkg.go.dev/sync#Mutex.Lock)
+[`(sync.Mutex).Lock` on pkg.go.dev](https://pkg.go.dev/sync?utm_source=gopls#Mutex.Lock)
 
 Lock locks m\.
 -- Name-hover --
@@ -11,7 +11,7 @@
 func (*types.object).Name() string
 ```
 
-[`(types.TypeName).Name` on pkg.go.dev](https://pkg.go.dev/go/types#TypeName.Name)
+[`(types.TypeName).Name` on pkg.go.dev](https://pkg.go.dev/go/types?utm_source=gopls#TypeName.Name)
 
 Name returns the object\'s \(package\-local, unqualified\) name\.
 -- Random-definition --
@@ -19,7 +19,7 @@
 func Random() int
 ```
 
-[`a.Random` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Random)
+[`a.Random` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Random)
 -- Random-definition-json --
 {
 	"span": {
@@ -35,7 +35,7 @@
 			"offset": 22
 		}
 	},
-	"description": "```go\nfunc Random() int\n```\n\n[`a.Random` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Random)"
+	"description": "```go\nfunc Random() int\n```\n\n[`a.Random` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Random)"
 }
 
 -- Random-hover --
@@ -43,13 +43,13 @@
 func Random() int
 ```
 
-[`a.Random` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Random)
+[`a.Random` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Random)
 -- Random2-definition --
 godef/a/random.go:8:6-13: defined here as ```go
 func Random2(y int) int
 ```
 
-[`a.Random2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Random2)
+[`a.Random2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Random2)
 -- Random2-definition-json --
 {
 	"span": {
@@ -65,7 +65,7 @@
 			"offset": 78
 		}
 	},
-	"description": "```go\nfunc Random2(y int) int\n```\n\n[`a.Random2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Random2)"
+	"description": "```go\nfunc Random2(y int) int\n```\n\n[`a.Random2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Random2)"
 }
 
 -- Random2-hover --
@@ -73,11 +73,7 @@
 func Random2(y int) int
 ```
 
-[`a.Random2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Random2)
--- a-hover --
-```go
-
-```
+[`a.Random2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Random2)
 -- aPackage-hover --
 Package a is a package for testing go to definition\.
 -- err-definition --
@@ -127,7 +123,7 @@
 func(t Type, size ...IntegerType) Type
 ```
 
-[`make` on pkg.go.dev](https://pkg.go.dev/builtin#make)
+[`make` on pkg.go.dev](https://pkg.go.dev/builtin?utm_source=gopls#make)
 
 The make built\-in function allocates and initializes an object of type slice, map, or chan \(only\)\.
 -- string-hover --
@@ -139,7 +135,7 @@
 package types ("go/types")
 ```
 
-[`types` on pkg.go.dev](https://pkg.go.dev/go/types)
+[`types` on pkg.go.dev](https://pkg.go.dev/go/types?utm_source=gopls)
 -- x-hover --
 ```go
 var x string
diff --git a/internal/lsp/testdata/godef/a/d.go.golden b/internal/lsp/testdata/godef/a/d.go.golden
index 1427f37..d80c14a 100644
--- a/internal/lsp/testdata/godef/a/d.go.golden
+++ b/internal/lsp/testdata/godef/a/d.go.golden
@@ -3,7 +3,7 @@
 field Member string
 ```
 
-[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Member)
+[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Member)
 
 \@Member
 -- Member-definition-json --
@@ -21,7 +21,7 @@
 			"offset": 93
 		}
 	},
-	"description": "```go\nfield Member string\n```\n\n[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Member)\n\n\\@Member"
+	"description": "```go\nfield Member string\n```\n\n[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Member)\n\n\\@Member"
 }
 
 -- Member-hover --
@@ -29,7 +29,7 @@
 field Member string
 ```
 
-[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Member)
+[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Member)
 
 \@Member
 -- Method-definition --
@@ -37,7 +37,7 @@
 func (Thing).Method(i int) string
 ```
 
-[`(a.Thing).Method` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Method)
+[`(a.Thing).Method` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Method)
 -- Method-definition-json --
 {
 	"span": {
@@ -53,7 +53,7 @@
 			"offset": 222
 		}
 	},
-	"description": "```go\nfunc (Thing).Method(i int) string\n```\n\n[`(a.Thing).Method` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Method)"
+	"description": "```go\nfunc (Thing).Method(i int) string\n```\n\n[`(a.Thing).Method` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Method)"
 }
 
 -- Method-hover --
@@ -61,13 +61,13 @@
 func (Thing).Method(i int) string
 ```
 
-[`(a.Thing).Method` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Method)
+[`(a.Thing).Method` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Method)
 -- Other-definition --
 godef/a/d.go:9:5-10: defined here as ```go
 var Other Thing
 ```
 
-[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Other)
+[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Other)
 
 \@Other
 -- Other-definition-json --
@@ -85,7 +85,7 @@
 			"offset": 123
 		}
 	},
-	"description": "```go\nvar Other Thing\n```\n\n[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Other)\n\n\\@Other"
+	"description": "```go\nvar Other Thing\n```\n\n[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Other)\n\n\\@Other"
 }
 
 -- Other-hover --
@@ -93,7 +93,7 @@
 var Other Thing
 ```
 
-[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Other)
+[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Other)
 
 \@Other
 -- Thing-definition --
@@ -103,7 +103,7 @@
 }
 ```
 
-[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing)
+[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing)
 -- Thing-definition-json --
 {
 	"span": {
@@ -119,7 +119,7 @@
 			"offset": 67
 		}
 	},
-	"description": "```go\ntype Thing struct {\n\tMember string //@Member\n}\n```\n\n[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing)"
+	"description": "```go\ntype Thing struct {\n\tMember string //@Member\n}\n```\n\n[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing)"
 }
 
 -- Thing-hover --
@@ -129,13 +129,13 @@
 }
 ```
 
-[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing)
+[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing)
 -- Things-definition --
 godef/a/d.go:11:6-12: defined here as ```go
 func Things(val []string) []Thing
 ```
 
-[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Things)
+[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Things)
 -- Things-definition-json --
 {
 	"span": {
@@ -151,7 +151,7 @@
 			"offset": 151
 		}
 	},
-	"description": "```go\nfunc Things(val []string) []Thing\n```\n\n[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Things)"
+	"description": "```go\nfunc Things(val []string) []Thing\n```\n\n[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Things)"
 }
 
 -- Things-hover --
@@ -159,6 +159,6 @@
 func Things(val []string) []Thing
 ```
 
-[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Things)
+[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Things)
 -- a-hover --
 Package a is a package for testing go to definition\.
diff --git a/internal/lsp/testdata/godef/a/random.go.golden b/internal/lsp/testdata/godef/a/random.go.golden
index bba2e2b..0f99a52 100644
--- a/internal/lsp/testdata/godef/a/random.go.golden
+++ b/internal/lsp/testdata/godef/a/random.go.golden
@@ -3,7 +3,7 @@
 func (*Pos).Sum() int
 ```
 
-[`(a.Pos).Sum` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Pos.Sum)
+[`(a.Pos).Sum` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Pos.Sum)
 -- PosSum-definition-json --
 {
 	"span": {
@@ -19,7 +19,7 @@
 			"offset": 416
 		}
 	},
-	"description": "```go\nfunc (*Pos).Sum() int\n```\n\n[`(a.Pos).Sum` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Pos.Sum)"
+	"description": "```go\nfunc (*Pos).Sum() int\n```\n\n[`(a.Pos).Sum` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Pos.Sum)"
 }
 
 -- PosSum-hover --
@@ -27,7 +27,7 @@
 func (*Pos).Sum() int
 ```
 
-[`(a.Pos).Sum` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Pos.Sum)
+[`(a.Pos).Sum` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Pos.Sum)
 -- PosX-definition --
 godef/a/random.go:13:2-3: defined here as ```go
 field x int
diff --git a/internal/lsp/testdata/godef/b/b.go b/internal/lsp/testdata/godef/b/b.go
index a510a45..23d908f 100644
--- a/internal/lsp/testdata/godef/b/b.go
+++ b/internal/lsp/testdata/godef/b/b.go
@@ -22,10 +22,13 @@
 	e.Goodbye() //@hover("Goodbye", AGoodbye)
 }
 
+type aAlias = a.A //@mark(aAlias, "aAlias")
+
 type S1 struct { //@S1
-	F1  int //@mark(S1F1, "F1")
-	S2      //@godef("S2", S2),mark(S1S2, "S2")
-	a.A     //@godef("A", AString)
+	F1     int //@mark(S1F1, "F1")
+	S2         //@godef("S2", S2),mark(S1S2, "S2")
+	a.A        //@godef("A", AString)
+	aAlias     //@godef("a", aAlias)
 }
 
 type S2 struct { //@S2
diff --git a/internal/lsp/testdata/godef/b/b.go.golden b/internal/lsp/testdata/godef/b/b.go.golden
index 4ebb96a..19ece5d 100644
--- a/internal/lsp/testdata/godef/b/b.go.golden
+++ b/internal/lsp/testdata/godef/b/b.go.golden
@@ -3,7 +3,7 @@
 func (a.I).B()
 ```
 
-[`(a.I).B` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#I.B)
+[`(a.I).B` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#I.B)
 
 \@mark\(AB, \"B\"\)
 -- AField-hover --
@@ -11,7 +11,7 @@
 field Field int
 ```
 
-[`(a.S).Field` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#S.Field)
+[`(a.S).Field` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#S.Field)
 
 \@mark\(AField, \"Field\"\)
 -- AField2-hover --
@@ -19,7 +19,7 @@
 field Field2 int
 ```
 
-[`(a.R).Field2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#R.Field2)
+[`(a.R).Field2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#R.Field2)
 
 \@mark\(AField2, \"Field2\"\)
 -- AGoodbye-hover --
@@ -27,7 +27,7 @@
 func (a.H).Goodbye()
 ```
 
-[`(a.H).Goodbye` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#H.Goodbye)
+[`(a.H).Goodbye` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#H.Goodbye)
 
 \@mark\(AGoodbye, \"Goodbye\"\)
 -- AHello-hover --
@@ -35,7 +35,7 @@
 func (a.J).Hello()
 ```
 
-[`(a.J).Hello` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#J.Hello)
+[`(a.J).Hello` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#J.Hello)
 
 \@mark\(AHello, \"Hello\"\)
 -- AHey-hover --
@@ -43,19 +43,19 @@
 func (a.R).Hey()
 ```
 
-[`(a.R).Hey` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#R.Hey)
+[`(a.R).Hey` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#R.Hey)
 -- AHi-hover --
 ```go
 func (a.A).Hi()
 ```
 
-[`(a.A).Hi` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#A.Hi)
+[`(a.A).Hi` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#A.Hi)
 -- AImport-definition --
 godef/b/b.go:5:2-43: defined here as ```go
 package a ("golang.org/x/tools/internal/lsp/godef/a")
 ```
 
-[`a` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a)
+[`a` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls)
 -- AImport-definition-json --
 {
 	"span": {
@@ -71,7 +71,7 @@
 			"offset": 153
 		}
 	},
-	"description": "```go\npackage a (\"golang.org/x/tools/internal/lsp/godef/a\")\n```\n\n[`a` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a)"
+	"description": "```go\npackage a (\"golang.org/x/tools/internal/lsp/godef/a\")\n```\n\n[`a` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls)"
 }
 
 -- AImport-hover --
@@ -79,14 +79,14 @@
 package a ("golang.org/x/tools/internal/lsp/godef/a")
 ```
 
-[`a` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a)
+[`a` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls)
 -- AString-definition --
 godef/a/a.go:26:6-7: defined here as ```go
 type A string //@mark(AString, "A")
 
 ```
 
-[`a.A` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#A)
+[`a.A` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#A)
 -- AString-definition-json --
 {
 	"span": {
@@ -102,7 +102,7 @@
 			"offset": 453
 		}
 	},
-	"description": "```go\ntype A string //@mark(AString, \"A\")\n\n```\n\n[`a.A` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#A)"
+	"description": "```go\ntype A string //@mark(AString, \"A\")\n\n```\n\n[`a.A` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#A)"
 }
 
 -- AString-hover --
@@ -111,13 +111,13 @@
 
 ```
 
-[`a.A` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#A)
+[`a.A` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#A)
 -- AStuff-definition --
 godef/a/a.go:28:6-12: defined here as ```go
 func a.AStuff()
 ```
 
-[`a.AStuff` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#AStuff)
+[`a.AStuff` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#AStuff)
 -- AStuff-definition-json --
 {
 	"span": {
@@ -133,7 +133,7 @@
 			"offset": 495
 		}
 	},
-	"description": "```go\nfunc a.AStuff()\n```\n\n[`a.AStuff` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#AStuff)"
+	"description": "```go\nfunc a.AStuff()\n```\n\n[`a.AStuff` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#AStuff)"
 }
 
 -- AStuff-hover --
@@ -141,51 +141,53 @@
 func a.AStuff()
 ```
 
-[`a.AStuff` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#AStuff)
+[`a.AStuff` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#AStuff)
 -- S1-definition --
-godef/b/b.go:25:6-8: defined here as ```go
+godef/b/b.go:27:6-8: defined here as ```go
 type S1 struct {
-	F1  int //@mark(S1F1, "F1")
-	S2      //@godef("S2", S2),mark(S1S2, "S2")
-	a.A     //@godef("A", AString)
+	F1     int //@mark(S1F1, "F1")
+	S2         //@godef("S2", S2),mark(S1S2, "S2")
+	a.A        //@godef("A", AString)
+	aAlias     //@godef("a", aAlias)
 }
 ```
 
-[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1)
+[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1)
 -- S1-definition-json --
 {
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 25,
+			"line": 27,
 			"column": 6,
-			"offset": 521
+			"offset": 566
 		},
 		"end": {
-			"line": 25,
+			"line": 27,
 			"column": 8,
-			"offset": 523
+			"offset": 568
 		}
 	},
-	"description": "```go\ntype S1 struct {\n\tF1  int //@mark(S1F1, \"F1\")\n\tS2      //@godef(\"S2\", S2),mark(S1S2, \"S2\")\n\ta.A     //@godef(\"A\", AString)\n}\n```\n\n[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1)"
+	"description": "```go\ntype S1 struct {\n\tF1     int //@mark(S1F1, \"F1\")\n\tS2         //@godef(\"S2\", S2),mark(S1S2, \"S2\")\n\ta.A        //@godef(\"A\", AString)\n\taAlias     //@godef(\"a\", aAlias)\n}\n```\n\n[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1)"
 }
 
 -- S1-hover --
 ```go
 type S1 struct {
-	F1  int //@mark(S1F1, "F1")
-	S2      //@godef("S2", S2),mark(S1S2, "S2")
-	a.A     //@godef("A", AString)
+	F1     int //@mark(S1F1, "F1")
+	S2         //@godef("S2", S2),mark(S1S2, "S2")
+	a.A        //@godef("A", AString)
+	aAlias     //@godef("a", aAlias)
 }
 ```
 
-[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1)
+[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1)
 -- S1F1-definition --
-godef/b/b.go:26:2-4: defined here as ```go
+godef/b/b.go:28:2-4: defined here as ```go
 field F1 int
 ```
 
-[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.F1)
+[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.F1)
 
 \@mark\(S1F1, \"F1\"\)
 -- S1F1-definition-json --
@@ -193,17 +195,17 @@
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 26,
+			"line": 28,
 			"column": 2,
-			"offset": 540
+			"offset": 585
 		},
 		"end": {
-			"line": 26,
+			"line": 28,
 			"column": 4,
-			"offset": 542
+			"offset": 587
 		}
 	},
-	"description": "```go\nfield F1 int\n```\n\n[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.F1)\n\n\\@mark\\(S1F1, \\\"F1\\\"\\)"
+	"description": "```go\nfield F1 int\n```\n\n[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.F1)\n\n\\@mark\\(S1F1, \\\"F1\\\"\\)"
 }
 
 -- S1F1-hover --
@@ -211,15 +213,15 @@
 field F1 int
 ```
 
-[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.F1)
+[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.F1)
 
 \@mark\(S1F1, \"F1\"\)
 -- S1S2-definition --
-godef/b/b.go:27:2-4: defined here as ```go
+godef/b/b.go:29:2-4: defined here as ```go
 field S2 S2
 ```
 
-[`(b.S1).S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.S2)
+[`(b.S1).S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.S2)
 
 \@godef\(\"S2\", S2\),mark\(S1S2, \"S2\"\)
 -- S1S2-definition-json --
@@ -227,17 +229,17 @@
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 27,
+			"line": 29,
 			"column": 2,
-			"offset": 569
+			"offset": 617
 		},
 		"end": {
-			"line": 27,
+			"line": 29,
 			"column": 4,
-			"offset": 571
+			"offset": 619
 		}
 	},
-	"description": "```go\nfield S2 S2\n```\n\n[`(b.S1).S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.S2)\n\n\\@godef\\(\\\"S2\\\", S2\\),mark\\(S1S2, \\\"S2\\\"\\)"
+	"description": "```go\nfield S2 S2\n```\n\n[`(b.S1).S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.S2)\n\n\\@godef\\(\\\"S2\\\", S2\\),mark\\(S1S2, \\\"S2\\\"\\)"
 }
 
 -- S1S2-hover --
@@ -245,11 +247,11 @@
 field S2 S2
 ```
 
-[`(b.S1).S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.S2)
+[`(b.S1).S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.S2)
 
 \@godef\(\"S2\", S2\),mark\(S1S2, \"S2\"\)
 -- S2-definition --
-godef/b/b.go:31:6-8: defined here as ```go
+godef/b/b.go:34:6-8: defined here as ```go
 type S2 struct {
 	F1   string //@mark(S2F1, "F1")
 	F2   int    //@mark(S2F2, "F2")
@@ -257,23 +259,23 @@
 }
 ```
 
-[`b.S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2)
+[`b.S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2)
 -- S2-definition-json --
 {
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 31,
+			"line": 34,
 			"column": 6,
-			"offset": 653
+			"offset": 741
 		},
 		"end": {
-			"line": 31,
+			"line": 34,
 			"column": 8,
-			"offset": 655
+			"offset": 743
 		}
 	},
-	"description": "```go\ntype S2 struct {\n\tF1   string //@mark(S2F1, \"F1\")\n\tF2   int    //@mark(S2F2, \"F2\")\n\t*a.A        //@godef(\"A\", AString),godef(\"a\",AImport)\n}\n```\n\n[`b.S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2)"
+	"description": "```go\ntype S2 struct {\n\tF1   string //@mark(S2F1, \"F1\")\n\tF2   int    //@mark(S2F2, \"F2\")\n\t*a.A        //@godef(\"A\", AString),godef(\"a\",AImport)\n}\n```\n\n[`b.S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2)"
 }
 
 -- S2-hover --
@@ -285,13 +287,13 @@
 }
 ```
 
-[`b.S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2)
+[`b.S2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2)
 -- S2F1-definition --
-godef/b/b.go:32:2-4: defined here as ```go
+godef/b/b.go:35:2-4: defined here as ```go
 field F1 string
 ```
 
-[`(b.S2).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2.F1)
+[`(b.S2).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2.F1)
 
 \@mark\(S2F1, \"F1\"\)
 -- S2F1-definition-json --
@@ -299,17 +301,17 @@
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 32,
+			"line": 35,
 			"column": 2,
-			"offset": 672
+			"offset": 760
 		},
 		"end": {
-			"line": 32,
+			"line": 35,
 			"column": 4,
-			"offset": 674
+			"offset": 762
 		}
 	},
-	"description": "```go\nfield F1 string\n```\n\n[`(b.S2).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2.F1)\n\n\\@mark\\(S2F1, \\\"F1\\\"\\)"
+	"description": "```go\nfield F1 string\n```\n\n[`(b.S2).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2.F1)\n\n\\@mark\\(S2F1, \\\"F1\\\"\\)"
 }
 
 -- S2F1-hover --
@@ -317,15 +319,15 @@
 field F1 string
 ```
 
-[`(b.S2).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2.F1)
+[`(b.S2).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2.F1)
 
 \@mark\(S2F1, \"F1\"\)
 -- S2F2-definition --
-godef/b/b.go:33:2-4: defined here as ```go
+godef/b/b.go:36:2-4: defined here as ```go
 field F2 int
 ```
 
-[`(b.S2).F2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2.F2)
+[`(b.S2).F2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2.F2)
 
 \@mark\(S2F2, \"F2\"\)
 -- S2F2-definition-json --
@@ -333,17 +335,17 @@
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 33,
+			"line": 36,
 			"column": 2,
-			"offset": 705
+			"offset": 793
 		},
 		"end": {
-			"line": 33,
+			"line": 36,
 			"column": 4,
-			"offset": 707
+			"offset": 795
 		}
 	},
-	"description": "```go\nfield F2 int\n```\n\n[`(b.S2).F2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2.F2)\n\n\\@mark\\(S2F2, \\\"F2\\\"\\)"
+	"description": "```go\nfield F2 int\n```\n\n[`(b.S2).F2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2.F2)\n\n\\@mark\\(S2F2, \\\"F2\\\"\\)"
 }
 
 -- S2F2-hover --
@@ -351,15 +353,43 @@
 field F2 int
 ```
 
-[`(b.S2).F2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S2.F2)
+[`(b.S2).F2` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S2.F2)
 
 \@mark\(S2F2, \"F2\"\)
+-- aAlias-definition --
+godef/b/b.go:25:6-12: defined here as ```go
+type aAlias = a.A //@mark(aAlias, "aAlias")
+
+```
+-- aAlias-definition-json --
+{
+	"span": {
+		"uri": "file://godef/b/b.go",
+		"start": {
+			"line": 25,
+			"column": 6,
+			"offset": 521
+		},
+		"end": {
+			"line": 25,
+			"column": 12,
+			"offset": 527
+		}
+	},
+	"description": "```go\ntype aAlias = a.A //@mark(aAlias, \"aAlias\")\n\n```"
+}
+
+-- aAlias-hover --
+```go
+type aAlias = a.A //@mark(aAlias, "aAlias")
+
+```
 -- bX-definition --
-godef/b/b.go:54:7-8: defined here as ```go
+godef/b/b.go:57:7-8: defined here as ```go
 const X untyped int = 0
 ```
 
-[`b.X` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#X)
+[`b.X` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#X)
 
 \@mark\(bX, \"X\"\),godef\(\"X\", bX\)
 -- bX-definition-json --
@@ -367,17 +397,17 @@
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 54,
+			"line": 57,
 			"column": 7,
-			"offset": 1140
+			"offset": 1228
 		},
 		"end": {
-			"line": 54,
+			"line": 57,
 			"column": 8,
-			"offset": 1141
+			"offset": 1229
 		}
 	},
-	"description": "```go\nconst X untyped int = 0\n```\n\n[`b.X` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#X)\n\n\\@mark\\(bX, \\\"X\\\"\\),godef\\(\\\"X\\\", bX\\)"
+	"description": "```go\nconst X untyped int = 0\n```\n\n[`b.X` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#X)\n\n\\@mark\\(bX, \\\"X\\\"\\),godef\\(\\\"X\\\", bX\\)"
 }
 
 -- bX-hover --
@@ -385,7 +415,7 @@
 const X untyped int = 0
 ```
 
-[`b.X` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#X)
+[`b.X` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#X)
 
 \@mark\(bX, \"X\"\),godef\(\"X\", bX\)
 -- myFoo-definition --
@@ -393,7 +423,7 @@
 package myFoo ("golang.org/x/tools/internal/lsp/foo")
 ```
 
-[`myFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo)
+[`myFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo?utm_source=gopls)
 -- myFoo-definition-json --
 {
 	"span": {
@@ -409,7 +439,7 @@
 			"offset": 26
 		}
 	},
-	"description": "```go\npackage myFoo (\"golang.org/x/tools/internal/lsp/foo\")\n```\n\n[`myFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo)"
+	"description": "```go\npackage myFoo (\"golang.org/x/tools/internal/lsp/foo\")\n```\n\n[`myFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo?utm_source=gopls)"
 }
 
 -- myFoo-hover --
@@ -417,4 +447,4 @@
 package myFoo ("golang.org/x/tools/internal/lsp/foo")
 ```
 
-[`myFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo)
+[`myFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo?utm_source=gopls)
diff --git a/internal/lsp/testdata/godef/b/c.go.golden b/internal/lsp/testdata/godef/b/c.go.golden
index d551f22..9554c0d 100644
--- a/internal/lsp/testdata/godef/b/c.go.golden
+++ b/internal/lsp/testdata/godef/b/c.go.golden
@@ -1,47 +1,49 @@
 -- S1-definition --
-godef/b/b.go:25:6-8: defined here as ```go
+godef/b/b.go:27:6-8: defined here as ```go
 type S1 struct {
-	F1  int //@mark(S1F1, "F1")
-	S2      //@godef("S2", S2),mark(S1S2, "S2")
-	a.A     //@godef("A", AString)
+	F1     int //@mark(S1F1, "F1")
+	S2         //@godef("S2", S2),mark(S1S2, "S2")
+	a.A        //@godef("A", AString)
+	aAlias     //@godef("a", aAlias)
 }
 ```
 
-[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1)
+[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1)
 -- S1-definition-json --
 {
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 25,
+			"line": 27,
 			"column": 6,
-			"offset": 521
+			"offset": 566
 		},
 		"end": {
-			"line": 25,
+			"line": 27,
 			"column": 8,
-			"offset": 523
+			"offset": 568
 		}
 	},
-	"description": "```go\ntype S1 struct {\n\tF1  int //@mark(S1F1, \"F1\")\n\tS2      //@godef(\"S2\", S2),mark(S1S2, \"S2\")\n\ta.A     //@godef(\"A\", AString)\n}\n```\n\n[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1)"
+	"description": "```go\ntype S1 struct {\n\tF1     int //@mark(S1F1, \"F1\")\n\tS2         //@godef(\"S2\", S2),mark(S1S2, \"S2\")\n\ta.A        //@godef(\"A\", AString)\n\taAlias     //@godef(\"a\", aAlias)\n}\n```\n\n[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1)"
 }
 
 -- S1-hover --
 ```go
 type S1 struct {
-	F1  int //@mark(S1F1, "F1")
-	S2      //@godef("S2", S2),mark(S1S2, "S2")
-	a.A     //@godef("A", AString)
+	F1     int //@mark(S1F1, "F1")
+	S2         //@godef("S2", S2),mark(S1S2, "S2")
+	a.A        //@godef("A", AString)
+	aAlias     //@godef("a", aAlias)
 }
 ```
 
-[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1)
+[`b.S1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1)
 -- S1F1-definition --
-godef/b/b.go:26:2-4: defined here as ```go
+godef/b/b.go:28:2-4: defined here as ```go
 field F1 int
 ```
 
-[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.F1)
+[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.F1)
 
 \@mark\(S1F1, \"F1\"\)
 -- S1F1-definition-json --
@@ -49,17 +51,17 @@
 	"span": {
 		"uri": "file://godef/b/b.go",
 		"start": {
-			"line": 26,
+			"line": 28,
 			"column": 2,
-			"offset": 540
+			"offset": 585
 		},
 		"end": {
-			"line": 26,
+			"line": 28,
 			"column": 4,
-			"offset": 542
+			"offset": 587
 		}
 	},
-	"description": "```go\nfield F1 int\n```\n\n[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.F1)\n\n\\@mark\\(S1F1, \\\"F1\\\"\\)"
+	"description": "```go\nfield F1 int\n```\n\n[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.F1)\n\n\\@mark\\(S1F1, \\\"F1\\\"\\)"
 }
 
 -- S1F1-hover --
@@ -67,6 +69,6 @@
 field F1 int
 ```
 
-[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b#S1.F1)
+[`(b.S1).F1` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/b?utm_source=gopls#S1.F1)
 
 \@mark\(S1F1, \"F1\"\)
diff --git a/internal/lsp/testdata/godef/b/e.go.golden b/internal/lsp/testdata/godef/b/e.go.golden
index d5eb1e9..13c2e0e 100644
--- a/internal/lsp/testdata/godef/b/e.go.golden
+++ b/internal/lsp/testdata/godef/b/e.go.golden
@@ -3,7 +3,7 @@
 field Member string
 ```
 
-[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Member)
+[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Member)
 
 \@Member
 -- Member-definition-json --
@@ -21,7 +21,7 @@
 			"offset": 93
 		}
 	},
-	"description": "```go\nfield Member string\n```\n\n[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Member)\n\n\\@Member"
+	"description": "```go\nfield Member string\n```\n\n[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Member)\n\n\\@Member"
 }
 
 -- Member-hover --
@@ -29,7 +29,7 @@
 field Member string
 ```
 
-[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing.Member)
+[`(a.Thing).Member` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing.Member)
 
 \@Member
 -- Other-definition --
@@ -37,7 +37,7 @@
 var a.Other a.Thing
 ```
 
-[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Other)
+[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Other)
 
 \@Other
 -- Other-definition-json --
@@ -55,7 +55,7 @@
 			"offset": 123
 		}
 	},
-	"description": "```go\nvar a.Other a.Thing\n```\n\n[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Other)\n\n\\@Other"
+	"description": "```go\nvar a.Other a.Thing\n```\n\n[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Other)\n\n\\@Other"
 }
 
 -- Other-hover --
@@ -63,7 +63,7 @@
 var a.Other a.Thing
 ```
 
-[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Other)
+[`a.Other` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Other)
 
 \@Other
 -- Thing-definition --
@@ -73,7 +73,7 @@
 }
 ```
 
-[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing)
+[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing)
 -- Thing-definition-json --
 {
 	"span": {
@@ -89,7 +89,7 @@
 			"offset": 67
 		}
 	},
-	"description": "```go\ntype Thing struct {\n\tMember string //@Member\n}\n```\n\n[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing)"
+	"description": "```go\ntype Thing struct {\n\tMember string //@Member\n}\n```\n\n[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing)"
 }
 
 -- Thing-hover --
@@ -99,13 +99,13 @@
 }
 ```
 
-[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Thing)
+[`a.Thing` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Thing)
 -- Things-definition --
 godef/a/d.go:11:6-12: defined here as ```go
 func a.Things(val []string) []a.Thing
 ```
 
-[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Things)
+[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Things)
 -- Things-definition-json --
 {
 	"span": {
@@ -121,7 +121,7 @@
 			"offset": 151
 		}
 	},
-	"description": "```go\nfunc a.Things(val []string) []a.Thing\n```\n\n[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Things)"
+	"description": "```go\nfunc a.Things(val []string) []a.Thing\n```\n\n[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Things)"
 }
 
 -- Things-hover --
@@ -129,7 +129,7 @@
 func a.Things(val []string) []a.Thing
 ```
 
-[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a#Things)
+[`a.Things` on pkg.go.dev](https://pkg.go.dev/golang.org/x/tools/internal/lsp/godef/a?utm_source=gopls#Things)
 -- eInt-hover --
 ```go
 var x int
diff --git a/internal/lsp/testdata/links/links.go b/internal/lsp/testdata/links/links.go
index 06ab290..89492ba 100644
--- a/internal/lsp/testdata/links/links.go
+++ b/internal/lsp/testdata/links/links.go
@@ -1,11 +1,11 @@
 package links
 
 import (
-	"fmt" //@link(`fmt`,"https://pkg.go.dev/fmt")
+	"fmt" //@link(`fmt`,"https://pkg.go.dev/fmt?utm_source=gopls")
 
-	"golang.org/x/tools/internal/lsp/foo" //@link(`golang.org/x/tools/internal/lsp/foo`,`https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo`)
+	"golang.org/x/tools/internal/lsp/foo" //@link(`golang.org/x/tools/internal/lsp/foo`,`https://pkg.go.dev/golang.org/x/tools/internal/lsp/foo?utm_source=gopls`)
 
-	_ "database/sql" //@link(`database/sql`, `https://pkg.go.dev/database/sql`)
+	_ "database/sql" //@link(`database/sql`, `https://pkg.go.dev/database/sql?utm_source=gopls`)
 )
 
 var (
diff --git a/internal/lsp/testdata/rank/struct/struct_rank.go b/internal/lsp/testdata/rank/struct/struct_rank.go
new file mode 100644
index 0000000..e0bdd38
--- /dev/null
+++ b/internal/lsp/testdata/rank/struct/struct_rank.go
@@ -0,0 +1,11 @@
+package struct_rank
+
+type foo struct {
+	c int //@item(c_rank, "c", "int", "field")
+	b int //@item(b_rank, "b", "int", "field")
+	a int //@item(a_rank, "a", "int", "field")
+}
+
+func f() {
+	foo := foo{} //@rank("}", c_rank, b_rank, a_rank)
+}
diff --git a/internal/lsp/testdata/summary.txt.golden b/internal/lsp/testdata/summary.txt.golden
index 3771c85..a8a3799 100644
--- a/internal/lsp/testdata/summary.txt.golden
+++ b/internal/lsp/testdata/summary.txt.golden
@@ -6,7 +6,7 @@
 UnimportedCompletionsCount = 5
 DeepCompletionsCount = 5
 FuzzyCompletionsCount = 8
-RankedCompletionsCount = 157
+RankedCompletionsCount = 158
 CaseSensitiveCompletionsCount = 4
 DiagnosticsCount = 43
 FoldingRangesCount = 2
@@ -15,7 +15,7 @@
 SemanticTokenCount = 2
 SuggestedFixCount = 38
 FunctionExtractionCount = 12
-DefinitionsCount = 63
+DefinitionsCount = 64
 TypeDefinitionsCount = 2
 HighlightsCount = 69
 ReferencesCount = 25
diff --git a/internal/lsp/tests/tests.go b/internal/lsp/tests/tests.go
index 3d173b4..2456c2f 100644
--- a/internal/lsp/tests/tests.go
+++ b/internal/lsp/tests/tests.go
@@ -490,11 +490,6 @@
 			for i, e := range exp {
 				t.Run(SpanName(src)+"_"+strconv.Itoa(i), func(t *testing.T) {
 					t.Helper()
-					if strings.Contains(t.Name(), "complit") || strings.Contains(t.Name(), "UnimportedCompletion") {
-						if data.mode == "MultiModule" {
-							t.Skip("Unimported completions are broken in multi-module mode")
-						}
-					}
 					if strings.Contains(t.Name(), "cgo") {
 						testenv.NeedsTool(t, "cgo")
 					}
diff --git a/internal/lsp/workspace.go b/internal/lsp/workspace.go
index 9b29668..2dce905 100644
--- a/internal/lsp/workspace.go
+++ b/internal/lsp/workspace.go
@@ -70,20 +70,18 @@
 	// Update any session-specific registrations or unregistrations.
 	if !semanticTokensRegistered && options.SemanticTokens {
 		if err := s.client.RegisterCapability(ctx, &protocol.RegistrationParams{
-			Registrations: semanticTokenRegistrations(),
+			Registrations: []protocol.Registration{semanticTokenRegistration()},
 		}); err != nil {
 			return err
 		}
 	} else if semanticTokensRegistered && !options.SemanticTokens {
-		var unregistrations []protocol.Unregistration
-		for _, r := range semanticTokenRegistrations() {
-			unregistrations = append(unregistrations, protocol.Unregistration{
-				ID:     r.ID,
-				Method: r.Method,
-			})
-		}
 		if err := s.client.UnregisterCapability(ctx, &protocol.UnregistrationParams{
-			Unregisterations: unregistrations,
+			Unregisterations: []protocol.Unregistration{
+				{
+					ID:     semanticTokenRegistration().ID,
+					Method: semanticTokenRegistration().Method,
+				},
+			},
 		}); err != nil {
 			return err
 		}
@@ -91,31 +89,19 @@
 	return nil
 }
 
-// This is a work-around for
-// https://github.com/microsoft/language-server-protocol/issues/1107. Once
-// https://golang.org/cl/266497 has been released for ~1 month, we can probably
-// remove this function and use the only correct method name, which is
-// "textDocument/semanticTokens".
-func semanticTokenRegistrations() []protocol.Registration {
-	var registrations []protocol.Registration
-	for _, method := range []string{
-		"textDocument/semanticTokens",
-		"textDocument/semanticTokens/full",
-		"textDocument/semanticTokens/full/delta",
-		"textDocument/semanticTokens/range",
-	} {
-		registrations = append(registrations, protocol.Registration{
-			ID:     method,
-			Method: method,
-			RegisterOptions: &protocol.SemanticTokensOptions{
-				Legend: protocol.SemanticTokensLegend{
-					// TODO(pjw): trim these to what we use (and an unused one
-					// at position 0 of TokTypes, to catch typos)
-					TokenTypes:     SemanticTypes(),
-					TokenModifiers: SemanticModifiers(),
-				},
+func semanticTokenRegistration() protocol.Registration {
+	return protocol.Registration{
+		ID:     "textDocument/semanticTokens",
+		Method: "textDocument/semanticTokens",
+		RegisterOptions: &protocol.SemanticTokensOptions{
+			Legend: protocol.SemanticTokensLegend{
+				// TODO(pjw): trim these to what we use (and an unused one
+				// at position 0 of TokTypes, to catch typos)
+				TokenTypes:     SemanticTypes(),
+				TokenModifiers: SemanticModifiers(),
 			},
-		})
+			Full:  true,
+			Range: true,
+		},
 	}
-	return registrations
 }
diff --git a/internal/typesinternal/errorcode.go b/internal/typesinternal/errorcode.go
new file mode 100644
index 0000000..65473eb
--- /dev/null
+++ b/internal/typesinternal/errorcode.go
@@ -0,0 +1,1358 @@
+// Copyright 2020 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 typesinternal
+
+//go:generate stringer -type=ErrorCode
+
+type ErrorCode int
+
+// This file defines the error codes that can be produced during type-checking.
+// Collectively, these codes provide an identifier that may be used to
+// implement special handling for certain types of errors.
+//
+// Error codes should be fine-grained enough that the exact nature of the error
+// can be easily determined, but coarse enough that they are not an
+// implementation detail of the type checking algorithm. As a rule-of-thumb,
+// errors should be considered equivalent if there is a theoretical refactoring
+// of the type checker in which they are emitted in exactly one place. For
+// example, the type checker emits different error messages for "too many
+// arguments" and "too few arguments", but one can imagine an alternative type
+// checker where this check instead just emits a single "wrong number of
+// arguments", so these errors should have the same code.
+//
+// Error code names should be as brief as possible while retaining accuracy and
+// distinctiveness. In most cases names should start with an adjective
+// describing the nature of the error (e.g. "invalid", "unused", "misplaced"),
+// and end with a noun identifying the relevant language object. For example,
+// "DuplicateDecl" or "InvalidSliceExpr". For brevity, naming follows the
+// convention that "bad" implies a problem with syntax, and "invalid" implies a
+// problem with types.
+
+const (
+	_ ErrorCode = iota
+
+	// Test is reserved for errors that only apply while in self-test mode.
+	Test
+
+	/* package names */
+
+	// BlankPkgName occurs when a package name is the blank identifier "_".
+	//
+	// Per the spec:
+	//  "The PackageName must not be the blank identifier."
+	BlankPkgName
+
+	// MismatchedPkgName occurs when a file's package name doesn't match the
+	// package name already established by other files.
+	MismatchedPkgName
+
+	// InvalidPkgUse occurs when a package identifier is used outside of a
+	// selector expression.
+	//
+	// Example:
+	//  import "fmt"
+	//
+	//  var _ = fmt
+	InvalidPkgUse
+
+	/* imports */
+
+	// BadImportPath occurs when an import path is not valid.
+	BadImportPath
+
+	// BrokenImport occurs when importing a package fails.
+	//
+	// Example:
+	//  import "amissingpackage"
+	BrokenImport
+
+	// ImportCRenamed occurs when the special import "C" is renamed. "C" is a
+	// pseudo-package, and must not be renamed.
+	//
+	// Example:
+	//  import _ "C"
+	ImportCRenamed
+
+	// UnusedImport occurs when an import is unused.
+	//
+	// Example:
+	//  import "fmt"
+	//
+	//  func main() {}
+	UnusedImport
+
+	/* initialization */
+
+	// InvalidInitCycle occurs when an invalid cycle is detected within the
+	// initialization graph.
+	//
+	// Example:
+	//  var x int = f()
+	//
+	//  func f() int { return x }
+	InvalidInitCycle
+
+	/* decls */
+
+	// DuplicateDecl occurs when an identifier is declared multiple times.
+	//
+	// Example:
+	//  var x = 1
+	//  var x = 2
+	DuplicateDecl
+
+	// InvalidDeclCycle occurs when a declaration cycle is not valid.
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  type T struct {
+	//  	a [n]int
+	//  }
+	//
+	//  var n = unsafe.Sizeof(T{})
+	InvalidDeclCycle
+
+	// InvalidTypeCycle occurs when a cycle in type definitions results in a
+	// type that is not well-defined.
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  type T [unsafe.Sizeof(T{})]int
+	InvalidTypeCycle
+
+	/* decls > const */
+
+	// InvalidConstInit occurs when a const declaration has a non-constant
+	// initializer.
+	//
+	// Example:
+	//  var x int
+	//  const _ = x
+	InvalidConstInit
+
+	// InvalidConstVal occurs when a const value cannot be converted to its
+	// target type.
+	//
+	// TODO(findleyr): this error code and example are not very clear. Consider
+	// removing it.
+	//
+	// Example:
+	//  const _ = 1 << "hello"
+	InvalidConstVal
+
+	// InvalidConstType occurs when the underlying type in a const declaration
+	// is not a valid constant type.
+	//
+	// Example:
+	//  const c *int = 4
+	InvalidConstType
+
+	/* decls > var (+ other variable assignment codes) */
+
+	// UntypedNil occurs when the predeclared (untyped) value nil is used to
+	// initialize a variable declared without an explicit type.
+	//
+	// Example:
+	//  var x = nil
+	UntypedNil
+
+	// WrongAssignCount occurs when the number of values on the right-hand side
+	// of an assignment or or initialization expression does not match the number
+	// of variables on the left-hand side.
+	//
+	// Example:
+	//  var x = 1, 2
+	WrongAssignCount
+
+	// UnassignableOperand occurs when the left-hand side of an assignment is
+	// not assignable.
+	//
+	// Example:
+	//  func f() {
+	//  	const c = 1
+	//  	c = 2
+	//  }
+	UnassignableOperand
+
+	// NoNewVar occurs when a short variable declaration (':=') does not declare
+	// new variables.
+	//
+	// Example:
+	//  func f() {
+	//  	x := 1
+	//  	x := 2
+	//  }
+	NoNewVar
+
+	// MultiValAssignOp occurs when an assignment operation (+=, *=, etc) does
+	// not have single-valued left-hand or right-hand side.
+	//
+	// Per the spec:
+	//  "In assignment operations, both the left- and right-hand expression lists
+	//  must contain exactly one single-valued expression"
+	//
+	// Example:
+	//  func f() int {
+	//  	x, y := 1, 2
+	//  	x, y += 1
+	//  	return x + y
+	//  }
+	MultiValAssignOp
+
+	// InvalidIfaceAssign occurs when a value of type T is used as an
+	// interface, but T does not implement a method of the expected interface.
+	//
+	// Example:
+	//  type I interface {
+	//  	f()
+	//  }
+	//
+	//  type T int
+	//
+	//  var x I = T(1)
+	InvalidIfaceAssign
+
+	// InvalidChanAssign occurs when a chan assignment is invalid.
+	//
+	// Per the spec, a value x is assignable to a channel type T if:
+	//  "x is a bidirectional channel value, T is a channel type, x's type V and
+	//  T have identical element types, and at least one of V or T is not a
+	//  defined type."
+	//
+	// Example:
+	//  type T1 chan int
+	//  type T2 chan int
+	//
+	//  var x T1
+	//  // Invalid assignment because both types are named
+	//  var _ T2 = x
+	InvalidChanAssign
+
+	// IncompatibleAssign occurs when the type of the right-hand side expression
+	// in an assignment cannot be assigned to the type of the variable being
+	// assigned.
+	//
+	// Example:
+	//  var x []int
+	//  var _ int = x
+	IncompatibleAssign
+
+	// UnaddressableFieldAssign occurs when trying to assign to a struct field
+	// in a map value.
+	//
+	// Example:
+	//  func f() {
+	//  	m := make(map[string]struct{i int})
+	//  	m["foo"].i = 42
+	//  }
+	UnaddressableFieldAssign
+
+	/* decls > type (+ other type expression codes) */
+
+	// NotAType occurs when the identifier used as the underlying type in a type
+	// declaration or the right-hand side of a type alias does not denote a type.
+	//
+	// Example:
+	//  var S = 2
+	//
+	//  type T S
+	NotAType
+
+	// InvalidArrayLen occurs when an array length is not a constant value.
+	//
+	// Example:
+	//  var n = 3
+	//  var _ = [n]int{}
+	InvalidArrayLen
+
+	// BlankIfaceMethod occurs when a method name is '_'.
+	//
+	// Per the spec:
+	//  "The name of each explicitly specified method must be unique and not
+	//  blank."
+	//
+	// Example:
+	//  type T interface {
+	//  	_(int)
+	//  }
+	BlankIfaceMethod
+
+	// IncomparableMapKey occurs when a map key type does not support the == and
+	// != operators.
+	//
+	// Per the spec:
+	//  "The comparison operators == and != must be fully defined for operands of
+	//  the key type; thus the key type must not be a function, map, or slice."
+	//
+	// Example:
+	//  var x map[T]int
+	//
+	//  type T []int
+	IncomparableMapKey
+
+	// InvalidIfaceEmbed occurs when a non-interface type is embedded in an
+	// interface.
+	//
+	// Example:
+	//  type T struct {}
+	//
+	//  func (T) m()
+	//
+	//  type I interface {
+	//  	T
+	//  }
+	InvalidIfaceEmbed
+
+	// InvalidPtrEmbed occurs when an embedded field is of the pointer form *T,
+	// and T itself is itself a pointer, an unsafe.Pointer, or an interface.
+	//
+	// Per the spec:
+	//  "An embedded field must be specified as a type name T or as a pointer to
+	//  a non-interface type name *T, and T itself may not be a pointer type."
+	//
+	// Example:
+	//  type T *int
+	//
+	//  type S struct {
+	//  	*T
+	//  }
+	InvalidPtrEmbed
+
+	/* decls > func and method */
+
+	// BadRecv occurs when a method declaration does not have exactly one
+	// receiver parameter.
+	//
+	// Example:
+	//  func () _() {}
+	BadRecv
+
+	// InvalidRecv occurs when a receiver type expression is not of the form T
+	// or *T, or T is a pointer type.
+	//
+	// Example:
+	//  type T struct {}
+	//
+	//  func (**T) m() {}
+	InvalidRecv
+
+	// DuplicateFieldAndMethod occurs when an identifier appears as both a field
+	// and method name.
+	//
+	// Example:
+	//  type T struct {
+	//  	m int
+	//  }
+	//
+	//  func (T) m() {}
+	DuplicateFieldAndMethod
+
+	// DuplicateMethod occurs when two methods on the same receiver type have
+	// the same name.
+	//
+	// Example:
+	//  type T struct {}
+	//  func (T) m() {}
+	//  func (T) m(i int) int { return i }
+	DuplicateMethod
+
+	/* decls > special */
+
+	// InvalidBlank occurs when a blank identifier is used as a value or type.
+	//
+	// Per the spec:
+	//  "The blank identifier may appear as an operand only on the left-hand side
+	//  of an assignment."
+	//
+	// Example:
+	//  var x = _
+	InvalidBlank
+
+	// InvalidIota occurs when the predeclared identifier iota is used outside
+	// of a constant declaration.
+	//
+	// Example:
+	//  var x = iota
+	InvalidIota
+
+	// MissingInitBody occurs when an init function is missing its body.
+	//
+	// Example:
+	//  func init()
+	MissingInitBody
+
+	// InvalidInitSig occurs when an init function declares parameters or
+	// results.
+	//
+	// Example:
+	//  func init() int { return 1 }
+	InvalidInitSig
+
+	// InvalidInitDecl occurs when init is declared as anything other than a
+	// function.
+	//
+	// Example:
+	//  var init = 1
+	InvalidInitDecl
+
+	// InvalidMainDecl occurs when main is declared as anything other than a
+	// function, in a main package.
+	InvalidMainDecl
+
+	/* exprs */
+
+	// TooManyValues occurs when a function returns too many values for the
+	// expression context in which it is used.
+	//
+	// Example:
+	//  func ReturnTwo() (int, int) {
+	//  	return 1, 2
+	//  }
+	//
+	//  var x = ReturnTwo()
+	TooManyValues
+
+	// NotAnExpr occurs when a type expression is used where a value expression
+	// is expected.
+	//
+	// Example:
+	//  type T struct {}
+	//
+	//  func f() {
+	//  	T
+	//  }
+	NotAnExpr
+
+	/* exprs > const */
+
+	// TruncatedFloat occurs when a float constant is truncated to an integer
+	// value.
+	//
+	// Example:
+	//  var _ int = 98.6
+	TruncatedFloat
+
+	// NumericOverflow occurs when a numeric constant overflows its target type.
+	//
+	// Example:
+	//  var x int8 = 1000
+	NumericOverflow
+
+	/* exprs > operation */
+
+	// UndefinedOp occurs when an operator is not defined for the type(s) used
+	// in an operation.
+	//
+	// Example:
+	//  var c = "a" - "b"
+	UndefinedOp
+
+	// MismatchedTypes occurs when operand types are incompatible in a binary
+	// operation.
+	//
+	// Example:
+	//  var a = "hello"
+	//  var b = 1
+	//  var c = a - b
+	MismatchedTypes
+
+	// DivByZero occurs when a division operation is provable at compile
+	// time to be a division by zero.
+	//
+	// Example:
+	//  const divisor = 0
+	//  var x int = 1/divisor
+	DivByZero
+
+	// NonNumericIncDec occurs when an increment or decrement operator is
+	// applied to a non-numeric value.
+	//
+	// Example:
+	//  func f() {
+	//  	var c = "c"
+	//  	c++
+	//  }
+	NonNumericIncDec
+
+	/* exprs > ptr */
+
+	// UnaddressableOperand occurs when the & operator is applied to an
+	// unaddressable expression.
+	//
+	// Example:
+	//  var x = &1
+	UnaddressableOperand
+
+	// InvalidIndirection occurs when a non-pointer value is indirected via the
+	// '*' operator.
+	//
+	// Example:
+	//  var x int
+	//  var y = *x
+	InvalidIndirection
+
+	/* exprs > [] */
+
+	// NonIndexableOperand occurs when an index operation is applied to a value
+	// that cannot be indexed.
+	//
+	// Example:
+	//  var x = 1
+	//  var y = x[1]
+	NonIndexableOperand
+
+	// InvalidIndex occurs when an index argument is not of integer type,
+	// negative, or out-of-bounds.
+	//
+	// Example:
+	//  var s = [...]int{1,2,3}
+	//  var x = s[5]
+	//
+	// Example:
+	//  var s = []int{1,2,3}
+	//  var _ = s[-1]
+	//
+	// Example:
+	//  var s = []int{1,2,3}
+	//  var i string
+	//  var _ = s[i]
+	InvalidIndex
+
+	// SwappedSliceIndices occurs when constant indices in a slice expression
+	// are decreasing in value.
+	//
+	// Example:
+	//  var _ = []int{1,2,3}[2:1]
+	SwappedSliceIndices
+
+	/* operators > slice */
+
+	// NonSliceableOperand occurs when a slice operation is applied to a value
+	// whose type is not sliceable, or is unaddressable.
+	//
+	// Example:
+	//  var x = [...]int{1, 2, 3}[:1]
+	//
+	// Example:
+	//  var x = 1
+	//  var y = 1[:1]
+	NonSliceableOperand
+
+	// InvalidSliceExpr occurs when a three-index slice expression (a[x:y:z]) is
+	// applied to a string.
+	//
+	// Example:
+	//  var s = "hello"
+	//  var x = s[1:2:3]
+	InvalidSliceExpr
+
+	/* exprs > shift */
+
+	// InvalidShiftCount occurs when the right-hand side of a shift operation is
+	// either non-integer, negative, or too large.
+	//
+	// Example:
+	//  var (
+	//  	x string
+	//  	y int = 1 << x
+	//  )
+	InvalidShiftCount
+
+	// InvalidShiftOperand occurs when the shifted operand is not an integer.
+	//
+	// Example:
+	//  var s = "hello"
+	//  var x = s << 2
+	InvalidShiftOperand
+
+	/* exprs > chan */
+
+	// InvalidReceive occurs when there is a channel receive from a value that
+	// is either not a channel, or is a send-only channel.
+	//
+	// Example:
+	//  func f() {
+	//  	var x = 1
+	//  	<-x
+	//  }
+	InvalidReceive
+
+	// InvalidSend occurs when there is a channel send to a value that is not a
+	// channel, or is a receive-only channel.
+	//
+	// Example:
+	//  func f() {
+	//  	var x = 1
+	//  	x <- "hello!"
+	//  }
+	InvalidSend
+
+	/* exprs > literal */
+
+	// DuplicateLitKey occurs when an index is duplicated in a slice, array, or
+	// map literal.
+	//
+	// Example:
+	//  var _ = []int{0:1, 0:2}
+	//
+	// Example:
+	//  var _ = map[string]int{"a": 1, "a": 2}
+	DuplicateLitKey
+
+	// MissingLitKey occurs when a map literal is missing a key expression.
+	//
+	// Example:
+	//  var _ = map[string]int{1}
+	MissingLitKey
+
+	// InvalidLitIndex occurs when the key in a key-value element of a slice or
+	// array literal is not an integer constant.
+	//
+	// Example:
+	//  var i = 0
+	//  var x = []string{i: "world"}
+	InvalidLitIndex
+
+	// OversizeArrayLit occurs when an array literal exceeds its length.
+	//
+	// Example:
+	//  var _ = [2]int{1,2,3}
+	OversizeArrayLit
+
+	// MixedStructLit occurs when a struct literal contains a mix of positional
+	// and named elements.
+	//
+	// Example:
+	//  var _ = struct{i, j int}{i: 1, 2}
+	MixedStructLit
+
+	// InvalidStructLit occurs when a positional struct literal has an incorrect
+	// number of values.
+	//
+	// Example:
+	//  var _ = struct{i, j int}{1,2,3}
+	InvalidStructLit
+
+	// MissingLitField occurs when a struct literal refers to a field that does
+	// not exist on the struct type.
+	//
+	// Example:
+	//  var _ = struct{i int}{j: 2}
+	MissingLitField
+
+	// DuplicateLitField occurs when a struct literal contains duplicated
+	// fields.
+	//
+	// Example:
+	//  var _ = struct{i int}{i: 1, i: 2}
+	DuplicateLitField
+
+	// UnexportedLitField occurs when a positional struct literal implicitly
+	// assigns an unexported field of an imported type.
+	UnexportedLitField
+
+	// InvalidLitField occurs when a field name is not a valid identifier.
+	//
+	// Example:
+	//  var _ = struct{i int}{1: 1}
+	InvalidLitField
+
+	// UntypedLit occurs when a composite literal omits a required type
+	// identifier.
+	//
+	// Example:
+	//  type outer struct{
+	//  	inner struct { i int }
+	//  }
+	//
+	//  var _ = outer{inner: {1}}
+	UntypedLit
+
+	// InvalidLit occurs when a composite literal expression does not match its
+	// type.
+	//
+	// Example:
+	//  type P *struct{
+	//  	x int
+	//  }
+	//  var _ = P {}
+	InvalidLit
+
+	/* exprs > selector */
+
+	// AmbiguousSelector occurs when a selector is ambiguous.
+	//
+	// Example:
+	//  type E1 struct { i int }
+	//  type E2 struct { i int }
+	//  type T struct { E1; E2 }
+	//
+	//  var x T
+	//  var _ = x.i
+	AmbiguousSelector
+
+	// UndeclaredImportedName occurs when a package-qualified identifier is
+	// undeclared by the imported package.
+	//
+	// Example:
+	//  import "go/types"
+	//
+	//  var _ = types.NotAnActualIdentifier
+	UndeclaredImportedName
+
+	// UnexportedName occurs when a selector refers to an unexported identifier
+	// of an imported package.
+	//
+	// Example:
+	//  import "reflect"
+	//
+	//  type _ reflect.flag
+	UnexportedName
+
+	// UndeclaredName occurs when an identifier is not declared in the current
+	// scope.
+	//
+	// Example:
+	//  var x T
+	UndeclaredName
+
+	// MissingFieldOrMethod occurs when a selector references a field or method
+	// that does not exist.
+	//
+	// Example:
+	//  type T struct {}
+	//
+	//  var x = T{}.f
+	MissingFieldOrMethod
+
+	/* exprs > ... */
+
+	// BadDotDotDotSyntax occurs when a "..." occurs in a context where it is
+	// not valid.
+	//
+	// Example:
+	//  var _ = map[int][...]int{0: {}}
+	BadDotDotDotSyntax
+
+	// NonVariadicDotDotDot occurs when a "..." is used on the final argument to
+	// a non-variadic function.
+	//
+	// Example:
+	//  func printArgs(s []string) {
+	//  	for _, a := range s {
+	//  		println(a)
+	//  	}
+	//  }
+	//
+	//  func f() {
+	//  	s := []string{"a", "b", "c"}
+	//  	printArgs(s...)
+	//  }
+	NonVariadicDotDotDot
+
+	// MisplacedDotDotDot occurs when a "..." is used somewhere other than the
+	// final argument to a function call.
+	//
+	// Example:
+	//  func printArgs(args ...int) {
+	//  	for _, a := range args {
+	//  		println(a)
+	//  	}
+	//  }
+	//
+	//  func f() {
+	//  	a := []int{1,2,3}
+	//  	printArgs(0, a...)
+	//  }
+	MisplacedDotDotDot
+
+	// InvalidDotDotDotOperand occurs when a "..." operator is applied to a
+	// single-valued operand.
+	//
+	// Example:
+	//  func printArgs(args ...int) {
+	//  	for _, a := range args {
+	//  		println(a)
+	//  	}
+	//  }
+	//
+	//  func f() {
+	//  	a := 1
+	//  	printArgs(a...)
+	//  }
+	//
+	// Example:
+	//  func args() (int, int) {
+	//  	return 1, 2
+	//  }
+	//
+	//  func printArgs(args ...int) {
+	//  	for _, a := range args {
+	//  		println(a)
+	//  	}
+	//  }
+	//
+	//  func g() {
+	//  	printArgs(args()...)
+	//  }
+	InvalidDotDotDotOperand
+
+	// InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
+	// function.
+	//
+	// Example:
+	//  var s = []int{1, 2, 3}
+	//  var l = len(s...)
+	InvalidDotDotDot
+
+	/* exprs > built-in */
+
+	// UncalledBuiltin occurs when a built-in function is used as a
+	// function-valued expression, instead of being called.
+	//
+	// Per the spec:
+	//  "The built-in functions do not have standard Go types, so they can only
+	//  appear in call expressions; they cannot be used as function values."
+	//
+	// Example:
+	//  var _ = copy
+	UncalledBuiltin
+
+	// InvalidAppend occurs when append is called with a first argument that is
+	// not a slice.
+	//
+	// Example:
+	//  var _ = append(1, 2)
+	InvalidAppend
+
+	// InvalidCap occurs when an argument to the cap built-in function is not of
+	// supported type.
+	//
+	// See https://golang.org/ref/spec#Lengthand_capacity for information on
+	// which underlying types are supported as arguments to cap and len.
+	//
+	// Example:
+	//  var s = 2
+	//  var x = cap(s)
+	InvalidCap
+
+	// InvalidClose occurs when close(...) is called with an argument that is
+	// not of channel type, or that is a receive-only channel.
+	//
+	// Example:
+	//  func f() {
+	//  	var x int
+	//  	close(x)
+	//  }
+	InvalidClose
+
+	// InvalidCopy occurs when the arguments are not of slice type or do not
+	// have compatible type.
+	//
+	// See https://golang.org/ref/spec#Appendingand_copying_slices for more
+	// information on the type requirements for the copy built-in.
+	//
+	// Example:
+	//  func f() {
+	//  	var x []int
+	//  	y := []int64{1,2,3}
+	//  	copy(x, y)
+	//  }
+	InvalidCopy
+
+	// InvalidComplex occurs when the complex built-in function is called with
+	// arguments with incompatible types.
+	//
+	// Example:
+	//  var _ = complex(float32(1), float64(2))
+	InvalidComplex
+
+	// InvalidDelete occurs when the delete built-in function is called with a
+	// first argument that is not a map.
+	//
+	// Example:
+	//  func f() {
+	//  	m := "hello"
+	//  	delete(m, "e")
+	//  }
+	InvalidDelete
+
+	// InvalidImag occurs when the imag built-in function is called with an
+	// argument that does not have complex type.
+	//
+	// Example:
+	//  var _ = imag(int(1))
+	InvalidImag
+
+	// InvalidLen occurs when an argument to the len built-in function is not of
+	// supported type.
+	//
+	// See https://golang.org/ref/spec#Lengthand_capacity for information on
+	// which underlying types are supported as arguments to cap and len.
+	//
+	// Example:
+	//  var s = 2
+	//  var x = len(s)
+	InvalidLen
+
+	// SwappedMakeArgs occurs when make is called with three arguments, and its
+	// length argument is larger than its capacity argument.
+	//
+	// Example:
+	//  var x = make([]int, 3, 2)
+	SwappedMakeArgs
+
+	// InvalidMake occurs when make is called with an unsupported type argument.
+	//
+	// See https://golang.org/ref/spec#Makingslices_maps_and_channels for
+	// information on the types that may be created using make.
+	//
+	// Example:
+	//  var x = make(int)
+	InvalidMake
+
+	// InvalidReal occurs when the real built-in function is called with an
+	// argument that does not have complex type.
+	//
+	// Example:
+	//  var _ = real(int(1))
+	InvalidReal
+
+	/* exprs > assertion */
+
+	// InvalidAssert occurs when a type assertion is applied to a
+	// value that is not of interface type.
+	//
+	// Example:
+	//  var x = 1
+	//  var _ = x.(float64)
+	InvalidAssert
+
+	// ImpossibleAssert occurs for a type assertion x.(T) when the value x of
+	// interface cannot have dynamic type T, due to a missing or mismatching
+	// method on T.
+	//
+	// Example:
+	//  type T int
+	//
+	//  func (t *T) m() int { return int(*t) }
+	//
+	//  type I interface { m() int }
+	//
+	//  var x I
+	//  var _ = x.(T)
+	ImpossibleAssert
+
+	/* exprs > conversion */
+
+	// InvalidConversion occurs when the argument type cannot be converted to the
+	// target.
+	//
+	// See https://golang.org/ref/spec#Conversions for the rules of
+	// convertibility.
+	//
+	// Example:
+	//  var x float64
+	//  var _ = string(x)
+	InvalidConversion
+
+	// InvalidUntypedConversion occurs when an there is no valid implicit
+	// conversion from an untyped value satisfying the type constraints of the
+	// context in which it is used.
+	//
+	// Example:
+	//  var _ = 1 + ""
+	InvalidUntypedConversion
+
+	/* offsetof */
+
+	// BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument
+	// that is not a selector expression.
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  var x int
+	//  var _ = unsafe.Offsetof(x)
+	BadOffsetofSyntax
+
+	// InvalidOffsetof occurs when unsafe.Offsetof is called with a method
+	// selector, rather than a field selector, or when the field is embedded via
+	// a pointer.
+	//
+	// Per the spec:
+	//
+	//  "If f is an embedded field, it must be reachable without pointer
+	//  indirections through fields of the struct. "
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  type T struct { f int }
+	//  type S struct { *T }
+	//  var s S
+	//  var _ = unsafe.Offsetof(s.f)
+	//
+	// Example:
+	//  import "unsafe"
+	//
+	//  type S struct{}
+	//
+	//  func (S) m() {}
+	//
+	//  var s S
+	//  var _ = unsafe.Offsetof(s.m)
+	InvalidOffsetof
+
+	/* control flow > scope */
+
+	// UnusedExpr occurs when a side-effect free expression is used as a
+	// statement. Such a statement has no effect.
+	//
+	// Example:
+	//  func f(i int) {
+	//  	i*i
+	//  }
+	UnusedExpr
+
+	// UnusedVar occurs when a variable is declared but unused.
+	//
+	// Example:
+	//  func f() {
+	//  	x := 1
+	//  }
+	UnusedVar
+
+	// MissingReturn occurs when a function with results is missing a return
+	// statement.
+	//
+	// Example:
+	//  func f() int {}
+	MissingReturn
+
+	// WrongResultCount occurs when a return statement returns an incorrect
+	// number of values.
+	//
+	// Example:
+	//  func ReturnOne() int {
+	//  	return 1, 2
+	//  }
+	WrongResultCount
+
+	// OutOfScopeResult occurs when the name of a value implicitly returned by
+	// an empty return statement is shadowed in a nested scope.
+	//
+	// Example:
+	//  func factor(n int) (i int) {
+	//  	for i := 2; i < n; i++ {
+	//  		if n%i == 0 {
+	//  			return
+	//  		}
+	//  	}
+	//  	return 0
+	//  }
+	OutOfScopeResult
+
+	/* control flow > if */
+
+	// InvalidCond occurs when an if condition is not a boolean expression.
+	//
+	// Example:
+	//  func checkReturn(i int) {
+	//  	if i {
+	//  		panic("non-zero return")
+	//  	}
+	//  }
+	InvalidCond
+
+	/* control flow > for */
+
+	// InvalidPostDecl occurs when there is a declaration in a for-loop post
+	// statement.
+	//
+	// Example:
+	//  func f() {
+	//  	for i := 0; i < 10; j := 0 {}
+	//  }
+	InvalidPostDecl
+
+	// InvalidChanRange occurs when a send-only channel used in a range
+	// expression.
+	//
+	// Example:
+	//  func sum(c chan<- int) {
+	//  	s := 0
+	//  	for i := range c {
+	//  		s += i
+	//  	}
+	//  }
+	InvalidChanRange
+
+	// InvalidIterVar occurs when two iteration variables are used while ranging
+	// over a channel.
+	//
+	// Example:
+	//  func f(c chan int) {
+	//  	for k, v := range c {
+	//  		println(k, v)
+	//  	}
+	//  }
+	InvalidIterVar
+
+	// InvalidRangeExpr occurs when the type of a range expression is not array,
+	// slice, string, map, or channel.
+	//
+	// Example:
+	//  func f(i int) {
+	//  	for j := range i {
+	//  		println(j)
+	//  	}
+	//  }
+	InvalidRangeExpr
+
+	/* control flow > switch */
+
+	// MisplacedBreak occurs when a break statement is not within a for, switch,
+	// or select statement of the innermost function definition.
+	//
+	// Example:
+	//  func f() {
+	//  	break
+	//  }
+	MisplacedBreak
+
+	// MisplacedContinue occurs when a continue statement is not within a for
+	// loop of the innermost function definition.
+	//
+	// Example:
+	//  func sumeven(n int) int {
+	//  	proceed := func() {
+	//  		continue
+	//  	}
+	//  	sum := 0
+	//  	for i := 1; i <= n; i++ {
+	//  		if i % 2 != 0 {
+	//  			proceed()
+	//  		}
+	//  		sum += i
+	//  	}
+	//  	return sum
+	//  }
+	MisplacedContinue
+
+	// MisplacedFallthrough occurs when a fallthrough statement is not within an
+	// expression switch.
+	//
+	// Example:
+	//  func typename(i interface{}) string {
+	//  	switch i.(type) {
+	//  	case int64:
+	//  		fallthrough
+	//  	case int:
+	//  		return "int"
+	//  	}
+	//  	return "unsupported"
+	//  }
+	MisplacedFallthrough
+
+	// DuplicateCase occurs when a type or expression switch has duplicate
+	// cases.
+	//
+	// Example:
+	//  func printInt(i int) {
+	//  	switch i {
+	//  	case 1:
+	//  		println("one")
+	//  	case 1:
+	//  		println("One")
+	//  	}
+	//  }
+	DuplicateCase
+
+	// DuplicateDefault occurs when a type or expression switch has multiple
+	// default clauses.
+	//
+	// Example:
+	//  func printInt(i int) {
+	//  	switch i {
+	//  	case 1:
+	//  		println("one")
+	//  	default:
+	//  		println("One")
+	//  	default:
+	//  		println("1")
+	//  	}
+	//  }
+	DuplicateDefault
+
+	// BadTypeKeyword occurs when a .(type) expression is used anywhere other
+	// than a type switch.
+	//
+	// Example:
+	//  type I interface {
+	//  	m()
+	//  }
+	//  var t I
+	//  var _ = t.(type)
+	BadTypeKeyword
+
+	// InvalidTypeSwitch occurs when .(type) is used on an expression that is
+	// not of interface type.
+	//
+	// Example:
+	//  func f(i int) {
+	//  	switch x := i.(type) {}
+	//  }
+	InvalidTypeSwitch
+
+	/* control flow > select */
+
+	// InvalidSelectCase occurs when a select case is not a channel send or
+	// receive.
+	//
+	// Example:
+	//  func checkChan(c <-chan int) bool {
+	//  	select {
+	//  	case c:
+	//  		return true
+	//  	default:
+	//  		return false
+	//  	}
+	//  }
+	InvalidSelectCase
+
+	/* control flow > labels and jumps */
+
+	// UndeclaredLabel occurs when an undeclared label is jumped to.
+	//
+	// Example:
+	//  func f() {
+	//  	goto L
+	//  }
+	UndeclaredLabel
+
+	// DuplicateLabel occurs when a label is declared more than once.
+	//
+	// Example:
+	//  func f() int {
+	//  L:
+	//  L:
+	//  	return 1
+	//  }
+	DuplicateLabel
+
+	// MisplacedLabel occurs when a break or continue label is not on a for,
+	// switch, or select statement.
+	//
+	// Example:
+	//  func f() {
+	//  L:
+	//  	a := []int{1,2,3}
+	//  	for _, e := range a {
+	//  		if e > 10 {
+	//  			break L
+	//  		}
+	//  		println(a)
+	//  	}
+	//  }
+	MisplacedLabel
+
+	// UnusedLabel occurs when a label is declared but not used.
+	//
+	// Example:
+	//  func f() {
+	//  L:
+	//  }
+	UnusedLabel
+
+	// JumpOverDecl occurs when a label jumps over a variable declaration.
+	//
+	// Example:
+	//  func f() int {
+	//  	goto L
+	//  	x := 2
+	//  L:
+	//  	x++
+	//  	return x
+	//  }
+	JumpOverDecl
+
+	// JumpIntoBlock occurs when a forward jump goes to a label inside a nested
+	// block.
+	//
+	// Example:
+	//  func f(x int) {
+	//  	goto L
+	//  	if x > 0 {
+	//  	L:
+	//  		print("inside block")
+	//  	}
+	// }
+	JumpIntoBlock
+
+	/* control flow > calls */
+
+	// InvalidMethodExpr occurs when a pointer method is called but the argument
+	// is not addressable.
+	//
+	// Example:
+	//  type T struct {}
+	//
+	//  func (*T) m() int { return 1 }
+	//
+	//  var _ = T.m(T{})
+	InvalidMethodExpr
+
+	// WrongArgCount occurs when too few or too many arguments are passed by a
+	// function call.
+	//
+	// Example:
+	//  func f(i int) {}
+	//  var x = f()
+	WrongArgCount
+
+	// InvalidCall occurs when an expression is called that is not of function
+	// type.
+	//
+	// Example:
+	//  var x = "x"
+	//  var y = x()
+	InvalidCall
+
+	/* control flow > suspended */
+
+	// UnusedResults occurs when a restricted expression-only built-in function
+	// is suspended via go or defer. Such a suspension discards the results of
+	// these side-effect free built-in functions, and therefore is ineffectual.
+	//
+	// Example:
+	//  func f(a []int) int {
+	//  	defer len(a)
+	//  	return i
+	//  }
+	UnusedResults
+
+	// InvalidDefer occurs when a deferred expression is not a function call,
+	// for example if the expression is a type conversion.
+	//
+	// Example:
+	//  func f(i int) int {
+	//  	defer int32(i)
+	//  	return i
+	//  }
+	InvalidDefer
+
+	// InvalidGo occurs when a go expression is not a function call, for example
+	// if the expression is a type conversion.
+	//
+	// Example:
+	//  func f(i int) int {
+	//  	go int32(i)
+	//  	return i
+	//  }
+	InvalidGo
+)
diff --git a/internal/typesinternal/errorcode_string.go b/internal/typesinternal/errorcode_string.go
new file mode 100644
index 0000000..97f3ec8
--- /dev/null
+++ b/internal/typesinternal/errorcode_string.go
@@ -0,0 +1,152 @@
+// Code generated by "stringer -type=ErrorCode"; DO NOT EDIT.
+
+package typesinternal
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[Test-1]
+	_ = x[BlankPkgName-2]
+	_ = x[MismatchedPkgName-3]
+	_ = x[InvalidPkgUse-4]
+	_ = x[BadImportPath-5]
+	_ = x[BrokenImport-6]
+	_ = x[ImportCRenamed-7]
+	_ = x[UnusedImport-8]
+	_ = x[InvalidInitCycle-9]
+	_ = x[DuplicateDecl-10]
+	_ = x[InvalidDeclCycle-11]
+	_ = x[InvalidTypeCycle-12]
+	_ = x[InvalidConstInit-13]
+	_ = x[InvalidConstVal-14]
+	_ = x[InvalidConstType-15]
+	_ = x[UntypedNil-16]
+	_ = x[WrongAssignCount-17]
+	_ = x[UnassignableOperand-18]
+	_ = x[NoNewVar-19]
+	_ = x[MultiValAssignOp-20]
+	_ = x[InvalidIfaceAssign-21]
+	_ = x[InvalidChanAssign-22]
+	_ = x[IncompatibleAssign-23]
+	_ = x[UnaddressableFieldAssign-24]
+	_ = x[NotAType-25]
+	_ = x[InvalidArrayLen-26]
+	_ = x[BlankIfaceMethod-27]
+	_ = x[IncomparableMapKey-28]
+	_ = x[InvalidIfaceEmbed-29]
+	_ = x[InvalidPtrEmbed-30]
+	_ = x[BadRecv-31]
+	_ = x[InvalidRecv-32]
+	_ = x[DuplicateFieldAndMethod-33]
+	_ = x[DuplicateMethod-34]
+	_ = x[InvalidBlank-35]
+	_ = x[InvalidIota-36]
+	_ = x[MissingInitBody-37]
+	_ = x[InvalidInitSig-38]
+	_ = x[InvalidInitDecl-39]
+	_ = x[InvalidMainDecl-40]
+	_ = x[TooManyValues-41]
+	_ = x[NotAnExpr-42]
+	_ = x[TruncatedFloat-43]
+	_ = x[NumericOverflow-44]
+	_ = x[UndefinedOp-45]
+	_ = x[MismatchedTypes-46]
+	_ = x[DivByZero-47]
+	_ = x[NonNumericIncDec-48]
+	_ = x[UnaddressableOperand-49]
+	_ = x[InvalidIndirection-50]
+	_ = x[NonIndexableOperand-51]
+	_ = x[InvalidIndex-52]
+	_ = x[SwappedSliceIndices-53]
+	_ = x[NonSliceableOperand-54]
+	_ = x[InvalidSliceExpr-55]
+	_ = x[InvalidShiftCount-56]
+	_ = x[InvalidShiftOperand-57]
+	_ = x[InvalidReceive-58]
+	_ = x[InvalidSend-59]
+	_ = x[DuplicateLitKey-60]
+	_ = x[MissingLitKey-61]
+	_ = x[InvalidLitIndex-62]
+	_ = x[OversizeArrayLit-63]
+	_ = x[MixedStructLit-64]
+	_ = x[InvalidStructLit-65]
+	_ = x[MissingLitField-66]
+	_ = x[DuplicateLitField-67]
+	_ = x[UnexportedLitField-68]
+	_ = x[InvalidLitField-69]
+	_ = x[UntypedLit-70]
+	_ = x[InvalidLit-71]
+	_ = x[AmbiguousSelector-72]
+	_ = x[UndeclaredImportedName-73]
+	_ = x[UnexportedName-74]
+	_ = x[UndeclaredName-75]
+	_ = x[MissingFieldOrMethod-76]
+	_ = x[BadDotDotDotSyntax-77]
+	_ = x[NonVariadicDotDotDot-78]
+	_ = x[MisplacedDotDotDot-79]
+	_ = x[InvalidDotDotDotOperand-80]
+	_ = x[InvalidDotDotDot-81]
+	_ = x[UncalledBuiltin-82]
+	_ = x[InvalidAppend-83]
+	_ = x[InvalidCap-84]
+	_ = x[InvalidClose-85]
+	_ = x[InvalidCopy-86]
+	_ = x[InvalidComplex-87]
+	_ = x[InvalidDelete-88]
+	_ = x[InvalidImag-89]
+	_ = x[InvalidLen-90]
+	_ = x[SwappedMakeArgs-91]
+	_ = x[InvalidMake-92]
+	_ = x[InvalidReal-93]
+	_ = x[InvalidAssert-94]
+	_ = x[ImpossibleAssert-95]
+	_ = x[InvalidConversion-96]
+	_ = x[InvalidUntypedConversion-97]
+	_ = x[BadOffsetofSyntax-98]
+	_ = x[InvalidOffsetof-99]
+	_ = x[UnusedExpr-100]
+	_ = x[UnusedVar-101]
+	_ = x[MissingReturn-102]
+	_ = x[WrongResultCount-103]
+	_ = x[OutOfScopeResult-104]
+	_ = x[InvalidCond-105]
+	_ = x[InvalidPostDecl-106]
+	_ = x[InvalidChanRange-107]
+	_ = x[InvalidIterVar-108]
+	_ = x[InvalidRangeExpr-109]
+	_ = x[MisplacedBreak-110]
+	_ = x[MisplacedContinue-111]
+	_ = x[MisplacedFallthrough-112]
+	_ = x[DuplicateCase-113]
+	_ = x[DuplicateDefault-114]
+	_ = x[BadTypeKeyword-115]
+	_ = x[InvalidTypeSwitch-116]
+	_ = x[InvalidSelectCase-117]
+	_ = x[UndeclaredLabel-118]
+	_ = x[DuplicateLabel-119]
+	_ = x[MisplacedLabel-120]
+	_ = x[UnusedLabel-121]
+	_ = x[JumpOverDecl-122]
+	_ = x[JumpIntoBlock-123]
+	_ = x[InvalidMethodExpr-124]
+	_ = x[WrongArgCount-125]
+	_ = x[InvalidCall-126]
+	_ = x[UnusedResults-127]
+	_ = x[InvalidDefer-128]
+	_ = x[InvalidGo-129]
+}
+
+const _ErrorCode_name = "TestBlankPkgNameMismatchedPkgNameInvalidPkgUseBadImportPathBrokenImportImportCRenamedUnusedImportInvalidInitCycleDuplicateDeclInvalidDeclCycleInvalidTypeCycleInvalidConstInitInvalidConstValInvalidConstTypeUntypedNilWrongAssignCountUnassignableOperandNoNewVarMultiValAssignOpInvalidIfaceAssignInvalidChanAssignIncompatibleAssignUnaddressableFieldAssignNotATypeInvalidArrayLenBlankIfaceMethodIncomparableMapKeyInvalidIfaceEmbedInvalidPtrEmbedBadRecvInvalidRecvDuplicateFieldAndMethodDuplicateMethodInvalidBlankInvalidIotaMissingInitBodyInvalidInitSigInvalidInitDeclInvalidMainDeclTooManyValuesNotAnExprTruncatedFloatNumericOverflowUndefinedOpMismatchedTypesDivByZeroNonNumericIncDecUnaddressableOperandInvalidIndirectionNonIndexableOperandInvalidIndexSwappedSliceIndicesNonSliceableOperandInvalidSliceExprInvalidShiftCountInvalidShiftOperandInvalidReceiveInvalidSendDuplicateLitKeyMissingLitKeyInvalidLitIndexOversizeArrayLitMixedStructLitInvalidStructLitMissingLitFieldDuplicateLitFieldUnexportedLitFieldInvalidLitFieldUntypedLitInvalidLitAmbiguousSelectorUndeclaredImportedNameUnexportedNameUndeclaredNameMissingFieldOrMethodBadDotDotDotSyntaxNonVariadicDotDotDotMisplacedDotDotDotInvalidDotDotDotOperandInvalidDotDotDotUncalledBuiltinInvalidAppendInvalidCapInvalidCloseInvalidCopyInvalidComplexInvalidDeleteInvalidImagInvalidLenSwappedMakeArgsInvalidMakeInvalidRealInvalidAssertImpossibleAssertInvalidConversionInvalidUntypedConversionBadOffsetofSyntaxInvalidOffsetofUnusedExprUnusedVarMissingReturnWrongResultCountOutOfScopeResultInvalidCondInvalidPostDeclInvalidChanRangeInvalidIterVarInvalidRangeExprMisplacedBreakMisplacedContinueMisplacedFallthroughDuplicateCaseDuplicateDefaultBadTypeKeywordInvalidTypeSwitchInvalidSelectCaseUndeclaredLabelDuplicateLabelMisplacedLabelUnusedLabelJumpOverDeclJumpIntoBlockInvalidMethodExprWrongArgCountInvalidCallUnusedResultsInvalidDeferInvalidGo"
+
+var _ErrorCode_index = [...]uint16{0, 4, 16, 33, 46, 59, 71, 85, 97, 113, 126, 142, 158, 174, 189, 205, 215, 231, 250, 258, 274, 292, 309, 327, 351, 359, 374, 390, 408, 425, 440, 447, 458, 481, 496, 508, 519, 534, 548, 563, 578, 591, 600, 614, 629, 640, 655, 664, 680, 700, 718, 737, 749, 768, 787, 803, 820, 839, 853, 864, 879, 892, 907, 923, 937, 953, 968, 985, 1003, 1018, 1028, 1038, 1055, 1077, 1091, 1105, 1125, 1143, 1163, 1181, 1204, 1220, 1235, 1248, 1258, 1270, 1281, 1295, 1308, 1319, 1329, 1344, 1355, 1366, 1379, 1395, 1412, 1436, 1453, 1468, 1478, 1487, 1500, 1516, 1532, 1543, 1558, 1574, 1588, 1604, 1618, 1635, 1655, 1668, 1684, 1698, 1715, 1732, 1747, 1761, 1775, 1786, 1798, 1811, 1828, 1841, 1852, 1865, 1877, 1886}
+
+func (i ErrorCode) String() string {
+	i -= 1
+	if i < 0 || i >= ErrorCode(len(_ErrorCode_index)-1) {
+		return "ErrorCode(" + strconv.FormatInt(int64(i+1), 10) + ")"
+	}
+	return _ErrorCode_name[_ErrorCode_index[i]:_ErrorCode_index[i+1]]
+}