From a4ed05f16747f9958a65c5c279f69e30b6477c9e Mon Sep 17 00:00:00 2001
From: Austin Clements <austin@google.com>
Date: Thu, 15 Jun 2023 16:49:00 -0400
Subject: [PATCH 01/26] cmd/digraph: add "to dot" to emit Graphviz dot

This CL adds "digraph to dot", which prints the graph in Graphviz dot
format, which can then be piped into dot.

Change-Id: I8209d9038bb4e1df1ca2ced427ce14f6df8051db
Reviewed-on: https://go-review.googlesource.com/c/tools/+/503437
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Alan Donovan <adonovan@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
Run-TryBot: Austin Clements <austin@google.com>
---
 cmd/digraph/digraph.go      | 45 ++++++++++++++++++++++++++++++++-----
 cmd/digraph/digraph_test.go | 25 +++++++++++++++++++++
 2 files changed, 65 insertions(+), 5 deletions(-)

diff --git a/cmd/digraph/digraph.go b/cmd/digraph/digraph.go
index 93130a018ce..4d033e1ccdb 100644
--- a/cmd/digraph/digraph.go
+++ b/cmd/digraph/digraph.go
@@ -37,6 +37,8 @@ The support commands are:
 		the set of nodes strongly connected to the specified one
 	focus <node>
 		the subgraph containing all directed paths that pass through the specified node
+	to dot
+		print the graph in Graphviz dot format (other formats may be supported in the future)
 
 Input format:
 
@@ -81,6 +83,11 @@ Show which packages in x/tools depend, perhaps indirectly, on the callgraph pack
 	$ go list -f '{{.ImportPath}} {{join .Imports " "}}' -deps golang.org/x/tools/... |
 		digraph reverse golang.org/x/tools/go/callgraph
 
+Visualize the package dependency graph of the current package:
+
+	$ go list -f '{{.ImportPath}} {{join .Imports " "}}' -deps |
+		digraph to dot | dot -Tpng -o x.png
+
 Using a module graph produced by go mod, show all dependencies of the current module:
 
 	$ go mod graph | digraph forward $(go list -m)
@@ -137,6 +144,8 @@ The support commands are:
 		the set of nodes nodes strongly connected to the specified one
 	focus <node>
 		the subgraph containing all directed paths that pass through the specified node
+	to dot
+		print the graph in Graphviz dot format (other formats may be supported in the future)
 `)
 	os.Exit(2)
 }
@@ -207,6 +216,14 @@ func (g graph) addEdges(from string, to ...string) {
 	}
 }
 
+func (g graph) nodelist() nodelist {
+	nodes := make(nodeset)
+	for node := range g {
+		nodes[node] = true
+	}
+	return nodes.sort()
+}
+
 func (g graph) reachableFrom(roots nodeset) nodeset {
 	seen := make(nodeset)
 	var visit func(node string)
@@ -356,6 +373,20 @@ func (g graph) somepath(from, to string) error {
 	return nil
 }
 
+func (g graph) toDot(w *bytes.Buffer) {
+	fmt.Fprintln(w, "digraph {")
+	for _, src := range g.nodelist() {
+		for _, dst := range g[src].sort() {
+			// Dot's quoting rules appear to align with Go's for escString,
+			// which is the syntax of node IDs. Labels require significantly
+			// more quoting, but that appears not to be necessary if the node ID
+			// is implicitly used as the label.
+			fmt.Fprintf(w, "\t%q -> %q;\n", src, dst)
+		}
+	}
+	fmt.Fprintln(w, "}")
+}
+
 func parse(rd io.Reader) (graph, error) {
 	g := make(graph)
 
@@ -404,11 +435,7 @@ func digraph(cmd string, args []string) error {
 		if len(args) != 0 {
 			return fmt.Errorf("usage: digraph nodes")
 		}
-		nodes := make(nodeset)
-		for node := range g {
-			nodes[node] = true
-		}
-		nodes.sort().println("\n")
+		g.nodelist().println("\n")
 
 	case "degree":
 		if len(args) != 0 {
@@ -563,6 +590,14 @@ func digraph(cmd string, args []string) error {
 		sort.Strings(edgesSorted)
 		fmt.Fprintln(stdout, strings.Join(edgesSorted, "\n"))
 
+	case "to":
+		if len(args) != 1 || args[0] != "dot" {
+			return fmt.Errorf("usage: digraph to dot")
+		}
+		var b bytes.Buffer
+		g.toDot(&b)
+		stdout.Write(b.Bytes())
+
 	default:
 		return fmt.Errorf("no such command %q", cmd)
 	}
diff --git a/cmd/digraph/digraph_test.go b/cmd/digraph/digraph_test.go
index 60b8e75eb72..4d238d54b73 100644
--- a/cmd/digraph/digraph_test.go
+++ b/cmd/digraph/digraph_test.go
@@ -6,6 +6,7 @@ package main
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"reflect"
 	"sort"
 	"strings"
@@ -346,3 +347,27 @@ func TestFocus(t *testing.T) {
 		})
 	}
 }
+
+func TestToDot(t *testing.T) {
+	in := `a b c
+b "d\"\\d"
+c "d\"\\d"`
+	want := `digraph {
+	"a" -> "b";
+	"a" -> "c";
+	"b" -> "d\"\\d";
+	"c" -> "d\"\\d";
+}
+`
+	defer func(in io.Reader, out io.Writer) { stdin, stdout = in, out }(stdin, stdout)
+	stdin = strings.NewReader(in)
+	stdout = new(bytes.Buffer)
+	if err := digraph("to", []string{"dot"}); err != nil {
+		t.Fatal(err)
+	}
+	got := stdout.(fmt.Stringer).String()
+	if got != want {
+		t.Errorf("digraph(to, dot) = got %q, want %q", got, want)
+	}
+
+}

From d1a388b0ec90c90a7127e3af2612f5ef16c4aee8 Mon Sep 17 00:00:00 2001
From: Robert Findley <rfindley@google.com>
Date: Tue, 20 Jun 2023 12:22:24 -0400
Subject: [PATCH 02/26] internal/gcimporter: avoid a crash when exporting a
 struct with no pkg

This is an arbitrary fix to avoid a crash while exporting an empty
struct with no ambient package. Unfortunately, the struct encoding
assumes that there is an implied package for structs, which at least in
invalid code may not be the case.

Fixes golang/go#60891

Change-Id: I8acd591ac15cdc1770d615fdca57dcb7bb9b7651
Reviewed-on: https://go-review.googlesource.com/c/tools/+/504556
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
---
 internal/gcimporter/gcimporter_test.go |  3 +++
 internal/gcimporter/iexport.go         | 19 ++++++++++++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/internal/gcimporter/gcimporter_test.go b/internal/gcimporter/gcimporter_test.go
index e13cfd9219a..6346885a58f 100644
--- a/internal/gcimporter/gcimporter_test.go
+++ b/internal/gcimporter/gcimporter_test.go
@@ -809,6 +809,9 @@ func TestExportInvalid(t *testing.T) {
 		// It must be possible to export a constant with unknown kind, even if its
 		// type is known.
 		{"issue 60605", `package p; const EPSILON float64 = 1e-`, "EPSILON"},
+
+		// We must not crash when exporting a struct with unknown package.
+		{"issue 60891", `package p; type I[P any] int; const C I[struct{}] = 42`, "C"},
 	}
 
 	for _, test := range tests {
diff --git a/internal/gcimporter/iexport.go b/internal/gcimporter/iexport.go
index 3fc7989c083..db9842706c9 100644
--- a/internal/gcimporter/iexport.go
+++ b/internal/gcimporter/iexport.go
@@ -673,6 +673,9 @@ func (w *exportWriter) qualifiedType(obj *types.TypeName) {
 	w.pkg(obj.Pkg())
 }
 
+// TODO(rfindley): what does 'pkg' even mean here? It would be better to pass
+// it in explicitly into signatures and structs that may use it for
+// constructing fields.
 func (w *exportWriter) typ(t types.Type, pkg *types.Package) {
 	w.data.uint64(w.p.typOff(t, pkg))
 }
@@ -773,7 +776,21 @@ func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
 		if n > 0 {
 			w.setPkg(t.Field(0).Pkg(), true) // qualifying package for field objects
 		} else {
-			w.setPkg(pkg, true)
+			// TODO(rfindley): improve this very hacky logic.
+			//
+			// The importer expects a package to be set for all struct types, even
+			// those with no fields. A better encoding might be to set NumFields
+			// before pkg. setPkg panics with a nil package, which may be possible
+			// to reach with invalid packages (and perhaps valid packages, too?), so
+			// (arbitrarily) set the localpkg if available.
+			switch {
+			case pkg != nil:
+				w.setPkg(pkg, true)
+			case w.p.shallow:
+				w.setPkg(w.p.localpkg, true)
+			default:
+				panic(internalErrorf("no package to set for empty struct"))
+			}
 		}
 		w.uint64(uint64(n))
 		for i := 0; i < n; i++ {

From b71392afd89560d5b97d530a5751d3a9e6f0dddc Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Tue, 13 Jun 2023 11:47:20 -0400
Subject: [PATCH 03/26] gopls/internal/lsp/cache: reduce importing in analysis

This CL is a substantial reorganization of the analysis driver to
ensure that export data is imported at most once per batch of packages
that are analyzed, instead of once per import edge. This greatly
reduces the amount of allocation and computation done during analysis.

In cache/analysis.go, Snapshot.Analyze (which now takes a set of
PackageIDs, instead of being called singly in a loop) constructs an
ephemeral DAG that mirrors the package graph, and then works in
parallel postorder over this graph doing analysis. It uses a single
FileSet for the whole batch of packages it creates. The subgraph
rooted at each node is effectively a types.Importer for that node,
as it represents the mapping from PackagePath to *types.Package.

We no longer bother with promises or invalidation. We rely on the fact
that the graph is relatively cheap to construct, cache hits are cheap
to process, and the whole process only occurs after an idle delay of
about a second.

Also:

- In internal/facts, optimize the fact decoder by using a callback.
  Previously, it was spending a lot of time traversing the API of all
  imports of a package to build a PackagePath-to-types.Package
  mapping. For many packages in terraform-provider-aws this visits
  over 1M objects (!!). But of course this is trivially computed from
  the new representation.

- In internal/gcimporter, IImportShallow now uses a single callback to
  get all the types.Package symbols from the client, potentially in
  parallel (and that's what gopls does). The previous separation of
  "create" and "populate" has gone away.

  The analysis driver additionally exploits the getPackages callback to
  efficiently read the package manifest of an export data file,
  then abort with an error before proceeding to actually decode
  the rest of the file.

With this change, we can process the internal/provider package of the
terraform-provider-aws repo in 20s cold, 4s hot. (Before, it would run
out of memory.)

$ go test -bench=InitialWorkspaceLoad/hashiform ./gopls/internal/regtest/bench
BenchmarkInitialWorkspaceLoad/hashiform-8         	       1	4014521793 ns/op	 349570384 alloc_bytes	 439230464 in_use_bytes	 668992216 total_alloc_bytes
PASS

Fixes golang/go#60621

Change-Id: Iadeb02f57eb19dcccb639857053b897a60e0a90e
Reviewed-on: https://go-review.googlesource.com/c/tools/+/503195
Reviewed-by: Robert Findley <rfindley@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Alan Donovan <adonovan@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
---
 gopls/internal/lsp/cache/analysis.go      | 791 ++++++++++++----------
 gopls/internal/lsp/cache/check.go         |  36 +-
 gopls/internal/lsp/cache/maps.go          |  12 -
 gopls/internal/lsp/cache/session.go       |   1 -
 gopls/internal/lsp/cache/snapshot.go      |  19 -
 gopls/internal/lsp/code_action.go         |   4 +-
 gopls/internal/lsp/diagnostics.go         |  52 +-
 gopls/internal/lsp/source/diagnostics.go  |   6 +-
 gopls/internal/lsp/source/rename.go       |   2 +-
 gopls/internal/lsp/source/view.go         |   4 +-
 gopls/internal/regtest/bench/iwl_test.go  |   1 +
 gopls/internal/regtest/bench/repo_test.go |   9 +
 internal/event/tag/tag.go                 |   2 +-
 internal/facts/facts.go                   |  48 +-
 internal/facts/imports.go                 |   4 +
 internal/gcimporter/gcimporter_test.go    |   3 +-
 internal/gcimporter/iexport.go            |  21 +-
 internal/gcimporter/iimport.go            | 123 ++--
 internal/gcimporter/shallow_test.go       |  49 +-
 19 files changed, 652 insertions(+), 535 deletions(-)

diff --git a/gopls/internal/lsp/cache/analysis.go b/gopls/internal/lsp/cache/analysis.go
index 04e2651f9e6..5ba84278a0f 100644
--- a/gopls/internal/lsp/cache/analysis.go
+++ b/gopls/internal/lsp/cache/analysis.go
@@ -23,6 +23,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"sync/atomic"
 
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/tools/go/analysis"
@@ -34,7 +35,6 @@ import (
 	"golang.org/x/tools/internal/event/tag"
 	"golang.org/x/tools/internal/facts"
 	"golang.org/x/tools/internal/gcimporter"
-	"golang.org/x/tools/internal/memoize"
 	"golang.org/x/tools/internal/typeparams"
 	"golang.org/x/tools/internal/typesinternal"
 )
@@ -43,48 +43,50 @@ import (
 
    DESIGN
 
-   An analysis request is for a set of analyzers and an individual
-   package ID, notated (a*, p). The result is the set of diagnostics
-   for that package. It could easily be generalized to a set of
-   packages, (a*, p*), and perhaps should be, to improve performance
-   versus calling it in a loop.
-
-   The snapshot holds a cache (persistent.Map) of entries keyed by
-   (a*, p) pairs ("analysisKey") that have been requested so far. Some
-   of these entries may be invalidated during snapshot cloning after a
-   modification event.  The cache maps each (a*, p) to a promise of
-   the analysis result or "analysisSummary". The summary contains the
-   results of analysis (e.g. diagnostics) as well as the intermediate
-   results required by the recursion, such as serialized types and
-   facts.
-
-   The promise represents the result of a call to analyzeImpl, which
-   type-checks a package and then applies a graph of analyzers to it
-   in parallel postorder. (These graph edges are "horizontal": within
-   the same package.) First, analyzeImpl reads the source files of
-   package p, and obtains (recursively) the results of the "vertical"
-   dependencies (i.e. analyzers applied to the packages imported by
-   p). Only the subset of analyzers that use facts need be executed
-   recursively, but even if this subset is empty, the step is still
-   necessary because it provides type information. It is possible that
-   a package may need to be type-checked and analyzed twice, for
-   different subsets of analyzers, but the overlap is typically
-   insignificant.
-
-   With the file contents and the results of vertical dependencies,
-   analyzeImpl is then in a position to produce a key representing the
-   unit of work (parsing, type-checking, and analysis) that it has to
-   do. The key is a cryptographic hash of the "recipe" for this step,
-   including the Metadata, the file contents, the set of analyzers,
-   and the type and fact information from the vertical dependencies.
+   An analysis request (Snapshot.Analyze) is for a set of Analyzers and
+   PackageIDs. The result is the set of diagnostics for those
+   packages. Each request constructs a transitively closed DAG of
+   nodes, each representing a package, then works bottom up in
+   parallel postorder calling runCached to ensure that each node's
+   analysis summary is up to date. The summary contains the analysis
+   diagnostics as well as the intermediate results required by the
+   recursion, such as serialized types and facts.
+
+   The entire DAG is ephemeral. Each node in the DAG records the set
+   of analyzers to run: the complete set for the root packages, and
+   the "facty" subset for dependencies. Each package is thus analyzed
+   at most once. The entire DAG shares a single FileSet for parsing
+   and importing.
+
+   Each node is processed by runCached. It gets the source file
+   content hashes for package p, and the summaries of its "vertical"
+   dependencies (direct imports), and from them it computes a key
+   representing the unit of work (parsing, type-checking, and
+   analysis) that it has to do. The key is a cryptographic hash of the
+   "recipe" for this step, including the Metadata, the file contents,
+   the set of analyzers, and the type and fact information from the
+   vertical dependencies.
 
    The key is sought in a machine-global persistent file-system based
    cache. If this gopls process, or another gopls process on the same
-   machine, has already performed this analysis step, analyzeImpl will
+   machine, has already performed this analysis step, runCached will
    make a cache hit and load the serialized summary of the results. If
-   not, it will have to proceed to type-checking and analysis, and
-   write a new cache entry. The entry contains serialized types
-   (export data) and analysis facts.
+   not, it will have to proceed to run() to parse and type-check the
+   package and then apply a set of analyzers to it. (The set of
+   analyzers applied to a single package itself forms a graph of
+   "actions", and it too is evaluated in parallel postorder; these
+   dependency edges within the same package are called "horizontal".)
+   Finally it writes a new cache entry. The entry contains serialized
+   types (export data) and analysis facts.
+
+   Each node in the DAG acts like a go/types importer mapping,
+   providing a consistent view of packages and their objects: the
+   mapping for a node is a superset of its dependencies' mappings.
+   Every node has an associated *types.Package, initially nil. A
+   package is populated during run (cache miss) by type-checking its
+   syntax; but for a cache hit, the package is populated lazily, i.e.
+   not until it later becomes necessary because it is imported
+   directly or referenced by export data higher up in the DAG.
 
    For types, we use "shallow" export data. Historically, the Go
    compiler always produced a summary of the types for a given package
@@ -103,11 +105,8 @@ import (
    "Shallow" export data means that the serialized types describe only
    a single package. If those types mention types from other packages,
    the type checker may need to request additional packages beyond
-   just the direct imports. This means type information for the entire
-   transitive closure of imports may need to be available just in
-   case. After a cache hit or a cache miss, the summary is
-   postprocessed so that it contains the union of export data payloads
-   of all its direct dependencies.
+   just the direct imports. Type information for the entire transitive
+   closure of imports is provided (lazily) by the DAG.
 
    For correct dependency analysis, the digest used as a cache key
    must reflect the "deep" export data, so it is derived recursively
@@ -119,8 +118,9 @@ import (
    but if its export data is unchanged as a result, then indirect
    consumers may not need to be re-executed.  This allows, for example,
    one to insert a print statement in a function and not "rebuild" the
-   whole application (though export data does record line numbers of
-   types which may be perturbed by otherwise insignificant changes.)
+   whole application (though export data does record line numbers and
+   offsets of types which may be perturbed by otherwise insignificant
+   changes.)
 
    The summary must record whether a package is transitively
    error-free (whether it would compile) because many analyzers are
@@ -133,13 +133,6 @@ import (
 */
 
 // TODO(adonovan):
-// - Profile + optimize:
-//   - on a cold run, mostly type checking + export data, unsurprisingly.
-//   - on a hot-disk run, mostly type checking the IWL.
-//     Would be nice to have a benchmark that separates this out.
-//   - measure and record in the code the typical operation times
-//     and file sizes (export data + facts = cache entries).
-// - Do "port the old logic" tasks (see TODO in actuallyAnalyze).
 // - Add a (white-box) test of pruning when a change doesn't affect export data.
 // - Optimise pruning based on subset of packages mentioned in exportdata.
 // - Better logging so that it is possible to deduce why an analyzer
@@ -147,7 +140,6 @@ import (
 //   Even if the ultimate consumer decides to ignore errors,
 //   tests and other situations want to be assured of freedom from
 //   errors, not just missing results. This should be recorded.
-// - Check that the event trace is intelligible.
 // - Split this into a subpackage, gopls/internal/lsp/cache/driver,
 //   consisting of this file and three helpers from errors.go.
 //   The (*snapshot).Analyze method would stay behind and make calls
@@ -157,11 +149,6 @@ import (
 //        Metadata(PackageID) source.Metadata
 //        ReadFile(Context, URI) (source.FileHandle, error)
 //        View() *View // for Options
-//   - define a State type that encapsulates the persistent map
-//     (with its own mutex), and has methods:
-//        New() *State
-//        Clone(invalidate map[PackageID]bool) *State
-//        Destroy()
 //   - share cache.{goVersionRx,parseGoImpl}
 
 // Analyze applies a set of analyzers to the package denoted by id,
@@ -171,8 +158,19 @@ import (
 //
 // Precondition: all analyzers within the process have distinct names.
 // (The names are relied on by the serialization logic.)
-func (s *snapshot) Analyze(ctx context.Context, id PackageID, analyzers []*source.Analyzer) ([]*source.Diagnostic, error) {
-	ctx, done := event.Start(ctx, "snapshot.Analyze", tag.Package.Of(string(id)))
+func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit, analyzers []*source.Analyzer) ([]*source.Diagnostic, error) {
+	var tagStr string // sorted comma-separated list of PackageIDs
+	{
+		// TODO(adonovan): replace with a generic map[S]any -> string
+		// function in the tag package, and use maps.Keys + slices.Sort.
+		keys := make([]string, 0, len(pkgs))
+		for id := range pkgs {
+			keys = append(keys, string(id))
+		}
+		sort.Strings(keys)
+		tagStr = strings.Join(keys, ",")
+	}
+	ctx, done := event.Start(ctx, "snapshot.Analyze", tag.Package.Of(tagStr))
 	defer done()
 
 	// Filter and sort enabled root analyzers.
@@ -180,7 +178,7 @@ func (s *snapshot) Analyze(ctx context.Context, id PackageID, analyzers []*sourc
 	toSrc := make(map[*analysis.Analyzer]*source.Analyzer)
 	var enabled []*analysis.Analyzer
 	for _, a := range analyzers {
-		if a.IsEnabled(s.view.Options()) {
+		if a.IsEnabled(snapshot.view.Options()) {
 			toSrc[a.Analyzer] = a
 			enabled = append(enabled, a.Analyzer)
 		}
@@ -188,21 +186,149 @@ func (s *snapshot) Analyze(ctx context.Context, id PackageID, analyzers []*sourc
 	sort.Slice(enabled, func(i, j int) bool {
 		return enabled[i].Name < enabled[j].Name
 	})
+	analyzers = nil // prevent accidental use
 
 	// Register fact types of required analyzers.
-	for _, a := range requiredAnalyzers(enabled) {
-		for _, f := range a.FactTypes {
-			gob.Register(f)
+	enabled = requiredAnalyzers(enabled)
+	var useFacts []*analysis.Analyzer
+	for _, a := range enabled {
+		if len(a.FactTypes) > 0 {
+			useFacts = append(useFacts, a)
+			for _, f := range a.FactTypes {
+				gob.Register(f) // <2us
+			}
 		}
 	}
+	useFacts = requiredAnalyzers(useFacts)
 
-	// Run the analysis.
-	res, err := s.analyze(ctx, id, enabled)
-	if err != nil {
-		return nil, err
+	// File set for this batch (entire graph) of analysis.
+	fset := token.NewFileSet()
+
+	// Starting from the root packages and following DepsByPkgPath,
+	// build the DAG of packages we're going to analyze.
+	//
+	// Root nodes will run the enabled set of analyzers,
+	// whereas dependencies will run only the useFacts set.
+	nodes := make(map[PackageID]*analysisNode)
+	var leaves []*analysisNode // nodes with no unfinished successors
+	var makeNode func(from *analysisNode, id PackageID) (*analysisNode, error)
+	makeNode = func(from *analysisNode, id PackageID) (*analysisNode, error) {
+		an, ok := nodes[id]
+		if !ok {
+			m := snapshot.Metadata(id)
+			if m == nil {
+				return nil, bug.Errorf("no metadata for %s", id)
+			}
+
+			// -- preorder --
+
+			an = &analysisNode{
+				fset:       fset,
+				m:          m,
+				analyzers:  useFacts, // all nodes run at least the facty analyzers
+				allDeps:    make(map[PackagePath]*analysisNode),
+				exportDeps: make(map[PackagePath]*analysisNode),
+			}
+			// Unsafe must use a distinguished types.Package.
+			// Mark it as fully populated from birth.
+			if m.PkgPath == "unsafe" {
+				an.typesOnce.Do(func() { an.types = types.Unsafe })
+			}
+			nodes[id] = an
+
+			// -- recursion --
+
+			// Build subgraphs for dependencies.
+			an.succs = make(map[PackageID]*analysisNode, len(m.DepsByPkgPath))
+			for _, depID := range m.DepsByPkgPath {
+				dep, err := makeNode(an, depID)
+				if err != nil {
+					return nil, err
+				}
+				an.succs[depID] = dep
+
+				// Compute the union of all dependencies.
+				// (This step has quadratic complexity.)
+				for pkgPath, node := range dep.allDeps {
+					an.allDeps[pkgPath] = node
+				}
+			}
+
+			// -- postorder --
+
+			an.allDeps[m.PkgPath] = an // add self entry (reflexive transitive closure)
+
+			// Add leaf nodes (no successors) directly to queue.
+			if len(an.succs) == 0 {
+				leaves = append(leaves, an)
+			}
+
+			// Load the contents of each compiled Go file through
+			// the snapshot's cache. (These are all cache hits as
+			// files are pre-loaded following packages.Load)
+			an.files = make([]source.FileHandle, len(m.CompiledGoFiles))
+			for i, uri := range m.CompiledGoFiles {
+				fh, err := snapshot.ReadFile(ctx, uri)
+				if err != nil {
+					return nil, err
+				}
+				an.files[i] = fh
+			}
+		}
+		// Add edge from predecessor.
+		if from != nil {
+			atomic.AddInt32(&from.count, 1) // TODO(adonovan): use generics
+			an.preds = append(an.preds, from)
+		}
+		return an, nil
+	}
+
+	// For root packages, we run the enabled set of analyzers.
+	var roots []*analysisNode
+	for id := range pkgs {
+		root, err := makeNode(nil, id)
+		if err != nil {
+			return nil, err
+		}
+		root.analyzers = enabled
+		roots = append(roots, root)
+	}
+
+	// Now that we have read all files,
+	// we no longer need the snapshot.
+	snapshot = nil
+
+	// Execute phase: run leaves first, adding
+	// new nodes to the queue as they become leaves.
+	var g errgroup.Group
+	// Avoid g.SetLimit here: it makes g.Go stop accepting work,
+	// which prevents workers from enqeuing, and thus finishing,
+	// and thus allowing the group to make progress: deadlock.
+	var enqueue func(it *analysisNode)
+	enqueue = func(an *analysisNode) {
+		g.Go(func() error {
+			summary, err := an.runCached(ctx)
+			if err != nil {
+				return err // cancelled, or failed to produce a package
+			}
+			an.summary = summary
+
+			// Notify each waiting predecessor,
+			// and enqueue it when it becomes a leaf.
+			for _, pred := range an.preds {
+				if atomic.AddInt32(&pred.count, -1) == 0 {
+					enqueue(pred)
+				}
+			}
+			return nil
+		})
+	}
+	for _, leaf := range leaves {
+		enqueue(leaf)
+	}
+	if err := g.Wait(); err != nil {
+		return nil, err // cancelled, or failed to produce a package
 	}
-	// Inv: res is the successful result of analyzeImpl(analyzers, id),
-	// which augments the successful result of actuallyAnalyze.
 
 	// Report diagnostics only from enabled actions that succeeded.
 	// Errors from creating or analyzing packages are ignored.
@@ -215,43 +341,114 @@ func (s *snapshot) Analyze(ctx context.Context, id PackageID, analyzers []*sourc
 	// Even if current callers choose to discard the
 	// results, we should propagate the per-action errors.
 	var results []*source.Diagnostic
-	for _, a := range enabled {
-		summary, ok := res.Actions[a.Name]
-		if summary == nil {
-			panic(fmt.Sprintf("analyzeSummary.Actions[%q] = (nil, %t); got %v (#60551)",
-				a.Name, ok, res.Actions))
-		}
-		if summary.Err != "" {
-			continue // action failed
-		}
-		for _, gobDiag := range summary.Diagnostics {
-			results = append(results, toSourceDiagnostic(toSrc[a], &gobDiag))
+	for _, root := range roots {
+		for _, a := range enabled {
+			// Inv: root.summary is the successful result of run (via runCached).
+			summary, ok := root.summary.Actions[a.Name]
+			if summary == nil {
+				panic(fmt.Sprintf("analyzeSummary.Actions[%q] = (nil, %t); got %v (#60551)",
+					a.Name, ok, root.summary.Actions))
+			}
+			if summary.Err != "" {
+				continue // action failed
+			}
+			for _, gobDiag := range summary.Diagnostics {
+				results = append(results, toSourceDiagnostic(toSrc[a], &gobDiag))
+			}
 		}
 	}
 	return results, nil
 }
 
-// analysisKey is the type of keys in the snapshot.analyses map.
-type analysisKey struct {
-	analyzerNames string
-	pkgid         PackageID
+// An analysisNode is a node in a doubly-linked DAG isomorphic to the
+// import graph. Each node represents a single package, and the DAG
+// represents a batch of analysis work done at once using a single
+// realm of token.Pos or types.Object values.
+//
+// A complete DAG is created anew for each batch of analysis;
+// subgraphs are not reused over time. Each node's *types.Package
+// field is initially nil and is populated on demand, either from
+// type-checking syntax trees (typeCheck) or from importing export
+// data (_import). When this occurs, the typesOnce event becomes
+// "done".
+//
+// Each node's allDeps map is a "view" of all its dependencies keyed by
+// package path, which defines the types.Importer mapping used when
+// populating the node's types.Package. Different nodes have different
+// views (e.g. due to variants), but two nodes that are related by
+// graph ordering have views that are consistent in their overlap.
+// exportDeps is the subset actually referenced by export data;
+// this is the set for which we attempt to decode facts.
+//
+// Each node's run method is called in parallel postorder. On success,
+// its summary field is populated, either from the cache (hit), or by
+// type-checking and analyzing syntax (miss).
+type analysisNode struct {
+	fset       *token.FileSet                // file set shared by entire batch (DAG)
+	m          *source.Metadata              // metadata for this package
+	files      []source.FileHandle           // contents of CompiledGoFiles
+	analyzers  []*analysis.Analyzer          // set of analyzers to run
+	preds      []*analysisNode               // graph edges:
+	succs      map[PackageID]*analysisNode   //   (preds -> self -> succs)
+	allDeps    map[PackagePath]*analysisNode // all dependencies including self
+	exportDeps map[PackagePath]*analysisNode // subset of allDeps ref'd by export data (+self)
+	count      int32                         // number of unfinished successors
+	summary    *analyzeSummary               // serializable result of analyzing this package
+	typesOnce  sync.Once                     // guards lazy population of types field
+	types      *types.Package                // type information lazily imported from summary
 }
 
-func (key analysisKey) String() string {
-	return fmt.Sprintf("%s@%s", key.analyzerNames, key.pkgid)
+func (an *analysisNode) String() string { return string(an.m.ID) }
+
+// _import imports this node's types.Package from export data, if not already done.
+// Precondition: analysis was a success.
+// Postcondition: an.types and an.exportDeps are populated.
+func (an *analysisNode) _import() *types.Package {
+	an.typesOnce.Do(func() {
+		an.types = types.NewPackage(string(an.m.PkgPath), string(an.m.Name))
+
+		// getPackages recursively imports each dependency
+		// referenced by the export data, in parallel.
+		getPackages := func(items []gcimporter.GetPackagesItem) error {
+			var g errgroup.Group
+			for i, item := range items {
+				path := PackagePath(item.Path)
+				dep, ok := an.allDeps[path]
+				if !ok {
+					// This early return bypasses Wait; that's ok.
+					return fmt.Errorf("%s: unknown dependency %q", an.m, path)
+				}
+				an.exportDeps[path] = dep // record, for later fact decoding
+				if dep == an {
+					items[i].Pkg = an.types
+				} else {
+					i := i
+					g.Go(func() error {
+						items[i].Pkg = dep._import()
+						return nil
+					})
+				}
+			}
+			return g.Wait()
+		}
+		pkg, err := gcimporter.IImportShallow(an.fset, getPackages, an.summary.Export, string(an.m.PkgPath))
+		if err != nil {
+			log.Fatalf("%s: invalid export data: %v", an.m, err)
+		}
+		if pkg != an.types {
+			log.Fatalf("%s: inconsistent packages", an.m)
+		}
+	})
+	return an.types
 }
 
 // analyzeSummary is a gob-serializable summary of successfully
 // applying a list of analyzers to a package.
 type analyzeSummary struct {
-	PkgPath        PackagePath // types.Package.Path() (needed to decode export data)
-	Export         []byte
+	Export         []byte      // encoded types of package
 	DeepExportHash source.Hash // hash of reflexive transitive closure of export data
 	Compiles       bool        // transitively free of list/parse/type errors
 	Actions        actionsMap  // map from analyzer name to analysis results (*actionSummary)
-
-	// Not serialized: populated after the summary is computed or deserialized.
-	allExport map[PackagePath][]byte // transitive export data
 }
 
 // actionsMap defines a stable Gob encoding for a map.
@@ -302,126 +499,16 @@ type actionSummary struct {
 	Err         string // "" => success
 }
 
-// analyze is a memoization of analyzeImpl.
-func (s *snapshot) analyze(ctx context.Context, id PackageID, analyzers []*analysis.Analyzer) (*analyzeSummary, error) {
-	// Use the caller-sorted list of names of analyzers in the key.
-	//
-	// TODO(adonovan): opt: account for analysis results at a
-	// finer grain to avoid duplicate work when a
-	// a proper subset of analyzers is requested?
-	// In particular, TypeErrorAnalyzers don't use facts
-	// but need to request vdeps just for type information.
-	names := make([]string, 0, len(analyzers))
-	for _, a := range analyzers {
-		names = append(names, a.Name)
-	}
-	// This key describes the result of applying a list of analyzers to a package.
-	key := analysisKey{strings.Join(names, ","), id}
-
-	// An analysisPromise represents the result of loading, parsing,
-	// type-checking and analyzing a single package.
-	type analysisPromise struct {
-		promise *memoize.Promise // [analyzeImplResult]
-	}
-
-	type analyzeImplResult struct {
-		summary *analyzeSummary
-		err     error
-	}
-
-	// Access the map once, briefly, and atomically.
-	s.mu.Lock()
-	entry, hit := s.analyses.Get(key)
-	if !hit {
-		entry = analysisPromise{
-			promise: memoize.NewPromise("analysis", func(ctx context.Context, arg interface{}) interface{} {
-				summary, err := analyzeImpl(ctx, arg.(*snapshot), analyzers, id)
-				return analyzeImplResult{summary, err}
-			}),
-		}
-		s.analyses.Set(key, entry, nil) // nothing needs releasing
-	}
-	s.mu.Unlock()
-
-	// Await result.
-	ap := entry.(analysisPromise)
-	v, err := s.awaitPromise(ctx, ap.promise)
-	if err != nil {
-		return nil, err // e.g. cancelled
-	}
-	res := v.(analyzeImplResult)
-	return res.summary, res.err
-}
-
-// analyzeImpl applies a list of analyzers (plus any others
+// runCached applies a list of analyzers (plus any others
 // transitively required by them) to a package.  It succeeds as long
 // as it could produce a types.Package, even if there were direct or
 // indirect list/parse/type errors, and even if all the analysis
 // actions failed. It usually fails only if the package was unknown,
 // a file was missing, or the operation was cancelled.
 //
-// Postcondition: analyzeImpl must not continue to use the snapshot
+// Postcondition: runCached must not continue to use the snapshot
 // (in background goroutines) after it has returned; see memoize.RefCounted.
-func analyzeImpl(ctx context.Context, snapshot *snapshot, analyzers []*analysis.Analyzer, id PackageID) (*analyzeSummary, error) {
-	m := snapshot.Metadata(id)
-	if m == nil {
-		return nil, fmt.Errorf("no metadata for %s", id)
-	}
-
-	// Also, load the contents of each "compiled" Go file through
-	// the snapshot's cache.
-	// (These are all cache hits as files are pre-loaded following packages.Load)
-	compiledGoFiles := make([]source.FileHandle, len(m.CompiledGoFiles))
-	for i, uri := range m.CompiledGoFiles {
-		fh, err := snapshot.ReadFile(ctx, uri)
-		if err != nil {
-			return nil, err // e.g. canceled
-		}
-		compiledGoFiles[i] = fh
-	}
-
-	// Recursively analyze each "vertical" dependency
-	// for its types.Package and (perhaps) analysis.Facts.
-	// If any of them fails to produce a package, we cannot continue.
-	// We request only the analyzers that produce facts.
-	vdeps := make(map[PackageID]*analyzeSummary)
-	{
-		var group errgroup.Group
-
-		// Analyze vertical dependencies.
-		// We request only the required analyzers that use facts.
-		var useFacts []*analysis.Analyzer
-		for _, a := range requiredAnalyzers(analyzers) {
-			if len(a.FactTypes) > 0 {
-				useFacts = append(useFacts, a)
-			}
-		}
-		var vdepsMu sync.Mutex
-		for _, id := range m.DepsByPkgPath {
-			id := id
-			group.Go(func() error {
-				res, err := snapshot.analyze(ctx, id, useFacts)
-				if err != nil {
-					return err // cancelled, or failed to produce a package
-				}
-
-				vdepsMu.Lock()
-				vdeps[id] = res
-				vdepsMu.Unlock()
-				return nil
-			})
-		}
-
-		if err := group.Wait(); err != nil {
-			return nil, err
-		}
-	}
-
-	// Inv: analyze() of all vdeps succeeded (though some actions may have failed).
-
-	// We no longer depend on the snapshot.
-	snapshot = nil
-
+func (an *analysisNode) runCached(ctx context.Context) (*analyzeSummary, error) {
 	// At this point we have the action results (serialized
 	// packages and facts) of our immediate dependencies,
 	// and the metadata and content of this package.
@@ -433,7 +520,7 @@ func analyzeImpl(ctx context.Context, snapshot *snapshot, analyzers []*analysis.
 	// The hash of our inputs is based on the serialized export
 	// data and facts so that immaterial changes can be pruned
 	// without decoding.
-	key := analysisCacheKey(analyzers, m, compiledGoFiles, vdeps)
+	key := an.cacheKey()
 
 	// Access the cache.
 	var summary *analyzeSummary
@@ -446,14 +533,14 @@ func analyzeImpl(ctx context.Context, snapshot *snapshot, analyzers []*analysis.
 	} else {
 		// Cache miss: do the work.
 		var err error
-		summary, err = actuallyAnalyze(ctx, analyzers, m, vdeps, compiledGoFiles)
+		summary, err = an.run(ctx)
 		if err != nil {
 			return nil, err
 		}
 		go func() {
 			data := mustEncode(summary)
 			if false {
-				log.Printf("Set key=%d value=%d id=%s\n", len(key), len(data), id)
+				log.Printf("Set key=%d value=%d id=%s\n", len(key), len(data), an.m.ID)
 			}
 			if err := filecache.Set(cacheKind, key, data); err != nil {
 				event.Error(ctx, "internal error updating analysis shared cache", err)
@@ -461,34 +548,15 @@ func analyzeImpl(ctx context.Context, snapshot *snapshot, analyzers []*analysis.
 		}()
 	}
 
-	// Hit or miss, we need to merge the export data from
-	// dependencies so that it includes all the types
-	// that might be summoned by the type checker.
-	//
-	// TODO(adonovan): opt: reduce this set by recording
-	// which packages were actually summoned by insert().
-	// (Just makes map smaller; probably marginal?)
-	allExport := make(map[PackagePath][]byte)
-	for _, vdep := range vdeps {
-		for k, v := range vdep.allExport {
-			allExport[k] = v
-		}
-	}
-	allExport[m.PkgPath] = summary.Export
-	summary.allExport = allExport
-
 	return summary, nil
 }
 
 // analysisCacheKey returns a cache key that is a cryptographic digest
 // of the all the values that might affect type checking and analysis:
 // the analyzer names, package metadata, names and contents of
-// compiled Go files, and vdeps information (export data and facts).
-//
-// TODO(adonovan): safety: define our own flavor of Metadata
-// containing just the fields we need, and using it in the subsequent
-// logic, to keep us honest about hashing all parts that matter?
-func analysisCacheKey(analyzers []*analysis.Analyzer, m *source.Metadata, compiledGoFiles []source.FileHandle, vdeps map[PackageID]*analyzeSummary) [sha256.Size]byte {
+// compiled Go files, and vdeps (successor) information
+// (export data and facts).
+func (an *analysisNode) cacheKey() [sha256.Size]byte {
 	hasher := sha256.New()
 
 	// In principle, a key must be the hash of an
@@ -496,12 +564,13 @@ func analysisCacheKey(analyzers []*analysis.Analyzer, m *source.Metadata, compil
 	// If it's ambiguous, we risk collisions.
 
 	// analyzers
-	fmt.Fprintf(hasher, "analyzers: %d\n", len(analyzers))
-	for _, a := range analyzers {
+	fmt.Fprintf(hasher, "analyzers: %d\n", len(an.analyzers))
+	for _, a := range an.analyzers {
 		fmt.Fprintln(hasher, a.Name)
 	}
 
 	// package metadata
+	m := an.m
 	fmt.Fprintf(hasher, "package: %s %s %s\n", m.ID, m.Name, m.PkgPath)
 	// We can ignore m.DepsBy{Pkg,Import}Path: although the logic
 	// uses those fields, we account for them by hashing vdeps.
@@ -521,30 +590,31 @@ func analysisCacheKey(analyzers []*analysis.Analyzer, m *source.Metadata, compil
 	}
 
 	// file names and contents
-	fmt.Fprintf(hasher, "files: %d\n", len(compiledGoFiles))
-	for _, fh := range compiledGoFiles {
+	fmt.Fprintf(hasher, "files: %d\n", len(an.files))
+	for _, fh := range an.files {
 		fmt.Fprintln(hasher, fh.FileIdentity())
 	}
 
 	// vdeps, in PackageID order
-	depIDs := make([]string, 0, len(vdeps))
-	for depID := range vdeps {
+	depIDs := make([]string, 0, len(an.succs))
+	for depID := range an.succs {
 		depIDs = append(depIDs, string(depID))
 	}
-	sort.Strings(depIDs)
+	sort.Strings(depIDs) // TODO(adonovan): avoid conversions by using slices.Sort[PackageID]
 	for _, depID := range depIDs {
-		vdep := vdeps[PackageID(depID)]
-		fmt.Fprintf(hasher, "dep: %s\n", vdep.PkgPath)
-		fmt.Fprintf(hasher, "export: %s\n", vdep.DeepExportHash)
+		vdep := an.succs[PackageID(depID)]
+		fmt.Fprintf(hasher, "dep: %s\n", vdep.m.PkgPath)
+		fmt.Fprintf(hasher, "export: %s\n", vdep.summary.DeepExportHash)
 
 		// action results: errors and facts
-		names := make([]string, 0, len(vdep.Actions))
-		for name := range vdep.Actions {
+		actions := vdep.summary.Actions
+		names := make([]string, 0, len(actions))
+		for name := range actions {
 			names = append(names, name)
 		}
 		sort.Strings(names)
 		for _, name := range names {
-			summary := vdep.Actions[name]
+			summary := actions[name]
 			fmt.Fprintf(hasher, "action %s\n", name)
 			if summary.Err != "" {
 				fmt.Fprintf(hasher, "error %s\n", summary.Err)
@@ -561,28 +631,25 @@ func analysisCacheKey(analyzers []*analysis.Analyzer, m *source.Metadata, compil
 	return hash
 }
 
-// actuallyAnalyze implements the cache-miss case.
+// run implements the cache-miss case.
 // This function does not access the snapshot.
 //
 // Postcondition: on success, the analyzeSummary.Actions
 // key set is {a.Name for a in analyzers}.
-func actuallyAnalyze(ctx context.Context, analyzers []*analysis.Analyzer, m *source.Metadata, vdeps map[PackageID]*analyzeSummary, compiledGoFiles []source.FileHandle) (*analyzeSummary, error) {
-	// Create a local FileSet for processing this package only.
-	fset := token.NewFileSet()
-
+func (an *analysisNode) run(ctx context.Context) (*analyzeSummary, error) {
 	// Parse only the "compiled" Go files.
 	// Do the computation in parallel.
-	parsed := make([]*source.ParsedGoFile, len(compiledGoFiles))
+	parsed := make([]*source.ParsedGoFile, len(an.files))
 	{
 		var group errgroup.Group
-		for i, fh := range compiledGoFiles {
+		for i, fh := range an.files {
 			i, fh := i, fh
 			group.Go(func() error {
 				// Call parseGoImpl directly, not the caching wrapper,
 				// as cached ASTs require the global FileSet.
 				// ast.Object resolution is unfortunately an implied part of the
 				// go/analysis contract.
-				pgf, err := parseGoImpl(ctx, fset, fh, source.ParseFull&^source.SkipObjectResolution)
+				pgf, err := parseGoImpl(ctx, an.fset, fh, source.ParseFull&^source.SkipObjectResolution)
 				parsed[i] = pgf
 				return err
 			})
@@ -592,22 +659,43 @@ func actuallyAnalyze(ctx context.Context, analyzers []*analysis.Analyzer, m *sou
 		}
 	}
 
-	// Type-check the package.
-	pkg := typeCheckForAnalysis(fset, parsed, m, vdeps)
+	// Type-check the package syntax.
+	pkg := an.typeCheck(parsed)
+
+	// Compute the union of exportDeps across our direct imports.
+	// This is the set that will be needed by the fact decoder.
+	allExportDeps := make(map[PackagePath]*analysisNode)
+	for _, succ := range an.succs {
+		for k, v := range succ.exportDeps {
+			allExportDeps[k] = v
+		}
+	}
+
+	// The fact decoder needs a means to look up a Package by path.
+	pkg.factsDecoder = facts.NewDecoderFunc(pkg.types, func(path string) *types.Package {
+		// Note: Decode is called concurrently, and thus so is this function.
+
+		// Does the fact relate to a package referenced by export data?
+		if dep, ok := allExportDeps[PackagePath(path)]; ok {
+			dep.typesOnce.Do(func() { log.Fatal("dep.types not populated") })
+			return dep.types
+		}
 
-	// Build a map of PkgPath to *Package for all packages mentioned
-	// in exportdata for use by facts.
-	pkg.factsDecoder = facts.NewDecoder(pkg.types)
+		// If the fact relates to a dependency not referenced
+		// by export data, it is safe to ignore it.
+		// (In that case dep.types exists but may be unpopulated
+		// or in the process of being populated from export data.)
+		if an.allDeps[PackagePath(path)] == nil {
+			log.Fatalf("fact package %q is not a dependency", path)
+		}
+		return nil
+	})
 
 	// Poll cancellation state.
 	if err := ctx.Err(); err != nil {
 		return nil, err
 	}
 
-	// TODO(adonovan): port the old logic to:
-	// - gather go/packages diagnostics from m.Errors? (port goPackagesErrorDiagnostics)
-	// - gather diagnostics from expandErrors + typeErrorDiagnostics + depsErrors.
-
 	// -- analysis --
 
 	// Build action graph for this package.
@@ -621,7 +709,7 @@ func actuallyAnalyze(ctx context.Context, analyzers []*analysis.Analyzer, m *sou
 			for _, req := range a.Requires {
 				hdeps = append(hdeps, mkAction(req))
 			}
-			act = &action{a: a, pkg: pkg, vdeps: vdeps, hdeps: hdeps}
+			act = &action{a: a, pkg: pkg, vdeps: an.succs, hdeps: hdeps}
 			actions[a] = act
 		}
 		return act
@@ -629,7 +717,7 @@ func actuallyAnalyze(ctx context.Context, analyzers []*analysis.Analyzer, m *sou
 
 	// Build actions for initial package.
 	var roots []*action
-	for _, a := range analyzers {
+	for _, a := range an.analyzers {
 		roots = append(roots, mkAction(a))
 	}
 
@@ -652,7 +740,6 @@ func actuallyAnalyze(ctx context.Context, analyzers []*analysis.Analyzer, m *sou
 	}
 
 	return &analyzeSummary{
-		PkgPath:        PackagePath(pkg.types.Path()),
 		Export:         pkg.export,
 		DeepExportHash: pkg.deepExportHash,
 		Compiles:       pkg.compiles,
@@ -660,9 +747,13 @@ func actuallyAnalyze(ctx context.Context, analyzers []*analysis.Analyzer, m *sou
 	}, nil
 }
 
-func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m *source.Metadata, vdeps map[PackageID]*analyzeSummary) *analysisPackage {
+// Postcondition: an.types and an.exportDeps are populated.
+func (an *analysisNode) typeCheck(parsed []*source.ParsedGoFile) *analysisPackage {
+	m := an.m
+	fset := an.fset
+
 	if false { // debugging
-		log.Println("typeCheckForAnalysis", m.PkgPath)
+		log.Println("typeCheck", m.ID)
 	}
 
 	pkg := &analysisPackage{
@@ -684,6 +775,11 @@ func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m
 	}
 	typeparams.InitInstanceInfo(pkg.typesInfo)
 
+	// Unsafe has no syntax.
+	if m.PkgPath == "unsafe" {
+		return pkg
+	}
+
 	for i, p := range parsed {
 		pkg.files[i] = p.File
 		if p.ParseErr != nil {
@@ -691,77 +787,12 @@ func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m
 		}
 	}
 
-	// Unsafe is special.
-	if m.PkgPath == "unsafe" {
-		pkg.types = types.Unsafe
-		return pkg
-	}
-
-	// Compute the union of transitive export data.
-	// (The actual values are shared, and not serialized.)
-	allExport := make(map[PackagePath][]byte)
-	for _, vdep := range vdeps {
-		for k, v := range vdep.allExport {
-			allExport[k] = v
-		}
-
-		if !vdep.Compiles {
+	for _, vdep := range an.succs {
+		if !vdep.summary.Compiles {
 			pkg.compiles = false // transitive error
 		}
 	}
 
-	// exportHasher computes a hash of the names and export data of
-	// each package that was actually loaded during type checking.
-	//
-	// Because we use shallow export data, the hash for dependency
-	// analysis must incorporate indirect dependencies. As an
-	// optimization, we include only those that were actually
-	// used, which may be a small subset of those available.
-	//
-	// TODO(adonovan): opt: even better would be to implement a
-	// traversal over the package API like facts.NewDecoder does
-	// and only mention that set of packages in the hash.
-	// Perhaps there's a way to do that more efficiently.
-	//
-	// TODO(adonovan): opt: record the shallow hash alongside the
-	// shallow export data in the allExport map to avoid repeatedly
-	// hashing the export data.
-	//
-	// The writes to hasher below assume that type checking imports
-	// packages in a deterministic order.
-	exportHasher := sha256.New()
-	hashExport := func(pkgPath PackagePath, export []byte) {
-		fmt.Fprintf(exportHasher, "%s %d ", pkgPath, len(export))
-		exportHasher.Write(export)
-	}
-
-	// importer state
-	var (
-		insert    func(p *types.Package, name string)
-		importMap = make(map[string]*types.Package) // keys are PackagePaths
-	)
-	loadFromExportData := func(pkgPath PackagePath) (*types.Package, error) {
-		export, ok := allExport[pkgPath]
-		if !ok {
-			return nil, bug.Errorf("missing export data for %q", pkgPath)
-		}
-		hashExport(pkgPath, export)
-		imported, err := gcimporter.IImportShallow(fset, gcimporter.GetPackageFromMap(importMap), export, string(pkgPath), insert)
-		if err != nil {
-			return nil, bug.Errorf("invalid export data for %q: %v", pkgPath, err)
-		}
-		return imported, nil
-	}
-	insert = func(p *types.Package, name string) {
-		imported, err := loadFromExportData(PackagePath(p.Path()))
-		if err != nil {
-			log.Fatalf("internal error: %v", err)
-		}
-		if imported != p {
-			log.Fatalf("internal error: inconsistent packages")
-		}
-	}
-
 	cfg := &types.Config{
 		Sizes: m.TypesSizes,
 		Error: func(e error) {
@@ -778,16 +809,13 @@ func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m
 			pkg.typeErrors = append(pkg.typeErrors, typeError)
 		},
 		Importer: importerFunc(func(importPath string) (*types.Package, error) {
-			if importPath == "unsafe" {
-				return types.Unsafe, nil // unsafe has no export data
-			}
-
 			// Beware that returning an error from this function
 			// will cause the type checker to synthesize a fake
 			// package whose Path is importPath, potentially
 			// losing a vendor/ prefix. If type-checking errors
 			// are swallowed, these packages may be confusing.
 
+			// Map ImportPath to ID.
 			id, ok := m.DepsByImpPath[ImportPath(importPath)]
 			if !ok {
 				// The import syntax is inconsistent with the metadata.
@@ -798,22 +826,23 @@ func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m
 				return nil, fmt.Errorf("missing metadata for import of %q", importPath)
 			}
 
-			depResult, ok := vdeps[id] // id may be ""
-			if !ok {
+			// Map ID to node. (id may be "")
+			dep := an.succs[id]
+			if dep == nil {
 				// Analogous to (*snapshot).missingPkgError
 				// in the logic for regular type-checking,
 				// but without a snapshot we can't provide
 				// such detail, and anyway most analysis
 				// failures aren't surfaced in the UI.
-				return nil, fmt.Errorf("no required module provides package %q (id=%q)", importPath, id)
+				return nil, fmt.Errorf("no required module provides analysis package %q (id=%q)", importPath, id)
 			}
 
 			// (Duplicates logic from check.go.)
-			if !source.IsValidImport(m.PkgPath, depResult.PkgPath) {
+			if !source.IsValidImport(an.m.PkgPath, dep.m.PkgPath) {
 				return nil, fmt.Errorf("invalid use of internal package %s", importPath)
 			}
 
-			return loadFromExportData(depResult.PkgPath)
+			return dep._import(), nil
 		}),
 	}
 
@@ -845,7 +874,13 @@ func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m
 		}
 	}
 
-	// Emit the export data and compute the deep hash.
+	// Publish the completed package.
+	an.typesOnce.Do(func() { an.types = pkg.types })
+	if an.types != pkg.types {
+		log.Fatalf("typesOnce prematurely done")
+	}
+
+	// Emit the export data and compute the recursive hash.
 	export, err := gcimporter.IExportShallow(pkg.fset, pkg.types)
 	if err != nil {
 		// TODO(adonovan): in light of exporter bugs such as #57729,
@@ -854,12 +889,56 @@ func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m
 		log.Fatalf("internal error writing shallow export data: %v", err)
 	}
 	pkg.export = export
-	hashExport(m.PkgPath, export)
-	exportHasher.Sum(pkg.deepExportHash[:0])
+
+	// Compute a recursive hash to account for the export data of
+	// this package and each dependency referenced by it.
+	// Also, populate exportDeps.
+	hash := sha256.New()
+	fmt.Fprintf(hash, "%s %d\n", m.PkgPath, len(export))
+	hash.Write(export)
+	paths, err := readShallowManifest(export)
+	if err != nil {
+		log.Fatalf("internal error: bad export data: %v", err)
+	}
+	for _, path := range paths {
+		dep, ok := an.allDeps[PackagePath(path)]
+		if !ok {
+			log.Fatalf("%s: missing dependency: %q", an, path)
+		}
+		fmt.Fprintf(hash, "%s %s\n", dep.m.PkgPath, dep.summary.DeepExportHash)
+		an.exportDeps[PackagePath(path)] = dep
+	}
+	an.exportDeps[m.PkgPath] = an // self
+	hash.Sum(pkg.deepExportHash[:0])
 
 	return pkg
 }
 
+// readShallowManifest returns the manifest of packages referenced by
+// a shallow export data file for a package (excluding the package itself).
+// TODO(adonovan): add a test.
+func readShallowManifest(export []byte) ([]PackagePath, error) {
+	const selfPath = "<self>" // dummy path
+	var paths []PackagePath
+	getPackages := func(items []gcimporter.GetPackagesItem) error {
+		paths = []PackagePath{} // non-nil
+		for _, item := range items {
+			if item.Path != selfPath {
+				paths = append(paths, PackagePath(item.Path))
+			}
+		}
+		return errors.New("stop") // terminate importer
+	}
+	_, err := gcimporter.IImportShallow(token.NewFileSet(), getPackages, export, selfPath)
+	if paths == nil {
+		if err != nil {
+			return nil, err // failed before getPackages callback
+		}
+		return nil, bug.Errorf("internal error: IImportShallow did not call getPackages")
+	}
+	return paths, nil // success
+}
+
 // analysisPackage contains information about a package, including
 // syntax trees, used transiently during its type-checking and analysis.
 type analysisPackage struct {
@@ -885,8 +964,8 @@ type action struct {
 	once  sync.Once
 	a     *analysis.Analyzer
 	pkg   *analysisPackage
-	hdeps []*action                     // horizontal dependencies
-	vdeps map[PackageID]*analyzeSummary // vertical dependencies
+	hdeps []*action                   // horizontal dependencies
+	vdeps map[PackageID]*analysisNode // vertical dependencies
 
 	// results of action.exec():
 	result  interface{} // result of Run function, of type a.ResultType
@@ -944,9 +1023,9 @@ func (act *action) exec() (interface{}, *actionSummary, error) {
 	// we return the dependencies' error' unadorned.
 	if hasFacts {
 		// TODO(adonovan): use deterministic order.
-		for _, res := range act.vdeps {
-			if vdep := res.Actions[analyzer.Name]; vdep.Err != "" {
-				return nil, nil, errors.New(vdep.Err)
+		for _, vdep := range act.vdeps {
+			if summ := vdep.summary.Actions[analyzer.Name]; summ.Err != "" {
+				return nil, nil, errors.New(summ.Err)
 			}
 		}
 	}
@@ -977,15 +1056,14 @@ func (act *action) exec() (interface{}, *actionSummary, error) {
 	// efficient to fork and tailor it to our precise needs.
 	//
 	// We've already sharded the fact encoding by action
-	// so that it can be done in parallel (hoisting the
-	// ImportMap call so that we build the map once per package).
+	// so that it can be done in parallel.
 	// We could eliminate locking.
 	// We could also dovetail more closely with the export data
 	// decoder to obtain a more compact representation of
 	// packages and objects (e.g. its internal IDs, instead
 	// of PkgPaths and objectpaths.)
 
-	// Read and decode analysis facts for each imported package.
+	// Read and decode analysis facts for each direct import.
 	factset, err := pkg.factsDecoder.Decode(func(imp *types.Package) ([]byte, error) {
 		if !hasFacts {
 			return nil, nil // analyzer doesn't use facts, so no vdeps
@@ -1012,11 +1090,12 @@ func (act *action) exec() (interface{}, *actionSummary, error) {
 			return nil, nil
 		}
 
-		vdep, ok := act.vdeps[id]
-		if !ok {
+		vdep := act.vdeps[id]
+		if vdep == nil {
 			return nil, bug.Errorf("internal error in %s: missing vdep for id=%s", pkg.types.Path(), id)
 		}
-		return vdep.Actions[analyzer.Name].Facts, nil
+
+		return vdep.summary.Actions[analyzer.Name].Facts, nil
 	})
 	if err != nil {
 		return nil, nil, fmt.Errorf("internal error decoding analysis facts: %w", err)
diff --git a/gopls/internal/lsp/cache/check.go b/gopls/internal/lsp/cache/check.go
index 59b19e03bab..81c81a30b5e 100644
--- a/gopls/internal/lsp/cache/check.go
+++ b/gopls/internal/lsp/cache/check.go
@@ -531,29 +531,19 @@ func (b *typeCheckBatch) importPackage(ctx context.Context, m *source.Metadata,
 
 	impMap := b.importMap(m.ID)
 
-	var firstErr error // TODO(rfindley): unused: revisit or remove.
 	thisPackage := types.NewPackage(string(m.PkgPath), string(m.Name))
-	getPackage := func(path, name string) *types.Package {
-		if path == string(m.PkgPath) {
-			return thisPackage
-		}
-
-		id := impMap[path]
-		imp, err := b.getImportPackage(ctx, id)
-		if err == nil {
-			return imp
-		}
-		// inv: err != nil
-		if firstErr == nil {
-			firstErr = err
+	getPackages := func(items []gcimporter.GetPackagesItem) error {
+		for i, item := range items {
+			if item.Path == string(m.PkgPath) {
+				items[i].Pkg = thisPackage
+			} else {
+				pkg, err := b.getImportPackage(ctx, impMap[item.Path])
+				if err != nil {
+					return err
+				}
+				items[i].Pkg = pkg
+			}
 		}
-
-		// Context cancellation, or a very bad error such as a file permission
-		// error.
-		//
-		// Returning nil here will cause the import to fail (and panic if
-		// gcimporter.debug is set), but that is preferable to the confusing errors
-		// produced when shallow import encounters an empty package.
 		return nil
 	}
 
@@ -563,9 +553,9 @@ func (b *typeCheckBatch) importPackage(ctx context.Context, m *source.Metadata,
 		return nil, ctx.Err()
 	}
 
-	// TODO(rfindley): collect "deep" hashes here using the provided
+	// TODO(rfindley): collect "deep" hashes here using the getPackages
 	// callback, for precise pruning.
-	imported, err := gcimporter.IImportShallow(b.fset, getPackage, data, string(m.PkgPath), func(*types.Package, string) {})
+	imported, err := gcimporter.IImportShallow(b.fset, getPackages, data, string(m.PkgPath))
 	if err != nil {
 		return nil, fmt.Errorf("import failed for %q: %v", m.ID, err)
 	}
diff --git a/gopls/internal/lsp/cache/maps.go b/gopls/internal/lsp/cache/maps.go
index 533c3397b42..de6187da255 100644
--- a/gopls/internal/lsp/cache/maps.go
+++ b/gopls/internal/lsp/cache/maps.go
@@ -5,8 +5,6 @@
 package cache
 
 import (
-	"strings"
-
 	"golang.org/x/tools/gopls/internal/lsp/source"
 	"golang.org/x/tools/gopls/internal/span"
 	"golang.org/x/tools/internal/persistent"
@@ -136,13 +134,3 @@ func (s knownDirsSet) Insert(key span.URI) {
 func (s knownDirsSet) Remove(key span.URI) {
 	s.impl.Delete(key)
 }
-
-// analysisKeyLessInterface is the less-than relation for analysisKey
-// values wrapped in an interface.
-func analysisKeyLessInterface(a, b interface{}) bool {
-	x, y := a.(analysisKey), b.(analysisKey)
-	if cmp := strings.Compare(x.analyzerNames, y.analyzerNames); cmp != 0 {
-		return cmp < 0
-	}
-	return x.pkgid < y.pkgid
-}
diff --git a/gopls/internal/lsp/cache/session.go b/gopls/internal/lsp/cache/session.go
index 8eae64e4d82..fd2e4d2f207 100644
--- a/gopls/internal/lsp/cache/session.go
+++ b/gopls/internal/lsp/cache/session.go
@@ -171,7 +171,6 @@ func (s *Session) createView(ctx context.Context, name string, folder span.URI,
 		parseCache:           new(parseCache),
 		activePackages:       persistent.NewMap(packageIDLessInterface),
 		symbolizeHandles:     persistent.NewMap(uriLessInterface),
-		analyses:             persistent.NewMap(analysisKeyLessInterface),
 		workspacePackages:    make(map[PackageID]PackagePath),
 		unloadableFiles:      make(map[span.URI]struct{}),
 		parseModHandles:      persistent.NewMap(uriLessInterface),
diff --git a/gopls/internal/lsp/cache/snapshot.go b/gopls/internal/lsp/cache/snapshot.go
index 6ff14fb6d34..ce98fe6d02f 100644
--- a/gopls/internal/lsp/cache/snapshot.go
+++ b/gopls/internal/lsp/cache/snapshot.go
@@ -122,11 +122,6 @@ type snapshot struct {
 	// IDs not contained in the map are not known to be open or not open.
 	activePackages *persistent.Map // from packageID to *Package
 
-	// analyses maps an analysisKey (which identifies a package
-	// and a set of analyzers) to the handle for the future result
-	// of loading the package and analyzing it.
-	analyses *persistent.Map // from analysisKey to analysisPromise
-
 	// workspacePackages contains the workspace's packages, which are loaded
 	// when the view is created. It contains no intermediate test variants.
 	workspacePackages map[PackageID]PackagePath
@@ -268,7 +263,6 @@ func (s *snapshot) destroy(destroyedBy string) {
 
 	s.packages.Destroy()
 	s.activePackages.Destroy()
-	s.analyses.Destroy()
 	s.files.Destroy()
 	s.knownSubdirs.Destroy()
 	s.symbolizeHandles.Destroy()
@@ -2014,7 +2008,6 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 		initializedErr:       s.initializedErr,
 		packages:             s.packages.Clone(),
 		activePackages:       s.activePackages.Clone(),
-		analyses:             s.analyses.Clone(),
 		files:                s.files.Clone(),
 		parseCache:           s.parseCache,
 		symbolizeHandles:     s.symbolizeHandles.Clone(),
@@ -2242,18 +2235,6 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 		result.activePackages.Delete(id)
 	}
 
-	// Delete invalidated analysis actions.
-	var actionsToDelete []analysisKey
-	result.analyses.Range(func(k, _ interface{}) {
-		key := k.(analysisKey)
-		if _, ok := idsToInvalidate[key.pkgid]; ok {
-			actionsToDelete = append(actionsToDelete, key)
-		}
-	})
-	for _, key := range actionsToDelete {
-		result.analyses.Delete(key)
-	}
-
 	// If a file has been deleted, we must delete metadata for all packages
 	// containing that file.
 	//
diff --git a/gopls/internal/lsp/code_action.go b/gopls/internal/lsp/code_action.go
index 8e817b88bb6..39addc8e98b 100644
--- a/gopls/internal/lsp/code_action.go
+++ b/gopls/internal/lsp/code_action.go
@@ -203,7 +203,7 @@ func (s *Server) codeAction(ctx context.Context, params *protocol.CodeActionPara
 		if err != nil {
 			return nil, err
 		}
-		analysisDiags, err := source.Analyze(ctx, snapshot, pkg.Metadata().ID, true)
+		analysisDiags, err := source.Analyze(ctx, snapshot, map[source.PackageID]unit{pkg.Metadata().ID: {}}, true)
 		if err != nil {
 			return nil, err
 		}
@@ -575,3 +575,5 @@ func goTest(ctx context.Context, snapshot source.Snapshot, uri span.URI, rng pro
 		Command: &cmd,
 	}}, nil
 }
+
+type unit = struct{}
diff --git a/gopls/internal/lsp/diagnostics.go b/gopls/internal/lsp/diagnostics.go
index 88008d319bc..94b5621b185 100644
--- a/gopls/internal/lsp/diagnostics.go
+++ b/gopls/internal/lsp/diagnostics.go
@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"sync"
 	"time"
@@ -362,7 +363,7 @@ func (s *Server) diagnose(ctx context.Context, snapshot source.Snapshot, analyze
 	var (
 		seen       = map[span.URI]struct{}{}
 		toDiagnose = make(map[source.PackageID]*source.Metadata)
-		toAnalyze  = make(map[source.PackageID]*source.Metadata)
+		toAnalyze  = make(map[source.PackageID]unit)
 	)
 	for _, m := range workspace {
 		var hasNonIgnored, hasOpenFile bool
@@ -378,7 +379,7 @@ func (s *Server) diagnose(ctx context.Context, snapshot source.Snapshot, analyze
 		if hasNonIgnored {
 			toDiagnose[m.ID] = m
 			if analyze == analyzeEverything || analyze == analyzeOpenPackages && hasOpenFile {
-				toAnalyze[m.ID] = m
+				toAnalyze[m.ID] = unit{}
 			}
 		}
 	}
@@ -416,7 +417,7 @@ func (s *Server) diagnose(ctx context.Context, snapshot source.Snapshot, analyze
 // of concurrent dispatch: as of writing we concurrently run TidyDiagnostics
 // and diagnosePkgs, and diagnosePkgs concurrently runs PackageDiagnostics and
 // analysis.
-func (s *Server) diagnosePkgs(ctx context.Context, snapshot source.Snapshot, toDiagnose, toAnalyze map[source.PackageID]*source.Metadata) {
+func (s *Server) diagnosePkgs(ctx context.Context, snapshot source.Snapshot, toDiagnose map[source.PackageID]*source.Metadata, toAnalyze map[source.PackageID]unit) {
 	ctx, done := event.Start(ctx, "Server.diagnosePkgs", source.SnapshotLabels(snapshot)...)
 	defer done()
 
@@ -425,7 +426,6 @@ func (s *Server) diagnosePkgs(ctx context.Context, snapshot source.Snapshot, toD
 	var (
 		wg            sync.WaitGroup
 		pkgDiags      map[span.URI][]*source.Diagnostic
-		analysisMu    sync.Mutex
 		analysisDiags = make(map[span.URI][]*source.Diagnostic)
 	)
 
@@ -446,28 +446,30 @@ func (s *Server) diagnosePkgs(ctx context.Context, snapshot source.Snapshot, toD
 
 	// Get diagnostics from analysis framework.
 	// This includes type-error analyzers, which suggest fixes to compiler errors.
-	//
-	// TODO(adonovan): in many cases we will be analyze multiple open variants of
-	// an open package, which have significantly overlapping import graphs.
-	// It may make sense to change the Analyze API to accept a slice of IDs, or
-	// merge analysis with type-checking.
-	for _, m := range toAnalyze {
-		m := m
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			diags, err := source.Analyze(ctx, snapshot, m.ID, false)
-			if err != nil {
-				event.Error(ctx, "warning: analyzing package", err, append(source.SnapshotLabels(snapshot), tag.Package.Of(string(m.ID)))...)
-				return
-			}
-			analysisMu.Lock()
-			for uri, diags := range diags {
-				analysisDiags[uri] = append(analysisDiags[uri], diags...)
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		diags, err := source.Analyze(ctx, snapshot, toAnalyze, false)
+		if err != nil {
+			var tagStr string // sorted comma-separated list of package IDs
+			{
+				// TODO(adonovan): replace with a generic map[S]any -> string
+				// function in the tag package, and use  maps.Keys + slices.Sort.
+				keys := make([]string, 0, len(toDiagnose))
+				for id := range toDiagnose {
+					keys = append(keys, string(id))
+				}
+				sort.Strings(keys)
+				tagStr = strings.Join(keys, ",")
 			}
-			analysisMu.Unlock()
-		}()
-	}
+			event.Error(ctx, "warning: analyzing package", err, append(source.SnapshotLabels(snapshot), tag.Package.Of(tagStr))...)
+			return
+		}
+		for uri, diags := range diags {
+			analysisDiags[uri] = append(analysisDiags[uri], diags...)
+		}
+	}()
+
 	wg.Wait()
 
 	// TODO(rfindley): remove the guards against snapshot.IsBuiltin, after the
diff --git a/gopls/internal/lsp/source/diagnostics.go b/gopls/internal/lsp/source/diagnostics.go
index 336e35b25ac..2a397dde91f 100644
--- a/gopls/internal/lsp/source/diagnostics.go
+++ b/gopls/internal/lsp/source/diagnostics.go
@@ -21,7 +21,7 @@ type SuggestedFix struct {
 }
 
 // Analyze reports go/analysis-framework diagnostics in the specified package.
-func Analyze(ctx context.Context, snapshot Snapshot, pkgid PackageID, includeConvenience bool) (map[span.URI][]*Diagnostic, error) {
+func Analyze(ctx context.Context, snapshot Snapshot, pkgIDs map[PackageID]unit, includeConvenience bool) (map[span.URI][]*Diagnostic, error) {
 	// Exit early if the context has been canceled. This also protects us
 	// from a race on Options, see golang/go#36699.
 	if ctx.Err() != nil {
@@ -45,7 +45,7 @@ func Analyze(ctx context.Context, snapshot Snapshot, pkgid PackageID, includeCon
 		}
 	}
 
-	analysisDiagnostics, err := snapshot.Analyze(ctx, pkgid, analyzers)
+	analysisDiagnostics, err := snapshot.Analyze(ctx, pkgIDs, analyzers)
 	if err != nil {
 		return nil, err
 	}
@@ -81,7 +81,7 @@ func FileDiagnostics(ctx context.Context, snapshot Snapshot, uri span.URI) (File
 	if err != nil {
 		return nil, nil, err
 	}
-	adiags, err := Analyze(ctx, snapshot, pkg.Metadata().ID, false)
+	adiags, err := Analyze(ctx, snapshot, map[PackageID]unit{pkg.Metadata().ID: {}}, false)
 	if err != nil {
 		return nil, nil, err
 	}
diff --git a/gopls/internal/lsp/source/rename.go b/gopls/internal/lsp/source/rename.go
index 60fb48d6a37..b460cb00121 100644
--- a/gopls/internal/lsp/source/rename.go
+++ b/gopls/internal/lsp/source/rename.go
@@ -21,7 +21,7 @@ package source
 //   - special cases: embedded fields, interfaces, test variants,
 //     function-local things with uppercase names;
 //     packages with type errors (currently 'satisfy' rejects them),
-//     pakage with missing imports;
+//     package with missing imports;
 //
 // - measure performance in k8s.
 //
diff --git a/gopls/internal/lsp/source/view.go b/gopls/internal/lsp/source/view.go
index 2f7a3f27ef2..ed204f3d85a 100644
--- a/gopls/internal/lsp/source/view.go
+++ b/gopls/internal/lsp/source/view.go
@@ -92,8 +92,8 @@ type Snapshot interface {
 	// Position information is added to FileSet().
 	ParseGo(ctx context.Context, fh FileHandle, mode parser.Mode) (*ParsedGoFile, error)
 
-	// Analyze runs the specified analyzers on the given package at this snapshot.
-	Analyze(ctx context.Context, id PackageID, analyzers []*Analyzer) ([]*Diagnostic, error)
+	// Analyze runs the specified analyzers on the given packages at this snapshot.
+	Analyze(ctx context.Context, pkgIDs map[PackageID]unit, analyzers []*Analyzer) ([]*Diagnostic, error)
 
 	// RunGoCommandPiped runs the given `go` command, writing its output
 	// to stdout and stderr. Verb, Args, and WorkingDir must be specified.
diff --git a/gopls/internal/regtest/bench/iwl_test.go b/gopls/internal/regtest/bench/iwl_test.go
index c4a2d0f23bf..b7e9ad30b7b 100644
--- a/gopls/internal/regtest/bench/iwl_test.go
+++ b/gopls/internal/regtest/bench/iwl_test.go
@@ -27,6 +27,7 @@ func BenchmarkInitialWorkspaceLoad(b *testing.B) {
 		{"pkgsite", "internal/frontend/server.go"},
 		{"starlark", "starlark/eval.go"},
 		{"tools", "internal/lsp/cache/snapshot.go"},
+		{"hashiform", "internal/provider/provider.go"},
 	}
 
 	for _, test := range tests {
diff --git a/gopls/internal/regtest/bench/repo_test.go b/gopls/internal/regtest/bench/repo_test.go
index 0b92b124642..f4ea78d5c02 100644
--- a/gopls/internal/regtest/bench/repo_test.go
+++ b/gopls/internal/regtest/bench/repo_test.go
@@ -87,6 +87,15 @@ var repos = map[string]*repo{
 		short:  true,
 		inDir:  flag.String("tools_dir", "", "if set, reuse this directory as x/tools@v0.9.0"),
 	},
+
+	// A repo of similar size to kubernetes, but with substantially more
+	// complex types that led to a serious performance regression (issue #60621).
+	"hashiform": {
+		name:   "hashiform",
+		url:    "https://github.com/hashicorp/terraform-provider-aws",
+		commit: "ac55de2b1950972d93feaa250d7505d9ed829c7c",
+		inDir:  flag.String("hashiform_dir", "", "if set, reuse this directory as hashiform@ac55de2"),
+	},
 }
 
 // getRepo gets the requested repo, and skips the test if -short is set and
diff --git a/internal/event/tag/tag.go b/internal/event/tag/tag.go
index ff2f2ecd38d..581b26c2041 100644
--- a/internal/event/tag/tag.go
+++ b/internal/event/tag/tag.go
@@ -19,7 +19,7 @@ var (
 	File          = keys.NewString("file", "")
 	Directory     = keys.New("directory", "")
 	URI           = keys.New("URI", "")
-	Package       = keys.NewString("package", "") // Package ID
+	Package       = keys.NewString("package", "") // sorted comma-separated list of Package IDs
 	PackagePath   = keys.NewString("package_path", "")
 	Query         = keys.New("query", "")
 	Snapshot      = keys.NewUInt64("snapshot", "")
diff --git a/internal/facts/facts.go b/internal/facts/facts.go
index 81df45161a8..954b42d6966 100644
--- a/internal/facts/facts.go
+++ b/internal/facts/facts.go
@@ -158,24 +158,52 @@ type gobFact struct {
 // for the same package. Each call to Decode returns an independent
 // fact set.
 type Decoder struct {
-	pkg      *types.Package
-	packages map[string]*types.Package
+	pkg        *types.Package
+	getPackage GetPackageFunc
 }
 
 // NewDecoder returns a fact decoder for the specified package.
+//
+// It uses a brute-force recursive approach to enumerate all objects
+// defined by dependencies of pkg, so that it can learn the set of
+// package paths that may be mentioned in the fact encoding. This does
+// not scale well; use [NewDecoderFunc] where possible.
 func NewDecoder(pkg *types.Package) *Decoder {
 	// Compute the import map for this package.
 	// See the package doc comment.
-	return &Decoder{pkg, importMap(pkg.Imports())}
+	m := importMap(pkg.Imports())
+	getPackageFunc := func(path string) *types.Package { return m[path] }
+	return NewDecoderFunc(pkg, getPackageFunc)
+}
+
+// NewDecoderFunc returns a fact decoder for the specified package.
+//
+// It calls the getPackage function for the package path string of
+// each dependency (perhaps indirect) that it encounters in the
+// encoding. If the function returns nil, the fact is discarded.
+//
+// This function is preferred over [NewDecoder] when the client is
+// capable of efficient look-up of packages by package path.
+func NewDecoderFunc(pkg *types.Package, getPackage GetPackageFunc) *Decoder {
+	return &Decoder{
+		pkg:        pkg,
+		getPackage: getPackage,
+	}
 }
 
-// Decode decodes all the facts relevant to the analysis of package pkg.
-// The read function reads serialized fact data from an external source
-// for one of of pkg's direct imports. The empty file is a valid
-// encoding of an empty fact set.
+// A GetPackageFunc function returns the package denoted by a package path.
+type GetPackageFunc = func(pkgPath string) *types.Package
+
+// Decode decodes all the facts relevant to the analysis of package
+// pkg. The read function reads serialized fact data from an external
+// source for one of pkg's direct imports, identified by package path.
+// The empty file is a valid encoding of an empty fact set.
 //
 // It is the caller's responsibility to call gob.Register on all
 // necessary fact types.
+//
+// Concurrent calls to Decode are safe, so long as the
+// [GetPackageFunc] (if any) is also concurrency-safe.
 func (d *Decoder) Decode(read func(*types.Package) ([]byte, error)) (*Set, error) {
 	// Read facts from imported packages.
 	// Facts may describe indirectly imported packages, or their objects.
@@ -202,13 +230,11 @@ func (d *Decoder) Decode(read func(*types.Package) ([]byte, error)) (*Set, error
 		if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&gobFacts); err != nil {
 			return nil, fmt.Errorf("decoding facts for %q: %v", imp.Path(), err)
 		}
-		if debug {
-			logf("decoded %d facts: %v", len(gobFacts), gobFacts)
-		}
+		logf("decoded %d facts: %v", len(gobFacts), gobFacts)
 
 		// Parse each one into a key and a Fact.
 		for _, f := range gobFacts {
-			factPkg := d.packages[f.PkgPath]
+			factPkg := d.getPackage(f.PkgPath) // possibly an indirect dependency
 			if factPkg == nil {
 				// Fact relates to a dependency that was
 				// unused in this translation unit. Skip.
diff --git a/internal/facts/imports.go b/internal/facts/imports.go
index 7b21668660c..b18e62d1d79 100644
--- a/internal/facts/imports.go
+++ b/internal/facts/imports.go
@@ -21,6 +21,10 @@ import (
 // Packages in the map that are only indirectly imported may be
 // incomplete (!pkg.Complete()).
 //
+// This function scales very poorly with packages' transitive object
+// references, which can be more than a million for each package near
+// the top of a large project. (This was a significant contributor to
+// #60621.)
 // TODO(adonovan): opt: compute this information more efficiently
 // by obtaining it from the internals of the gcexportdata decoder.
 func importMap(imports []*types.Package) map[string]*types.Package {
diff --git a/internal/gcimporter/gcimporter_test.go b/internal/gcimporter/gcimporter_test.go
index 6346885a58f..3db67606850 100644
--- a/internal/gcimporter/gcimporter_test.go
+++ b/internal/gcimporter/gcimporter_test.go
@@ -841,8 +841,7 @@ func TestExportInvalid(t *testing.T) {
 
 			// Re-import it.
 			imports := make(map[string]*types.Package)
-			insert := func(pkg1 *types.Package, name string) { panic("unexpected insert") }
-			pkg2, err := IImportShallow(fset, GetPackageFromMap(imports), data, "p", insert)
+			pkg2, err := IImportShallow(fset, GetPackagesFromMap(imports), data, "p")
 			if err != nil {
 				t.Fatalf("import: %v", err) // any failure of IExport+IImport is a bug.
 			}
diff --git a/internal/gcimporter/iexport.go b/internal/gcimporter/iexport.go
index db9842706c9..eed1702186b 100644
--- a/internal/gcimporter/iexport.go
+++ b/internal/gcimporter/iexport.go
@@ -47,20 +47,20 @@ func IExportShallow(fset *token.FileSet, pkg *types.Package) ([]byte, error) {
 // IImportShallow decodes "shallow" types.Package data encoded by
 // IExportShallow in the same executable. This function cannot import data from
 // cmd/compile or gcexportdata.Write.
-func IImportShallow(fset *token.FileSet, getPackage GetPackageFunc, data []byte, path string, insert InsertType) (*types.Package, error) {
+//
+// The importer calls getPackages to obtain package symbols for all
+// packages mentioned in the export data, including the one being
+// decoded.
+func IImportShallow(fset *token.FileSet, getPackages GetPackagesFunc, data []byte, path string) (*types.Package, error) {
 	const bundle = false
-	pkgs, err := iimportCommon(fset, getPackage, data, bundle, path, insert)
+	const shallow = true
+	pkgs, err := iimportCommon(fset, getPackages, data, bundle, path, shallow)
 	if err != nil {
 		return nil, err
 	}
 	return pkgs[0], nil
 }
 
-// InsertType is the type of a function that creates a types.TypeName
-// object for a named type and inserts it into the scope of the
-// specified Package.
-type InsertType = func(pkg *types.Package, name string)
-
 // Current bundled export format version. Increase with each format change.
 // 0: initial implementation
 const bundleVersion = 0
@@ -1222,6 +1222,13 @@ type internalError string
 
 func (e internalError) Error() string { return "gcimporter: " + string(e) }
 
+// TODO(adonovan): make this call panic, so that it's symmetric with errorf.
+// Otherwise it's easy to forget to do anything with the error.
+//
+// TODO(adonovan): also, consider switching the names "errorf" and
+// "internalErrorf" as the former is used for bugs, whose cause is
+// internal inconsistency, whereas the latter is used for ordinary
+// situations like bad input, whose cause is external.
 func internalErrorf(format string, args ...interface{}) error {
 	return internalError(fmt.Sprintf(format, args...))
 }
diff --git a/internal/gcimporter/iimport.go b/internal/gcimporter/iimport.go
index 94a5eba333f..fb6554f9261 100644
--- a/internal/gcimporter/iimport.go
+++ b/internal/gcimporter/iimport.go
@@ -85,7 +85,7 @@ const (
 // If the export data version is not recognized or the format is otherwise
 // compromised, an error is returned.
 func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (int, *types.Package, error) {
-	pkgs, err := iimportCommon(fset, GetPackageFromMap(imports), data, false, path, nil)
+	pkgs, err := iimportCommon(fset, GetPackagesFromMap(imports), data, false, path, false)
 	if err != nil {
 		return 0, nil, err
 	}
@@ -94,33 +94,49 @@ func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []
 
 // IImportBundle imports a set of packages from the serialized package bundle.
 func IImportBundle(fset *token.FileSet, imports map[string]*types.Package, data []byte) ([]*types.Package, error) {
-	return iimportCommon(fset, GetPackageFromMap(imports), data, true, "", nil)
+	return iimportCommon(fset, GetPackagesFromMap(imports), data, true, "", false)
 }
 
-// A GetPackageFunc is a function that gets the package with the given path
-// from the importer state, creating it (with the specified name) if necessary.
-// It is an abstraction of the map historically used to memoize package creation.
+// A GetPackagesFunc function obtains the non-nil symbols for a set of
+// packages, creating and recursively importing them as needed. An
+// implementation should store each package symbol is in the Pkg
+// field of the items array.
 //
-// Two calls with the same path must return the same package.
-//
-// If the given getPackage func returns nil, the import will fail.
-type GetPackageFunc = func(path, name string) *types.Package
+// Any error causes importing to fail. This can be used to quickly read
+// the import manifest of an export data file without fully decoding it.
+type GetPackagesFunc = func(items []GetPackagesItem) error
+
+// A GetPackagesItem is a request from the importer for the package
+// symbol of the specified name and path.
+type GetPackagesItem struct {
+	Name, Path string
+	Pkg        *types.Package // to be filled in by GetPackagesFunc call
 
-// GetPackageFromMap returns a GetPackageFunc that retrieves packages from the
-// given map of package path -> package.
+	// private importer state
+	pathOffset uint64
+	nameIndex  map[string]uint64
+}
+
+// GetPackagesFromMap returns a GetPackagesFunc that retrieves
+// packages from the given map of package path to package.
 //
-// The resulting func may mutate m: if a requested package is not found, a new
-// package will be inserted into m.
-func GetPackageFromMap(m map[string]*types.Package) GetPackageFunc {
-	return func(path, name string) *types.Package {
-		if _, ok := m[path]; !ok {
-			m[path] = types.NewPackage(path, name)
+// The returned function may mutate m: each requested package that is not
+// found is created with types.NewPackage and inserted into m.
+func GetPackagesFromMap(m map[string]*types.Package) GetPackagesFunc {
+	return func(items []GetPackagesItem) error {
+		for i, item := range items {
+			pkg, ok := m[item.Path]
+			if !ok {
+				pkg = types.NewPackage(item.Path, item.Name)
+				m[item.Path] = pkg
+			}
+			items[i].Pkg = pkg
 		}
-		return m[path]
+		return nil
 	}
 }
 
-func iimportCommon(fset *token.FileSet, getPackage GetPackageFunc, data []byte, bundle bool, path string, insert InsertType) (pkgs []*types.Package, err error) {
+func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte, bundle bool, path string, shallow bool) (pkgs []*types.Package, err error) {
 	const currentVersion = iexportVersionCurrent
 	version := int64(-1)
 	if !debug {
@@ -159,7 +175,7 @@ func iimportCommon(fset *token.FileSet, getPackage GetPackageFunc, data []byte,
 	sLen := int64(r.uint64())
 	var fLen int64
 	var fileOffset []uint64
-	if insert != nil {
+	if shallow {
 		// Shallow mode uses a different position encoding.
 		fLen = int64(r.uint64())
 		fileOffset = make([]uint64, r.uint64())
@@ -176,9 +192,9 @@ func iimportCommon(fset *token.FileSet, getPackage GetPackageFunc, data []byte,
 	r.Seek(sLen+fLen+dLen, io.SeekCurrent)
 
 	p := iimporter{
-		version: int(version),
-		ipath:   path,
-		insert:  insert,
+		version:  int(version),
+		ipath:    path,
+		usePosv2: shallow, // precise offsets are encoded only in shallow mode
 
 		stringData:  stringData,
 		stringCache: make(map[uint64]string),
@@ -205,8 +221,9 @@ func iimportCommon(fset *token.FileSet, getPackage GetPackageFunc, data []byte,
 		p.typCache[uint64(i)] = pt
 	}
 
-	pkgList := make([]*types.Package, r.uint64())
-	for i := range pkgList {
+	// Gather the relevant packages from the manifest.
+	items := make([]GetPackagesItem, r.uint64())
+	for i := range items {
 		pkgPathOff := r.uint64()
 		pkgPath := p.stringAt(pkgPathOff)
 		pkgName := p.stringAt(r.uint64())
@@ -215,29 +232,42 @@ func iimportCommon(fset *token.FileSet, getPackage GetPackageFunc, data []byte,
 		if pkgPath == "" {
 			pkgPath = path
 		}
-		pkg := getPackage(pkgPath, pkgName)
-		if pkg == nil {
-			errorf("internal error: getPackage returned nil package for %s", pkgPath)
-		} else if pkg.Name() != pkgName {
-			errorf("conflicting names %s and %s for package %q", pkg.Name(), pkgName, path)
-		}
-		if i == 0 && !bundle {
-			p.localpkg = pkg
-		}
-
-		p.pkgCache[pkgPathOff] = pkg
+		items[i].Name = pkgName
+		items[i].Path = pkgPath
+		items[i].pathOffset = pkgPathOff
 
 		// Read index for package.
 		nameIndex := make(map[string]uint64)
 		nSyms := r.uint64()
-		// In shallow mode we don't expect an index for other packages.
-		assert(nSyms == 0 || p.localpkg == pkg || p.insert == nil)
+		// In shallow mode, only the current package (i=0) has an index.
+		assert(!(shallow && i > 0 && nSyms != 0))
 		for ; nSyms > 0; nSyms-- {
 			name := p.stringAt(r.uint64())
 			nameIndex[name] = r.uint64()
 		}
 
-		p.pkgIndex[pkg] = nameIndex
+		items[i].nameIndex = nameIndex
+	}
+
+	// Request packages all at once from the client,
+	// enabling a parallel implementation.
+	if err := getPackages(items); err != nil {
+		return nil, err // don't wrap this error
+	}
+
+	// Check the results and complete the index.
+	pkgList := make([]*types.Package, len(items))
+	for i, item := range items {
+		pkg := item.Pkg
+		if pkg == nil {
+			errorf("internal error: getPackages returned nil package for %q", item.Path)
+		} else if pkg.Path() != item.Path {
+			errorf("internal error: getPackages returned wrong path %q, want %q", pkg.Path(), item.Path)
+		} else if pkg.Name() != item.Name {
+			errorf("internal error: getPackages returned wrong name %s for package %q, want %s", pkg.Name(), item.Path, item.Name)
+		}
+		p.pkgCache[item.pathOffset] = pkg
+		p.pkgIndex[pkg] = item.nameIndex
 		pkgList[i] = pkg
 	}
 
@@ -308,8 +338,7 @@ type iimporter struct {
 	version int
 	ipath   string
 
-	localpkg *types.Package
-	insert   func(pkg *types.Package, name string) // "shallow" mode only
+	usePosv2 bool
 
 	stringData  []byte
 	stringCache map[uint64]string
@@ -357,13 +386,9 @@ func (p *iimporter) doDecl(pkg *types.Package, name string) {
 
 	off, ok := p.pkgIndex[pkg][name]
 	if !ok {
-		// In "shallow" mode, call back to the application to
-		// find the object and insert it into the package scope.
-		if p.insert != nil {
-			assert(pkg != p.localpkg)
-			p.insert(pkg, name) // "can't fail"
-			return
-		}
+		// In deep mode, the index should be complete. In shallow
+		// mode, we should have already recursively loaded necessary
+		// dependencies so the above Lookup succeeds.
 		errorf("%v.%v not in index", pkg, name)
 	}
 
@@ -730,7 +755,7 @@ func (r *importReader) qualifiedIdent() (*types.Package, string) {
 }
 
 func (r *importReader) pos() token.Pos {
-	if r.p.insert != nil { // shallow mode
+	if r.p.usePosv2 {
 		return r.posv2()
 	}
 	if r.p.version >= iexportVersionPosCol {
diff --git a/internal/gcimporter/shallow_test.go b/internal/gcimporter/shallow_test.go
index f73d1b39182..b775a3578de 100644
--- a/internal/gcimporter/shallow_test.go
+++ b/internal/gcimporter/shallow_test.go
@@ -113,30 +113,33 @@ func typecheck(t *testing.T, ppkg *packages.Package) {
 
 	// importer state
 	var (
-		insert    func(p *types.Package, name string)
-		importMap = make(map[string]*types.Package) // keys are PackagePaths
-	)
-	loadFromExportData := func(imp *packages.Package) (*types.Package, error) {
-		data := []byte(imp.ExportFile)
-		return gcimporter.IImportShallow(fset, gcimporter.GetPackageFromMap(importMap), data, imp.PkgPath, insert)
-	}
-	insert = func(p *types.Package, name string) {
-		imp, ok := depsByPkgPath[p.Path()]
-		if !ok {
-			t.Fatalf("can't find dependency: %q", p.Path())
-		}
-		imported, err := loadFromExportData(imp)
-		if err != nil {
-			t.Fatalf("unmarshal: %v", err)
-		}
-		if imported != p {
-			t.Fatalf("internal error: inconsistent packages")
+		loadFromExportData func(*packages.Package) (*types.Package, error)
+		importMap          = map[string]*types.Package{ // keys are PackagePaths
+			ppkg.PkgPath: types.NewPackage(ppkg.PkgPath, ppkg.Name),
 		}
-		if obj := imported.Scope().Lookup(name); obj == nil {
-			t.Fatalf("lookup %q.%s failed", imported.Path(), name)
+	)
+	loadFromExportData = func(imp *packages.Package) (*types.Package, error) {
+		export := []byte(imp.ExportFile)
+		getPackages := func(items []gcimporter.GetPackagesItem) error {
+			for i, item := range items {
+				pkg, ok := importMap[item.Path]
+				if !ok {
+					dep, ok := depsByPkgPath[item.Path]
+					if !ok {
+						return fmt.Errorf("can't find dependency: %q", item.Path)
+					}
+					pkg = types.NewPackage(item.Path, dep.Name)
+					importMap[item.Path] = pkg
+					loadFromExportData(dep) // side effect: populate package scope
+				}
+				items[i].Pkg = pkg
+			}
+			return nil
 		}
+		return gcimporter.IImportShallow(fset, getPackages, export, imp.PkgPath)
 	}
 
+	// Type-check the syntax trees.
 	cfg := &types.Config{
 		Error: func(e error) {
 			t.Error(e)
@@ -153,8 +156,10 @@ func typecheck(t *testing.T, ppkg *packages.Package) {
 		}),
 	}
 
-	// Type-check the syntax trees.
-	tpkg, _ := cfg.Check(ppkg.PkgPath, fset, syntax, nil)
+	// (Use NewChecker+Files to ensure Package.Name is set explicitly.)
+	tpkg := types.NewPackage(ppkg.PkgPath, ppkg.Name)
+	_ = types.NewChecker(cfg, fset, tpkg, nil).Files(syntax) // ignore error
+	// Check sanity.
 	postTypeCheck(t, fset, tpkg)
 
 	// Save the export data.

From 155320d396edafbf0c588d4aa98099f9eb19b7dd Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 15 Jun 2023 16:21:26 -0400
Subject: [PATCH 04/26] gopls/internal/lsp/work: don't crash when hovering over
 broken mod dir

Guard against modfiles without a module directive.

Fixes golang/go#60821

Change-Id: I91661b2abea916db55a81323fc26dcd4f2f0516c
Reviewed-on: https://go-review.googlesource.com/c/tools/+/503436
gopls-CI: kokoro <noreply+kokoro@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Robert Findley <rfindley@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
---
 gopls/internal/lsp/cache/mod.go           |  2 +-
 gopls/internal/lsp/mod/diagnostics.go     |  8 +++++++-
 gopls/internal/lsp/work/hover.go          |  3 +++
 gopls/internal/regtest/misc/hover_test.go | 20 ++++++++++++++++++++
 4 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/gopls/internal/lsp/cache/mod.go b/gopls/internal/lsp/cache/mod.go
index 50c8b00777e..8b6331d056d 100644
--- a/gopls/internal/lsp/cache/mod.go
+++ b/gopls/internal/lsp/cache/mod.go
@@ -400,7 +400,7 @@ func (s *snapshot) matchErrorToModule(ctx context.Context, pm *source.ParsedModu
 		// Show the error on the module declaration, if one exists, or
 		// just the first line of the file.
 		var start, end int
-		if pm.File.Module != nil {
+		if pm.File.Module != nil && pm.File.Module.Syntax != nil {
 			syntax := pm.File.Module.Syntax
 			start, end = syntax.Start.Byte, syntax.End.Byte
 		}
diff --git a/gopls/internal/lsp/mod/diagnostics.go b/gopls/internal/lsp/mod/diagnostics.go
index cd1c85b2613..91d6c7ed90c 100644
--- a/gopls/internal/lsp/mod/diagnostics.go
+++ b/gopls/internal/lsp/mod/diagnostics.go
@@ -331,7 +331,13 @@ func ModVulnerabilityDiagnostics(ctx context.Context, snapshot source.Snapshot,
 	// TODO(hyangah): place this diagnostic on the `go` directive or `toolchain` directive
 	// after https://go.dev/issue/57001.
 	const diagnoseStdLib = false
-	if diagnoseStdLib {
+
+	// If diagnosing the stdlib, add standard library vulnerability diagnostics
+	// on the module declaration.
+	//
+	// Only proceed if we have a valid module declaration on which to position
+	// the diagnostics.
+	if diagnoseStdLib && pm.File.Module != nil && pm.File.Module.Syntax != nil {
 		// Add standard library vulnerabilities.
 		stdlibVulns := vulnsByModule["stdlib"]
 		if len(stdlibVulns) == 0 {
diff --git a/gopls/internal/lsp/work/hover.go b/gopls/internal/lsp/work/hover.go
index f576d696c18..558eebc824b 100644
--- a/gopls/internal/lsp/work/hover.go
+++ b/gopls/internal/lsp/work/hover.go
@@ -52,6 +52,9 @@ func Hover(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle,
 	if err != nil {
 		return nil, fmt.Errorf("getting modfile handle: %w", err)
 	}
+	if pm.File.Module == nil {
+		return nil, fmt.Errorf("modfile has no module declaration")
+	}
 	mod := pm.File.Module.Mod
 
 	// Get the range to highlight for the hover.
diff --git a/gopls/internal/regtest/misc/hover_test.go b/gopls/internal/regtest/misc/hover_test.go
index 41c6529a7bf..9b2d86ebb69 100644
--- a/gopls/internal/regtest/misc/hover_test.go
+++ b/gopls/internal/regtest/misc/hover_test.go
@@ -415,3 +415,23 @@ func TestHoverLinknameDirective(t *testing.T) {
 		}
 	})
 }
+
+func TestHoverGoWork_Issue60821(t *testing.T) {
+	const files = `
+-- go.work --
+go 1.19
+
+use (
+	moda
+	modb
+)
+-- moda/go.mod --
+
+`
+	Run(t, files, func(t *testing.T, env *Env) {
+		env.OpenFile("go.work")
+		// Neither of the requests below should crash gopls.
+		_, _, _ = env.Editor.Hover(env.Ctx, env.RegexpSearch("go.work", "moda"))
+		_, _, _ = env.Editor.Hover(env.Ctx, env.RegexpSearch("go.work", "modb"))
+	})
+}

From 6480332be24cd920bc0a15b9eb3a0cc020c1c33d Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Tue, 20 Jun 2023 15:12:10 -0400
Subject: [PATCH 05/26] gopls/internal/lsp/cache: use types.Unsafe in
 analysisPackage

Before, the early return in typeCheck forgot to set an.types.
Now the logic is pulled into single spot in the caller.

This change consolidates the various places that set
analysisNode.types to just two (syntax and export).

Change-Id: I2f1ea6b70888bd5874f76c57443fe46b1c04ae67
Reviewed-on: https://go-review.googlesource.com/c/tools/+/504558
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Alan Donovan <adonovan@google.com>
Auto-Submit: Alan Donovan <adonovan@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 gopls/internal/lsp/cache/analysis.go | 30 ++++++++++++++--------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/gopls/internal/lsp/cache/analysis.go b/gopls/internal/lsp/cache/analysis.go
index 5ba84278a0f..d9a457fd517 100644
--- a/gopls/internal/lsp/cache/analysis.go
+++ b/gopls/internal/lsp/cache/analysis.go
@@ -229,11 +229,6 @@ func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit,
 				allDeps:    make(map[PackagePath]*analysisNode),
 				exportDeps: make(map[PackagePath]*analysisNode),
 			}
-			// Unsafe must use a distinguished types.Package.
-			// Mark it as fully populated from birth.
-			if m.PkgPath == "unsafe" {
-				an.typesOnce.Do(func() { an.types = types.Unsafe })
-			}
 			nodes[id] = an
 
 			// -- recursion --
@@ -405,6 +400,11 @@ func (an *analysisNode) String() string { return string(an.m.ID) }
 // Postcondition: an.types and an.exportDeps are populated.
 func (an *analysisNode) _import() *types.Package {
 	an.typesOnce.Do(func() {
+		if an.m.PkgPath == "unsafe" {
+			an.types = types.Unsafe
+			return
+		}
+
 		an.types = types.NewPackage(string(an.m.PkgPath), string(an.m.Name))
 
 		// getPackages recursively imports each dependency
@@ -662,6 +662,12 @@ func (an *analysisNode) run(ctx context.Context) (*analyzeSummary, error) {
 	// Type-check the package syntax.
 	pkg := an.typeCheck(parsed)
 
+	// Publish the completed package.
+	an.typesOnce.Do(func() { an.types = pkg.types })
+	if an.types != pkg.types {
+		log.Fatalf("typesOnce prematurely done")
+	}
+
 	// Compute the union of exportDeps across our direct imports.
 	// This is the set that will be needed by the fact decoder.
 	allExportDeps := make(map[PackagePath]*analysisNode)
@@ -747,10 +753,9 @@ func (an *analysisNode) run(ctx context.Context) (*analyzeSummary, error) {
 	}, nil
 }
 
-// Postcondition: an.types and an.exportDeps are populated.
+// Postcondition: analysisPackage.types and an.exportDeps are populated.
 func (an *analysisNode) typeCheck(parsed []*source.ParsedGoFile) *analysisPackage {
 	m := an.m
-	fset := an.fset
 
 	if false { // debugging
 		log.Println("typeCheck", m.ID)
@@ -758,7 +763,7 @@ func (an *analysisNode) typeCheck(parsed []*source.ParsedGoFile) *analysisPackag
 
 	pkg := &analysisPackage{
 		m:        m,
-		fset:     fset,
+		fset:     an.fset,
 		parsed:   parsed,
 		files:    make([]*ast.File, len(parsed)),
 		compiles: len(m.Errors) == 0, // false => list error
@@ -777,6 +782,7 @@ func (an *analysisNode) typeCheck(parsed []*source.ParsedGoFile) *analysisPackag
 
 	// Unsafe has no syntax.
 	if m.PkgPath == "unsafe" {
+		pkg.types = types.Unsafe
 		return pkg
 	}
 
@@ -862,7 +868,7 @@ func (an *analysisNode) typeCheck(parsed []*source.ParsedGoFile) *analysisPackag
 	// TODO(adonovan): do we actually need this??
 	typesinternal.SetUsesCgo(cfg)
 
-	check := types.NewChecker(cfg, fset, pkg.types, pkg.typesInfo)
+	check := types.NewChecker(cfg, pkg.fset, pkg.types, pkg.typesInfo)
 
 	// Type checking errors are handled via the config, so ignore them here.
 	_ = check.Files(pkg.files)
@@ -874,12 +880,6 @@ func (an *analysisNode) typeCheck(parsed []*source.ParsedGoFile) *analysisPackag
 		}
 	}
 
-	// Publish the completed package.
-	an.typesOnce.Do(func() { an.types = pkg.types })
-	if an.types != pkg.types {
-		log.Fatalf("typesOnce prematurely done")
-	}
-
 	// Emit the export data and compute the recursive hash.
 	export, err := gcimporter.IExportShallow(pkg.fset, pkg.types)
 	if err != nil {

From 9960b693c44a8dfedafaca0da40a50d29e03fe42 Mon Sep 17 00:00:00 2001
From: Robert Findley <rfindley@google.com>
Date: Tue, 20 Jun 2023 11:33:29 -0400
Subject: [PATCH 06/26] gopls/internal/lsp/cache: guard against "unsafe" by
 package path, not ID

The crash in golang/go#60890 suggests that a user encountered a variant
of the unsafe package. I'm not sure how to reproduce this, but in any
case we should be checking package path, not ID, when guarding against
exporting "unsafe".

For golang/go#60890

Change-Id: Ib6c546b8f74ba513f5ee3df09b5ba29cea0c1b85
Reviewed-on: https://go-review.googlesource.com/c/tools/+/504555
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
---
 gopls/internal/lsp/cache/check.go | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/gopls/internal/lsp/cache/check.go b/gopls/internal/lsp/cache/check.go
index 81c81a30b5e..1b0844ad12d 100644
--- a/gopls/internal/lsp/cache/check.go
+++ b/gopls/internal/lsp/cache/check.go
@@ -453,6 +453,13 @@ func (b *typeCheckBatch) getImportPackage(ctx context.Context, id PackageID) (pk
 	}
 
 	ph := b.handles[id]
+
+	// Do a second check for "unsafe" defensively, due to golang/go#60890.
+	if ph.m.PkgPath == "unsafe" {
+		bug.Reportf("encountered \"unsafe\" as %s (golang/go#60890)", id)
+		return types.Unsafe, nil
+	}
+
 	data, err := filecache.Get(exportDataKind, ph.key)
 	if err == filecache.ErrNotFound {
 		// No cached export data: type-check as fast as possible.
@@ -632,13 +639,17 @@ func (b *typeCheckBatch) checkPackage(ctx context.Context, ph *packageHandle) (*
 				diagnosticsKind: encodeDiagnostics(pkg.diagnostics),
 			}
 
-			if ph.m.ID != "unsafe" { // unsafe cannot be exported
+			if ph.m.PkgPath != "unsafe" { // unsafe cannot be exported
 				exportData, err := gcimporter.IExportShallow(pkg.fset, pkg.types)
 				if err != nil {
 					bug.Reportf("exporting package %v: %v", ph.m.ID, err)
 				} else {
 					toCache[exportDataKind] = exportData
 				}
+			} else if ph.m.ID != "unsafe" {
+				// golang/go#60890: we should only ever see one variant of the "unsafe"
+				// package.
+				bug.Reportf("encountered \"unsafe\" as %s (golang/go#60890)", ph.m.ID)
 			}
 
 			for kind, data := range toCache {

From 85554d61b94ee8b082a43399ebf894cf08d59b5a Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Tue, 20 Jun 2023 16:52:59 -0400
Subject: [PATCH 07/26] gopls/internal/lsp/cache: add debugging assertion for
 golang/go#60904

Updates golang/go#60904

Change-Id: Ia9f259716732705060a0d3675cd701c6c68a215f
Reviewed-on: https://go-review.googlesource.com/c/tools/+/504695
gopls-CI: kokoro <noreply+kokoro@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Alan Donovan <adonovan@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
Auto-Submit: Alan Donovan <adonovan@google.com>
---
 gopls/internal/lsp/cache/check.go | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/gopls/internal/lsp/cache/check.go b/gopls/internal/lsp/cache/check.go
index 1b0844ad12d..14877ff44e3 100644
--- a/gopls/internal/lsp/cache/check.go
+++ b/gopls/internal/lsp/cache/check.go
@@ -541,14 +541,25 @@ func (b *typeCheckBatch) importPackage(ctx context.Context, m *source.Metadata,
 	thisPackage := types.NewPackage(string(m.PkgPath), string(m.Name))
 	getPackages := func(items []gcimporter.GetPackagesItem) error {
 		for i, item := range items {
+			var id PackageID
+			var pkg *types.Package
 			if item.Path == string(m.PkgPath) {
-				items[i].Pkg = thisPackage
+				id = m.ID
+				pkg = thisPackage
 			} else {
-				pkg, err := b.getImportPackage(ctx, impMap[item.Path])
+				id = impMap[item.Path]
+				var err error
+				pkg, err = b.getImportPackage(ctx, id)
 				if err != nil {
 					return err
 				}
-				items[i].Pkg = pkg
+			}
+			items[i].Pkg = pkg
+
+			// debugging issue #60904
+			if pkg.Name() != item.Name {
+				return bug.Errorf("internal error: package name is %q, want %q (id=%q, path=%q) (see issue #60904)",
+					pkg.Name(), item.Name, id, item.Path)
 			}
 		}
 		return nil

From 0ca9d30bb602329aef3311e5e6264d6be7388410 Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Wed, 21 Jun 2023 10:41:09 -0400
Subject: [PATCH 08/26] gopls/internal/lsp/cache: fix nil panic in analysis
 toSourceDiagnostic

The set of enabled analyzers is expanded to include requirements,
but we should not use the expanded set in the final loop when
we map back to source.Analyzers. Nonetheless, it is surprising
that any analyzer only in the expandes set should report a
diagnostics, so I've added an assertion.

Fixes golang/go#60909

Change-Id: I3b6e21194f7d717628822b933e6f4a387f719a1c
Reviewed-on: https://go-review.googlesource.com/c/tools/+/504818
Run-TryBot: Alan Donovan <adonovan@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
Auto-Submit: Alan Donovan <adonovan@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
---
 gopls/internal/lsp/cache/analysis.go | 33 ++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/gopls/internal/lsp/cache/analysis.go b/gopls/internal/lsp/cache/analysis.go
index d9a457fd517..ad55f2f9776 100644
--- a/gopls/internal/lsp/cache/analysis.go
+++ b/gopls/internal/lsp/cache/analysis.go
@@ -176,7 +176,7 @@ func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit,
 	// Filter and sort enabled root analyzers.
 	// A disabled analyzer may still be run if required by another.
 	toSrc := make(map[*analysis.Analyzer]*source.Analyzer)
-	var enabled []*analysis.Analyzer
+	var enabled []*analysis.Analyzer // enabled subset + transitive requirements
 	for _, a := range analyzers {
 		if a.IsEnabled(snapshot.view.Options()) {
 			toSrc[a.Analyzer] = a
@@ -190,16 +190,16 @@ func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit,
 
 	// Register fact types of required analyzers.
 	enabled = requiredAnalyzers(enabled)
-	var useFacts []*analysis.Analyzer
+	var facty []*analysis.Analyzer // facty subset of enabled + transitive requirements
 	for _, a := range enabled {
 		if len(a.FactTypes) > 0 {
-			useFacts = append(useFacts, a)
+			facty = append(facty, a)
 			for _, f := range a.FactTypes {
 				gob.Register(f) // <2us
 			}
 		}
 	}
-	useFacts = requiredAnalyzers(useFacts)
+	facty = requiredAnalyzers(facty)
 
 	// File set for this batch (entire graph) of analysis.
 	fset := token.NewFileSet()
@@ -208,7 +208,9 @@ func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit,
 	// build the DAG of packages we're going to analyze.
 	//
 	// Root nodes will run the enabled set of analyzers,
-	// whereas dependencies will run only the useFacts set.
+	// whereas dependencies will run only the facty set.
+	// Because (by construction) enabled is a superset of facty,
+	// we can analyze each node with exactly one set of analyzers.
 	nodes := make(map[PackageID]*analysisNode)
 	var leaves []*analysisNode // nodes with no unfinished successors
 	var makeNode func(from *analysisNode, id PackageID) (*analysisNode, error)
@@ -225,7 +227,7 @@ func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit,
 			an = &analysisNode{
 				fset:       fset,
 				m:          m,
-				analyzers:  useFacts, // all nodes run at least the facty analyzers
+				analyzers:  facty, // all nodes run at least the facty analyzers
 				allDeps:    make(map[PackagePath]*analysisNode),
 				exportDeps: make(map[PackagePath]*analysisNode),
 			}
@@ -338,6 +340,23 @@ func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit,
 	var results []*source.Diagnostic
 	for _, root := range roots {
 		for _, a := range enabled {
+			// Skip analyzers that were added only to
+			// fulfil requirements of the original set.
+			srcAnalyzer, ok := toSrc[a]
+			if !ok {
+				// Although this 'skip' operation is logically sound,
+				// it is nonetheless surprising that its absence should
+				// cause #60909 since none of the analyzers added for
+				// requirements (e.g. ctrlflow, inspect, buildssa)
+				// is capable of reporting diagnostics.
+				if summary := root.summary.Actions[a.Name]; summary != nil {
+					if n := len(summary.Diagnostics); n > 0 {
+						bug.Reportf("Internal error: got %d unexpected diagnostics from analyzer %s. This analyzer was added only to fulfil the requirements of the requested set of analyzers, and it is not expected that such analyzers report diagnostics. Please report this in issue #60909.", n, a)
+					}
+				}
+				continue
+			}
+
 			// Inv: root.summary is the successful result of run (via runCached).
 			summary, ok := root.summary.Actions[a.Name]
 			if summary == nil {
@@ -348,7 +367,7 @@ func (snapshot *snapshot) Analyze(ctx context.Context, pkgs map[PackageID]unit,
 				continue // action failed
 			}
 			for _, gobDiag := range summary.Diagnostics {
-				results = append(results, toSourceDiagnostic(toSrc[a], &gobDiag))
+				results = append(results, toSourceDiagnostic(srcAnalyzer, &gobDiag))
 			}
 		}
 	}

From 63624dfc81c499476bef6cb30baae98fcf5b8f0b Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Wed, 14 Jun 2023 11:08:30 -0400
Subject: [PATCH 09/26] gopls/internal/lsp/cache: remove ITVs from shared
 import graph

The shared import graph exists to optimize type-checking of open
packages following a change. But we should only ever ask for ITVs when
type-checking the entire workspace (in the debounced call to
diagnoseSnapshot).

For golang/go#53992

Change-Id: Ie968d4b2a0476822999aa216c678bed370aaa67b
Reviewed-on: https://go-review.googlesource.com/c/tools/+/503316
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Alan Donovan <adonovan@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
---
 gopls/internal/lsp/cache/check.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/gopls/internal/lsp/cache/check.go b/gopls/internal/lsp/cache/check.go
index 14877ff44e3..9329d4bd0d1 100644
--- a/gopls/internal/lsp/cache/check.go
+++ b/gopls/internal/lsp/cache/check.go
@@ -205,7 +205,11 @@ func (s *snapshot) resolveImportGraph() (*importGraph, error) {
 	openPackages := make(map[PackageID]bool)
 	for _, fh := range s.overlays() {
 		for _, id := range meta.ids[fh.URI()] {
-			openPackages[id] = true
+			// TODO(rfindley): remove this defensiveness after the release. We can
+			// rely on m.metadata[id] != nil.
+			if m := meta.metadata[id]; m != nil && !m.IsIntermediateTestVariant() {
+				openPackages[id] = true
+			}
 		}
 	}
 

From 87df9bcac8d968740c8a22f1a2210cae39501a4c Mon Sep 17 00:00:00 2001
From: Heschi Kreinick <heschi@google.com>
Date: Wed, 21 Jun 2023 16:23:23 -0400
Subject: [PATCH 10/26] cmd/godoc: disable TestWebIndex, a very slow test

It's timing out when run under the race detector.

Change-Id: I40b0fb669f4bdb0f2110856146786176235c6653
Reviewed-on: https://go-review.googlesource.com/c/tools/+/504995
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Heschi Kreinick <heschi@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 cmd/godoc/godoc_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cmd/godoc/godoc_test.go b/cmd/godoc/godoc_test.go
index 63df8974978..b2ebe8581a6 100644
--- a/cmd/godoc/godoc_test.go
+++ b/cmd/godoc/godoc_test.go
@@ -187,6 +187,7 @@ func TestWeb(t *testing.T) {
 
 // Basic integration test for godoc HTTP interface.
 func TestWebIndex(t *testing.T) {
+	t.Skip("slow test of to-be-deleted code (golang/go#59056)")
 	if testing.Short() {
 		t.Skip("skipping slow test in -short mode")
 	}

From c8278fe909aba46f3cad6253a0d3b1303a16ad72 Mon Sep 17 00:00:00 2001
From: Rob Findley <rfindley@google.com>
Date: Thu, 22 Jun 2023 16:36:59 -0400
Subject: [PATCH 11/26] gopls/internal/lsp/cache: don't record edges to invalid
 packages

The importer assumes that packages have non-empty package path and name.
Enforce this invariant when loading metadata.

Fixes golang/go#60952

Change-Id: I2f4f18e475ba306d93c8b649d19897a584e5ba19
Reviewed-on: https://go-review.googlesource.com/c/tools/+/505219
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Alan Donovan <adonovan@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
---
 go/packages/golist.go            |  3 +++
 gopls/internal/lsp/cache/load.go | 14 +++++++++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/go/packages/golist.go b/go/packages/golist.go
index e84f19dfa98..58230038a7c 100644
--- a/go/packages/golist.go
+++ b/go/packages/golist.go
@@ -671,6 +671,9 @@ func (state *golistState) createDriverResponse(words ...string) (*driverResponse
 		// Temporary work-around for golang/go#39986. Parse filenames out of
 		// error messages. This happens if there are unrecoverable syntax
 		// errors in the source, so we can't match on a specific error message.
+		//
+		// TODO(rfindley): remove this heuristic, in favor of considering
+		// InvalidGoFiles from the list driver.
 		if err := p.Error; err != nil && state.shouldAddFilenameFromError(p) {
 			addFilenameFromPos := func(pos string) bool {
 				split := strings.Split(pos, ":")
diff --git a/gopls/internal/lsp/cache/load.go b/gopls/internal/lsp/cache/load.go
index da985a8ea38..eb302b7b332 100644
--- a/gopls/internal/lsp/cache/load.go
+++ b/gopls/internal/lsp/cache/load.go
@@ -528,9 +528,21 @@ func buildMetadata(updates map[PackageID]*source.Metadata, pkg *packages.Package
 			continue
 		}
 
+		buildMetadata(updates, imported, loadDir, false) // only top level packages can be standalone
+
+		// Don't record edges to packages with no name, as they cause trouble for
+		// the importer (golang/go#60952).
+		//
+		// However, we do want to insert these packages into the update map
+		// (buildMetadata above), so that we get type-checking diagnostics for the
+		// invalid packages.
+		if imported.Name == "" {
+			depsByImpPath[importPath] = "" // missing
+			continue
+		}
+
 		depsByImpPath[importPath] = PackageID(imported.ID)
 		depsByPkgPath[PackagePath(imported.PkgPath)] = PackageID(imported.ID)
-		buildMetadata(updates, imported, loadDir, false) // only top level packages can be standalone
 	}
 	m.DepsByImpPath = depsByImpPath
 	m.DepsByPkgPath = depsByPkgPath

From fa103593d02f86f400531e4294b9b294d4893901 Mon Sep 17 00:00:00 2001
From: Robert Findley <rfindley@google.com>
Date: Fri, 23 Jun 2023 09:32:56 -0400
Subject: [PATCH 12/26] gopls/internal/lsp/cache: don't panic when import fails
 during analysis

We have received a number of empty crash reports for gopls since cutting
the v0.12.3 release. We don't want to auto-populate crash reports with
log.Fatal messages (as unlike panicking stacks they may contain the name
of user packages), so in almost all cases we lose information as to why
gopls crashed (users are unlikely to pre-populate this information).

In general, I don't think failing analysis should crash the process, so
switch this failure mode to a bug report.

Fixes golang/go#60963

Change-Id: I670ee4b1adbe9f37d763c5684b14d4bcb78dcb63
Reviewed-on: https://go-review.googlesource.com/c/tools/+/505575
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
Run-TryBot: Robert Findley <rfindley@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
---
 gopls/internal/lsp/cache/analysis.go | 36 ++++++++++++++++++----------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/gopls/internal/lsp/cache/analysis.go b/gopls/internal/lsp/cache/analysis.go
index ad55f2f9776..52e730b65fb 100644
--- a/gopls/internal/lsp/cache/analysis.go
+++ b/gopls/internal/lsp/cache/analysis.go
@@ -408,8 +408,10 @@ type analysisNode struct {
 	exportDeps map[PackagePath]*analysisNode // subset of allDeps ref'd by export data (+self)
 	count      int32                         // number of unfinished successors
 	summary    *analyzeSummary               // serializable result of analyzing this package
-	typesOnce  sync.Once                     // guards lazy population of types field
-	types      *types.Package                // type information lazily imported from summary
+
+	typesOnce sync.Once      // guards lazy population of types and typesErr fields
+	types     *types.Package // type information lazily imported from summary
+	typesErr  error          // an error producing type information
 }
 
 func (an *analysisNode) String() string { return string(an.m.ID) }
@@ -417,7 +419,7 @@ func (an *analysisNode) String() string { return string(an.m.ID) }
 // _import imports this node's types.Package from export data, if not already done.
 // Precondition: analysis was a success.
 // Postcondition: an.types and an.exportDeps are populated.
-func (an *analysisNode) _import() *types.Package {
+func (an *analysisNode) _import() (*types.Package, error) {
 	an.typesOnce.Do(func() {
 		if an.m.PkgPath == "unsafe" {
 			an.types = types.Unsafe
@@ -439,12 +441,19 @@ func (an *analysisNode) _import() *types.Package {
 				}
 				an.exportDeps[path] = dep // record, for later fact decoding
 				if dep == an {
-					items[i].Pkg = an.types
+					if an.typesErr != nil {
+						return an.typesErr
+					} else {
+						items[i].Pkg = an.types
+					}
 				} else {
 					i := i
 					g.Go(func() error {
-						items[i].Pkg = dep._import()
-						return nil
+						depPkg, err := dep._import()
+						if err == nil {
+							items[i].Pkg = depPkg
+						}
+						return err
 					})
 				}
 			}
@@ -452,13 +461,13 @@ func (an *analysisNode) _import() *types.Package {
 		}
 		pkg, err := gcimporter.IImportShallow(an.fset, getPackages, an.summary.Export, string(an.m.PkgPath))
 		if err != nil {
-			log.Fatalf("%s: invalid export data: %v", an.m, err)
-		}
-		if pkg != an.types {
+			an.typesErr = bug.Errorf("%s: invalid export data: %v", an.m, err)
+			an.types = nil
+		} else if pkg != an.types {
 			log.Fatalf("%s: inconsistent packages", an.m)
 		}
 	})
-	return an.types
+	return an.types, an.typesErr
 }
 
 // analyzeSummary is a gob-serializable summary of successfully
@@ -703,7 +712,10 @@ func (an *analysisNode) run(ctx context.Context) (*analyzeSummary, error) {
 		// Does the fact relate to a package referenced by export data?
 		if dep, ok := allExportDeps[PackagePath(path)]; ok {
 			dep.typesOnce.Do(func() { log.Fatal("dep.types not populated") })
-			return dep.types
+			if dep.typesErr == nil {
+				return dep.types
+			}
+			return nil
 		}
 
 		// If the fact relates to a dependency not referenced
@@ -867,7 +879,7 @@ func (an *analysisNode) typeCheck(parsed []*source.ParsedGoFile) *analysisPackag
 				return nil, fmt.Errorf("invalid use of internal package %s", importPath)
 			}
 
-			return dep._import(), nil
+			return dep._import()
 		}),
 	}
 

From 8f9bce43b33fe41595fc72852efefcb52a099c18 Mon Sep 17 00:00:00 2001
From: Lasse Folger <lassefolger@google.com>
Date: Fri, 23 Jun 2023 12:37:29 +0200
Subject: [PATCH 13/26] go/ast/inspector: clarify behavior regarding comment
 traversal

The inspector does not walk all ast.Comments nodes but only those
attached to declarations (i.e. doc comments). Clarify this in the
the documentation of the traversal functions.

Change-Id: I5cc9c5914fc8a7f0687ae632ba884d1317a4a7cb
Reviewed-on: https://go-review.googlesource.com/c/tools/+/505495
Auto-Submit: Alan Donovan <adonovan@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
Run-TryBot: Alan Donovan <adonovan@google.com>
---
 go/ast/inspector/inspector.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/go/ast/inspector/inspector.go b/go/ast/inspector/inspector.go
index 3fbfebf3693..1fc1de0bd10 100644
--- a/go/ast/inspector/inspector.go
+++ b/go/ast/inspector/inspector.go
@@ -64,8 +64,9 @@ type event struct {
 // depth-first order. It calls f(n) for each node n before it visits
 // n's children.
 //
+// The complete traversal sequence is determined by ast.Inspect.
 // The types argument, if non-empty, enables type-based filtering of
-// events. The function f if is called only for nodes whose type
+// events. The function f is called only for nodes whose type
 // matches an element of the types slice.
 func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
 	// Because it avoids postorder calls to f, and the pruning
@@ -97,6 +98,7 @@ func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
 // of the non-nil children of the node, followed by a call of
 // f(n, false).
 //
+// The complete traversal sequence is determined by ast.Inspect.
 // The types argument, if non-empty, enables type-based filtering of
 // events. The function f if is called only for nodes whose type
 // matches an element of the types slice.

From 9d8d4089ca1bf8aa2bf11dbffa5803f76cf0968d Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Fri, 23 Jun 2023 11:50:36 -0400
Subject: [PATCH 14/26] gopls/internal/lsp/cmd: list bug reports in 'gopls bug'

This change causes gopls bug to print cached bug reports to stdout,
and to summarize them (by file:line) in the GitHub Issue form.
We don't post the bug contents, but we invite the user to copy
them.

Also, move the undocumented bug injection (for testing) from
'gopls stats' to 'gopls bug'.

Updates golang/go#60969

Change-Id: I19648e978dca3b74954d17ac449e22537c5f1e02
Reviewed-on: https://go-review.googlesource.com/c/tools/+/505579
Reviewed-by: Hyang-Ah Hana Kim <hyangah@gmail.com>
Run-TryBot: Alan Donovan <adonovan@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
---
 gopls/internal/lsp/cmd/info.go                | 74 ++++++++++++++++++-
 gopls/internal/lsp/cmd/stats.go               |  8 --
 .../internal/lsp/cmd/test/integration_test.go |  6 +-
 gopls/internal/lsp/filecache/filecache.go     |  2 +-
 4 files changed, 74 insertions(+), 16 deletions(-)

diff --git a/gopls/internal/lsp/cmd/info.go b/gopls/internal/lsp/cmd/info.go
index 68ef40ffb29..d63e24b6bfc 100644
--- a/gopls/internal/lsp/cmd/info.go
+++ b/gopls/internal/lsp/cmd/info.go
@@ -12,10 +12,13 @@ import (
 	"fmt"
 	"net/url"
 	"os"
+	"sort"
 	"strings"
 
+	goplsbug "golang.org/x/tools/gopls/internal/bug"
 	"golang.org/x/tools/gopls/internal/lsp/browser"
 	"golang.org/x/tools/gopls/internal/lsp/debug"
+	"golang.org/x/tools/gopls/internal/lsp/filecache"
 	"golang.org/x/tools/gopls/internal/lsp/source"
 	"golang.org/x/tools/internal/tool"
 )
@@ -128,10 +131,50 @@ A failing unit test is the best.
 // Run collects some basic information and then prepares an issue ready to
 // be reported.
 func (b *bug) Run(ctx context.Context, args ...string) error {
-	buf := &bytes.Buffer{}
-	fmt.Fprint(buf, goplsBugHeader)
-	debug.PrintVersionInfo(ctx, buf, true, debug.Markdown)
-	body := buf.String()
+	// This undocumented environment variable allows
+	// the cmd integration test (and maintainers) to
+	// trigger a call to bug.Report.
+	if msg := os.Getenv("TEST_GOPLS_BUG"); msg != "" {
+		filecache.Start() // register bug handler
+		goplsbug.Report(msg)
+		return nil
+	}
+
+	// Enumerate bug reports, grouped and sorted.
+	_, reports := filecache.BugReports()
+	sort.Slice(reports, func(i, j int) bool {
+		x, y := reports[i], reports[i]
+		if x.Key != y.Key {
+			return x.Key < y.Key // ascending key order
+		}
+		return y.AtTime.Before(x.AtTime) // most recent first
+	})
+	keyDenom := make(map[string]int) // key is "file:line"
+	for _, report := range reports {
+		keyDenom[report.Key]++
+	}
+
+	// Privacy: the content of 'public' will be posted to GitHub
+	// to populate an issue textarea. Even though the user must
+	// submit the form to share the information with the world,
+	// merely populating the form causes us to share the
+	// information with GitHub itself.
+	//
+	// For that reason, we cannot write private information to
+	// public, such as bug reports, which may quote source code.
+	public := &bytes.Buffer{}
+	fmt.Fprint(public, goplsBugHeader)
+	if len(reports) > 0 {
+		fmt.Fprintf(public, "#### Internal errors\n\n")
+		fmt.Fprintf(public, "Gopls detected %d internal errors, %d distinct:\n",
+			len(reports), len(keyDenom))
+		for key, denom := range keyDenom {
+			fmt.Fprintf(public, "- %s (%d)\n", key, denom)
+		}
+		fmt.Fprintf(public, "\nPlease copy the full information printed by `gopls bug` here, if you are comfortable sharing it.\n\n")
+	}
+	debug.PrintVersionInfo(ctx, public, true, debug.Markdown)
+	body := public.String()
 	title := strings.Join(args, " ")
 	if !strings.HasPrefix(title, goplsBugPrefix) {
 		title = goplsBugPrefix + title
@@ -140,6 +183,29 @@ func (b *bug) Run(ctx context.Context, args ...string) error {
 		fmt.Print("Please file a new issue at golang.org/issue/new using this template:\n\n")
 		fmt.Print(body)
 	}
+
+	// Print bug reports to stdout (not GitHub).
+	keyNum := make(map[string]int)
+	for _, report := range reports {
+		fmt.Printf("-- %v -- \n", report.AtTime)
+
+		// Append seq number (e.g. " (1/2)") for repeated keys.
+		var seq string
+		if denom := keyDenom[report.Key]; denom > 1 {
+			keyNum[report.Key]++
+			seq = fmt.Sprintf(" (%d/%d)", keyNum[report.Key], denom)
+		}
+
+		// Privacy:
+		// - File and Stack may contain the name of the user that built gopls.
+		// - Description may contain names of the user's packages/files/symbols.
+		fmt.Printf("%s:%d: %s%s\n\n", report.File, report.Line, report.Description, seq)
+		fmt.Printf("%s\n\n", report.Stack)
+	}
+	if len(reports) > 0 {
+		fmt.Printf("Please copy the above information into the GitHub issue, if you are comfortable sharing it.\n")
+	}
+
 	return nil
 }
 
diff --git a/gopls/internal/lsp/cmd/stats.go b/gopls/internal/lsp/cmd/stats.go
index a681c5c0642..4986107134e 100644
--- a/gopls/internal/lsp/cmd/stats.go
+++ b/gopls/internal/lsp/cmd/stats.go
@@ -57,14 +57,6 @@ Example:
 }
 
 func (s *stats) Run(ctx context.Context, args ...string) error {
-	// This undocumented environment variable allows
-	// the cmd integration test to trigger a call to bug.Report.
-	if msg := os.Getenv("TEST_GOPLS_BUG"); msg != "" {
-		filecache.Start() // effect: register bug handler
-		goplsbug.Report(msg)
-		return nil
-	}
-
 	if s.app.Remote != "" {
 		// stats does not work with -remote.
 		// Other sessions on the daemon may interfere with results.
diff --git a/gopls/internal/lsp/cmd/test/integration_test.go b/gopls/internal/lsp/cmd/test/integration_test.go
index 52ecb239035..91c214c6751 100644
--- a/gopls/internal/lsp/cmd/test/integration_test.go
+++ b/gopls/internal/lsp/cmd/test/integration_test.go
@@ -702,7 +702,7 @@ package foo
 	oops := fmt.Sprintf("oops-%d", rand.Int())
 	{
 		env := []string{"TEST_GOPLS_BUG=" + oops}
-		res := goplsWithEnv(t, tree, env, "stats")
+		res := goplsWithEnv(t, tree, env, "bug")
 		res.checkExit(true)
 	}
 
@@ -745,8 +745,8 @@ package foo
 	{
 		got := fmt.Sprint(stats.BugReports)
 		wants := []string{
-			"cmd/stats.go", // File containing call to bug.Report
-			oops,           // Description
+			"cmd/info.go", // File containing call to bug.Report
+			oops,          // Description
 		}
 		for _, want := range wants {
 			if !strings.Contains(got, want) {
diff --git a/gopls/internal/lsp/filecache/filecache.go b/gopls/internal/lsp/filecache/filecache.go
index 47ee89e41b0..624f8722837 100644
--- a/gopls/internal/lsp/filecache/filecache.go
+++ b/gopls/internal/lsp/filecache/filecache.go
@@ -552,7 +552,7 @@ func init() {
 // used by this process (or "" on initialization error).
 func BugReports() (string, []bug.Bug) {
 	// To test this logic, run:
-	// $ TEST_GOPLS_BUG=oops gopls stats   # trigger a bug
+	// $ TEST_GOPLS_BUG=oops gopls bug     # trigger a bug
 	// $ gopls stats                       # list the bugs
 
 	dir, err := getCacheDir()

From a6594121c294b66bccc12ed8298411891f03fd36 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Sun, 27 Jan 2019 13:55:40 -0500
Subject: [PATCH 15/26] go/vcs: deprecate package in favor of go list -json

This package has diverged significantly from actual cmd/go import path
resolution behavior. The recommended course of action is for people to
start using the go command itself, where this logic is guaranteed to be
up to date. cmd/go also has support for modules, while this package does
not.

I've considered two alternatives to deprecating this package:

1. Not deprecate it, keep it as is. This is not a good option because
the package deviates from cmd/go import path resolution behavior and
doesn't have all security fixes backported to it. Keeping it in this
state without deprecating it can be misleading, since people may think
this package implements the stated goal of matching cmd/go behavior and
is well supported, which is not the current reality.

2. Not deprecate it, try to make it up to date with cmd/go import path
resolution logic. This is not a good option because VCSs are no longer
guaranteed to exist for packages located inside modules. To expose the
import path to module resolution logic, the API of this package would
need to be significantly modified. At this time, my understanding is
such work is not in scope and people are encouraged to use the existing
go command instead.

In 2019, when this CL was mailed, deprecating seemed as the best option.
In 2023, when this CL was merged, deprecating seemed as the best option.

Fixes golang/go#11490.
For golang/go#57051.

Change-Id: Id32d2bec5706c4e87126b825de5215fa5d1ba8ac
Reviewed-on: https://go-review.googlesource.com/c/tools/+/159818
gopls-CI: kokoro <noreply+kokoro@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Auto-Submit: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Bryan Mills <bcmills@google.com>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
---
 go/vcs/vcs.go | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/go/vcs/vcs.go b/go/vcs/vcs.go
index 54d850535d2..edbdf60827a 100644
--- a/go/vcs/vcs.go
+++ b/go/vcs/vcs.go
@@ -6,11 +6,17 @@
 // and using version control systems, which can be used to
 // implement behavior similar to the standard "go get" command.
 //
-// This package is a copy of internal code in package cmd/go/internal/get,
-// modified to make the identifiers exported. It's provided here
-// for developers who want to write tools with similar semantics.
-// It needs to be manually kept in sync with upstream when changes are
-// made to cmd/go/internal/get; see https://golang.org/issue/11490.
+// Deprecated: Use the go list command with -json flag instead,
+// which implements up-to-date import path resolution behavior,
+// module support, and includes the latest security fixes.
+//
+// This package was a copy of internal code in package cmd/go/internal/get
+// before module support, modified to make the identifiers exported.
+// It was provided here for developers who wanted to write tools with similar semantics.
+// It needed to be manually kept in sync with upstream when changes were
+// made to cmd/go/internal/get, as tracked in go.dev/issue/11490.
+// By now, it has diverged significantly from upstream cmd/go/internal/get
+// behavior and is not being actively updated.
 package vcs // import "golang.org/x/tools/go/vcs"
 
 import (

From d03a819dc0620bc996dc43fa7762619faf44d58e Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Sat, 24 Jun 2023 21:22:46 -0400
Subject: [PATCH 16/26] go/vcs: isolate into a nested module

The previous change marked the vcs package as deprecated.
This change isolates it into a nested module where it
will be tagged as v0.1.0-deprecated, its last version.
The next change deletes the nested module from the tools repo.

For golang/go#57051.

Change-Id: I0b7df60dbe87c1d97f150e5f8ca10e9d281a9364
Reviewed-on: https://go-review.googlesource.com/c/tools/+/505955
gopls-CI: kokoro <noreply+kokoro@google.com>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
Auto-Submit: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Bryan Mills <bcmills@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
---
 go/vcs/go.mod | 7 +++++++
 go/vcs/go.sum | 2 ++
 go/vcs/vcs.go | 2 +-
 3 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 go/vcs/go.mod
 create mode 100644 go/vcs/go.sum

diff --git a/go/vcs/go.mod b/go/vcs/go.mod
new file mode 100644
index 00000000000..74da6cb1e3f
--- /dev/null
+++ b/go/vcs/go.mod
@@ -0,0 +1,7 @@
+// Deprecated: This module contains one deprecated package.
+// See the package deprecation notice for more information.
+module golang.org/x/tools/go/vcs
+
+go 1.19
+
+require golang.org/x/sys v0.9.0
diff --git a/go/vcs/go.sum b/go/vcs/go.sum
new file mode 100644
index 00000000000..cb35c1fbf4d
--- /dev/null
+++ b/go/vcs/go.sum
@@ -0,0 +1,2 @@
+golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
+golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/go/vcs/vcs.go b/go/vcs/vcs.go
index edbdf60827a..232177dcf18 100644
--- a/go/vcs/vcs.go
+++ b/go/vcs/vcs.go
@@ -16,7 +16,7 @@
 // It needed to be manually kept in sync with upstream when changes were
 // made to cmd/go/internal/get, as tracked in go.dev/issue/11490.
 // By now, it has diverged significantly from upstream cmd/go/internal/get
-// behavior and is not being actively updated.
+// behavior and will not receive any further updates.
 package vcs // import "golang.org/x/tools/go/vcs"
 
 import (

From 5a89a3bf267ef12790327b8692c88654845bc78d Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <dmitshur@golang.org>
Date: Sat, 24 Jun 2023 20:50:29 -0400
Subject: [PATCH 17/26] go/vcs: delete

This will also close issues 10159, 12079, 19362, and 22556
as 'not planned'.

Fixes golang/go#57051.

Change-Id: I1cc6851a60c554d2266b5c03b8c010270919f5be
Reviewed-on: https://go-review.googlesource.com/c/tools/+/505956
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
gopls-CI: kokoro <noreply+kokoro@google.com>
Auto-Submit: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Bryan Mills <bcmills@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
---
 README.md           |   3 +-
 go/vcs/discovery.go |  83 -----
 go/vcs/env.go       |  39 ---
 go/vcs/go.mod       |   7 -
 go/vcs/go.sum       |   2 -
 go/vcs/http.go      |  80 -----
 go/vcs/vcs.go       | 764 --------------------------------------------
 go/vcs/vcs_test.go  | 309 ------------------
 8 files changed, 1 insertion(+), 1286 deletions(-)
 delete mode 100644 go/vcs/discovery.go
 delete mode 100644 go/vcs/env.go
 delete mode 100644 go/vcs/go.mod
 delete mode 100644 go/vcs/go.sum
 delete mode 100644 go/vcs/http.go
 delete mode 100644 go/vcs/vcs.go
 delete mode 100644 go/vcs/vcs_test.go

diff --git a/README.md b/README.md
index 0a2fcf18eb4..4dbf6d69aed 100644
--- a/README.md
+++ b/README.md
@@ -62,12 +62,11 @@ Selected packages:
 
 Numerous other packages provide more esoteric functionality.
 
-<!-- Some that didn't make the cut: 
+<!-- Some that didn't make the cut:
 
 golang.org/x/tools/benchmark/parse
 golang.org/x/tools/go/ast/astutil
 golang.org/x/tools/go/types/typeutil
-golang.org/x/tools/go/vcs
 golang.org/x/tools/playground
 golang.org/x/tools/present
 golang.org/x/tools/refactor/importgraph
diff --git a/go/vcs/discovery.go b/go/vcs/discovery.go
deleted file mode 100644
index 7d179bcc813..00000000000
--- a/go/vcs/discovery.go
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2012 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 vcs
-
-import (
-	"encoding/xml"
-	"fmt"
-	"io"
-	"strings"
-)
-
-// charsetReader returns a reader for the given charset. Currently
-// it only supports UTF-8 and ASCII. Otherwise, it returns a meaningful
-// error which is printed by go get, so the user can find why the package
-// wasn't downloaded if the encoding is not supported. Note that, in
-// order to reduce potential errors, ASCII is treated as UTF-8 (i.e. characters
-// greater than 0x7f are not rejected).
-func charsetReader(charset string, input io.Reader) (io.Reader, error) {
-	switch strings.ToLower(charset) {
-	case "ascii":
-		return input, nil
-	default:
-		return nil, fmt.Errorf("can't decode XML document using charset %q", charset)
-	}
-}
-
-// parseMetaGoImports returns meta imports from the HTML in r.
-// Parsing ends at the end of the <head> section or the beginning of the <body>.
-//
-// This copy of cmd/go/internal/vcs.parseMetaGoImports always operates
-// in IgnoreMod ModuleMode.
-func parseMetaGoImports(r io.Reader) (imports []metaImport, err error) {
-	d := xml.NewDecoder(r)
-	d.CharsetReader = charsetReader
-	d.Strict = false
-	var t xml.Token
-	for {
-		t, err = d.RawToken()
-		if err != nil {
-			if err == io.EOF || len(imports) > 0 {
-				err = nil
-			}
-			return
-		}
-		if e, ok := t.(xml.StartElement); ok && strings.EqualFold(e.Name.Local, "body") {
-			return
-		}
-		if e, ok := t.(xml.EndElement); ok && strings.EqualFold(e.Name.Local, "head") {
-			return
-		}
-		e, ok := t.(xml.StartElement)
-		if !ok || !strings.EqualFold(e.Name.Local, "meta") {
-			continue
-		}
-		if attrValue(e.Attr, "name") != "go-import" {
-			continue
-		}
-		if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 {
-			// Ignore VCS type "mod", which is applicable only in module mode.
-			if f[1] == "mod" {
-				continue
-			}
-			imports = append(imports, metaImport{
-				Prefix:   f[0],
-				VCS:      f[1],
-				RepoRoot: f[2],
-			})
-		}
-	}
-}
-
-// attrValue returns the attribute value for the case-insensitive key
-// `name', or the empty string if nothing is found.
-func attrValue(attrs []xml.Attr, name string) string {
-	for _, a := range attrs {
-		if strings.EqualFold(a.Name.Local, name) {
-			return a.Value
-		}
-	}
-	return ""
-}
diff --git a/go/vcs/env.go b/go/vcs/env.go
deleted file mode 100644
index 189210cdf81..00000000000
--- a/go/vcs/env.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package vcs
-
-import (
-	"os"
-	"strings"
-)
-
-// envForDir returns a copy of the environment
-// suitable for running in the given directory.
-// The environment is the current process's environment
-// but with an updated $PWD, so that an os.Getwd in the
-// child will be faster.
-func envForDir(dir string) []string {
-	env := os.Environ()
-	// Internally we only use rooted paths, so dir is rooted.
-	// Even if dir is not rooted, no harm done.
-	return mergeEnvLists([]string{"PWD=" + dir}, env)
-}
-
-// mergeEnvLists merges the two environment lists such that
-// variables with the same name in "in" replace those in "out".
-func mergeEnvLists(in, out []string) []string {
-NextVar:
-	for _, inkv := range in {
-		k := strings.SplitAfterN(inkv, "=", 2)[0]
-		for i, outkv := range out {
-			if strings.HasPrefix(outkv, k) {
-				out[i] = inkv
-				continue NextVar
-			}
-		}
-		out = append(out, inkv)
-	}
-	return out
-}
diff --git a/go/vcs/go.mod b/go/vcs/go.mod
deleted file mode 100644
index 74da6cb1e3f..00000000000
--- a/go/vcs/go.mod
+++ /dev/null
@@ -1,7 +0,0 @@
-// Deprecated: This module contains one deprecated package.
-// See the package deprecation notice for more information.
-module golang.org/x/tools/go/vcs
-
-go 1.19
-
-require golang.org/x/sys v0.9.0
diff --git a/go/vcs/go.sum b/go/vcs/go.sum
deleted file mode 100644
index cb35c1fbf4d..00000000000
--- a/go/vcs/go.sum
+++ /dev/null
@@ -1,2 +0,0 @@
-golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
-golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/go/vcs/http.go b/go/vcs/http.go
deleted file mode 100644
index 5836511d423..00000000000
--- a/go/vcs/http.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2012 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 vcs
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/url"
-)
-
-// httpClient is the default HTTP client, but a variable so it can be
-// changed by tests, without modifying http.DefaultClient.
-var httpClient = http.DefaultClient
-
-// httpGET returns the data from an HTTP GET request for the given URL.
-func httpGET(url string) ([]byte, error) {
-	resp, err := httpClient.Get(url)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("%s: %s", url, resp.Status)
-	}
-	b, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("%s: %v", url, err)
-	}
-	return b, nil
-}
-
-// httpsOrHTTP returns the body of either the importPath's
-// https resource or, if unavailable, the http resource.
-func httpsOrHTTP(importPath string) (urlStr string, body io.ReadCloser, err error) {
-	fetch := func(scheme string) (urlStr string, res *http.Response, err error) {
-		u, err := url.Parse(scheme + "://" + importPath)
-		if err != nil {
-			return "", nil, err
-		}
-		u.RawQuery = "go-get=1"
-		urlStr = u.String()
-		if Verbose {
-			log.Printf("Fetching %s", urlStr)
-		}
-		res, err = httpClient.Get(urlStr)
-		return
-	}
-	closeBody := func(res *http.Response) {
-		if res != nil {
-			res.Body.Close()
-		}
-	}
-	urlStr, res, err := fetch("https")
-	if err != nil || res.StatusCode != 200 {
-		if Verbose {
-			if err != nil {
-				log.Printf("https fetch failed.")
-			} else {
-				log.Printf("ignoring https fetch with status code %d", res.StatusCode)
-			}
-		}
-		closeBody(res)
-		urlStr, res, err = fetch("http")
-	}
-	if err != nil {
-		closeBody(res)
-		return "", nil, err
-	}
-	// Note: accepting a non-200 OK here, so people can serve a
-	// meta import in their http 404 page.
-	if Verbose {
-		log.Printf("Parsing meta tags from %s (status code %d)", urlStr, res.StatusCode)
-	}
-	return urlStr, res.Body, nil
-}
diff --git a/go/vcs/vcs.go b/go/vcs/vcs.go
deleted file mode 100644
index 232177dcf18..00000000000
--- a/go/vcs/vcs.go
+++ /dev/null
@@ -1,764 +0,0 @@
-// Copyright 2012 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 vcs exposes functions for resolving import paths
-// and using version control systems, which can be used to
-// implement behavior similar to the standard "go get" command.
-//
-// Deprecated: Use the go list command with -json flag instead,
-// which implements up-to-date import path resolution behavior,
-// module support, and includes the latest security fixes.
-//
-// This package was a copy of internal code in package cmd/go/internal/get
-// before module support, modified to make the identifiers exported.
-// It was provided here for developers who wanted to write tools with similar semantics.
-// It needed to be manually kept in sync with upstream when changes were
-// made to cmd/go/internal/get, as tracked in go.dev/issue/11490.
-// By now, it has diverged significantly from upstream cmd/go/internal/get
-// behavior and will not receive any further updates.
-package vcs // import "golang.org/x/tools/go/vcs"
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	exec "golang.org/x/sys/execabs"
-	"log"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// Verbose enables verbose operation logging.
-var Verbose bool
-
-// ShowCmd controls whether VCS commands are printed.
-var ShowCmd bool
-
-// A Cmd describes how to use a version control system
-// like Mercurial, Git, or Subversion.
-type Cmd struct {
-	Name string
-	Cmd  string // name of binary to invoke command
-
-	CreateCmd   string // command to download a fresh copy of a repository
-	DownloadCmd string // command to download updates into an existing repository
-
-	TagCmd         []TagCmd // commands to list tags
-	TagLookupCmd   []TagCmd // commands to lookup tags before running tagSyncCmd
-	TagSyncCmd     string   // command to sync to specific tag
-	TagSyncDefault string   // command to sync to default tag
-
-	LogCmd string // command to list repository changelogs in an XML format
-
-	Scheme  []string
-	PingCmd string
-}
-
-// A TagCmd describes a command to list available tags
-// that can be passed to Cmd.TagSyncCmd.
-type TagCmd struct {
-	Cmd     string // command to list tags
-	Pattern string // regexp to extract tags from list
-}
-
-// vcsList lists the known version control systems
-var vcsList = []*Cmd{
-	vcsHg,
-	vcsGit,
-	vcsSvn,
-	vcsBzr,
-}
-
-// ByCmd returns the version control system for the given
-// command name (hg, git, svn, bzr).
-func ByCmd(cmd string) *Cmd {
-	for _, vcs := range vcsList {
-		if vcs.Cmd == cmd {
-			return vcs
-		}
-	}
-	return nil
-}
-
-// vcsHg describes how to use Mercurial.
-var vcsHg = &Cmd{
-	Name: "Mercurial",
-	Cmd:  "hg",
-
-	CreateCmd:   "clone -U {repo} {dir}",
-	DownloadCmd: "pull",
-
-	// We allow both tag and branch names as 'tags'
-	// for selecting a version.  This lets people have
-	// a go.release.r60 branch and a go1 branch
-	// and make changes in both, without constantly
-	// editing .hgtags.
-	TagCmd: []TagCmd{
-		{"tags", `^(\S+)`},
-		{"branches", `^(\S+)`},
-	},
-	TagSyncCmd:     "update -r {tag}",
-	TagSyncDefault: "update default",
-
-	LogCmd: "log --encoding=utf-8 --limit={limit} --template={template}",
-
-	Scheme:  []string{"https", "http", "ssh"},
-	PingCmd: "identify {scheme}://{repo}",
-}
-
-// vcsGit describes how to use Git.
-var vcsGit = &Cmd{
-	Name: "Git",
-	Cmd:  "git",
-
-	CreateCmd:   "clone {repo} {dir}",
-	DownloadCmd: "pull --ff-only",
-
-	TagCmd: []TagCmd{
-		// tags/xxx matches a git tag named xxx
-		// origin/xxx matches a git branch named xxx on the default remote repository
-		{"show-ref", `(?:tags|origin)/(\S+)$`},
-	},
-	TagLookupCmd: []TagCmd{
-		{"show-ref tags/{tag} origin/{tag}", `((?:tags|origin)/\S+)$`},
-	},
-	TagSyncCmd:     "checkout {tag}",
-	TagSyncDefault: "checkout master",
-
-	Scheme:  []string{"git", "https", "http", "git+ssh"},
-	PingCmd: "ls-remote {scheme}://{repo}",
-}
-
-// vcsBzr describes how to use Bazaar.
-var vcsBzr = &Cmd{
-	Name: "Bazaar",
-	Cmd:  "bzr",
-
-	CreateCmd: "branch {repo} {dir}",
-
-	// Without --overwrite bzr will not pull tags that changed.
-	// Replace by --overwrite-tags after http://pad.lv/681792 goes in.
-	DownloadCmd: "pull --overwrite",
-
-	TagCmd:         []TagCmd{{"tags", `^(\S+)`}},
-	TagSyncCmd:     "update -r {tag}",
-	TagSyncDefault: "update -r revno:-1",
-
-	Scheme:  []string{"https", "http", "bzr", "bzr+ssh"},
-	PingCmd: "info {scheme}://{repo}",
-}
-
-// vcsSvn describes how to use Subversion.
-var vcsSvn = &Cmd{
-	Name: "Subversion",
-	Cmd:  "svn",
-
-	CreateCmd:   "checkout {repo} {dir}",
-	DownloadCmd: "update",
-
-	// There is no tag command in subversion.
-	// The branch information is all in the path names.
-
-	LogCmd: "log --xml --limit={limit}",
-
-	Scheme:  []string{"https", "http", "svn", "svn+ssh"},
-	PingCmd: "info {scheme}://{repo}",
-}
-
-func (v *Cmd) String() string {
-	return v.Name
-}
-
-// run runs the command line cmd in the given directory.
-// keyval is a list of key, value pairs.  run expands
-// instances of {key} in cmd into value, but only after
-// splitting cmd into individual arguments.
-// If an error occurs, run prints the command line and the
-// command's combined stdout+stderr to standard error.
-// Otherwise run discards the command's output.
-func (v *Cmd) run(dir string, cmd string, keyval ...string) error {
-	_, err := v.run1(dir, cmd, keyval, true)
-	return err
-}
-
-// runVerboseOnly is like run but only generates error output to standard error in verbose mode.
-func (v *Cmd) runVerboseOnly(dir string, cmd string, keyval ...string) error {
-	_, err := v.run1(dir, cmd, keyval, false)
-	return err
-}
-
-// runOutput is like run but returns the output of the command.
-func (v *Cmd) runOutput(dir string, cmd string, keyval ...string) ([]byte, error) {
-	return v.run1(dir, cmd, keyval, true)
-}
-
-// run1 is the generalized implementation of run and runOutput.
-func (v *Cmd) run1(dir string, cmdline string, keyval []string, verbose bool) ([]byte, error) {
-	m := make(map[string]string)
-	for i := 0; i < len(keyval); i += 2 {
-		m[keyval[i]] = keyval[i+1]
-	}
-	args := strings.Fields(cmdline)
-	for i, arg := range args {
-		args[i] = expand(m, arg)
-	}
-
-	_, err := exec.LookPath(v.Cmd)
-	if err != nil {
-		fmt.Fprintf(os.Stderr,
-			"go: missing %s command. See http://golang.org/s/gogetcmd\n",
-			v.Name)
-		return nil, err
-	}
-
-	cmd := exec.Command(v.Cmd, args...)
-	cmd.Dir = dir
-	cmd.Env = envForDir(cmd.Dir)
-	if ShowCmd {
-		fmt.Printf("cd %s\n", dir)
-		fmt.Printf("%s %s\n", v.Cmd, strings.Join(args, " "))
-	}
-	var buf bytes.Buffer
-	cmd.Stdout = &buf
-	cmd.Stderr = &buf
-	err = cmd.Run()
-	out := buf.Bytes()
-	if err != nil {
-		if verbose || Verbose {
-			fmt.Fprintf(os.Stderr, "# cd %s; %s %s\n", dir, v.Cmd, strings.Join(args, " "))
-			os.Stderr.Write(out)
-		}
-		return nil, err
-	}
-	return out, nil
-}
-
-// Ping pings the repo to determine if scheme used is valid.
-// This repo must be pingable with this scheme and VCS.
-func (v *Cmd) Ping(scheme, repo string) error {
-	return v.runVerboseOnly(".", v.PingCmd, "scheme", scheme, "repo", repo)
-}
-
-// Create creates a new copy of repo in dir.
-// The parent of dir must exist; dir must not.
-func (v *Cmd) Create(dir, repo string) error {
-	return v.run(".", v.CreateCmd, "dir", dir, "repo", repo)
-}
-
-// CreateAtRev creates a new copy of repo in dir at revision rev.
-// The parent of dir must exist; dir must not.
-// rev must be a valid revision in repo.
-func (v *Cmd) CreateAtRev(dir, repo, rev string) error {
-	if err := v.Create(dir, repo); err != nil {
-		return err
-	}
-	return v.run(dir, v.TagSyncCmd, "tag", rev)
-}
-
-// Download downloads any new changes for the repo in dir.
-// dir must be a valid VCS repo compatible with v.
-func (v *Cmd) Download(dir string) error {
-	return v.run(dir, v.DownloadCmd)
-}
-
-// Tags returns the list of available tags for the repo in dir.
-// dir must be a valid VCS repo compatible with v.
-func (v *Cmd) Tags(dir string) ([]string, error) {
-	var tags []string
-	for _, tc := range v.TagCmd {
-		out, err := v.runOutput(dir, tc.Cmd)
-		if err != nil {
-			return nil, err
-		}
-		re := regexp.MustCompile(`(?m-s)` + tc.Pattern)
-		for _, m := range re.FindAllStringSubmatch(string(out), -1) {
-			tags = append(tags, m[1])
-		}
-	}
-	return tags, nil
-}
-
-// TagSync syncs the repo in dir to the named tag, which is either a
-// tag returned by Tags or the empty string (the default tag).
-// dir must be a valid VCS repo compatible with v and the tag must exist.
-func (v *Cmd) TagSync(dir, tag string) error {
-	if v.TagSyncCmd == "" {
-		return nil
-	}
-	if tag != "" {
-		for _, tc := range v.TagLookupCmd {
-			out, err := v.runOutput(dir, tc.Cmd, "tag", tag)
-			if err != nil {
-				return err
-			}
-			re := regexp.MustCompile(`(?m-s)` + tc.Pattern)
-			m := re.FindStringSubmatch(string(out))
-			if len(m) > 1 {
-				tag = m[1]
-				break
-			}
-		}
-	}
-	if tag == "" && v.TagSyncDefault != "" {
-		return v.run(dir, v.TagSyncDefault)
-	}
-	return v.run(dir, v.TagSyncCmd, "tag", tag)
-}
-
-// Log logs the changes for the repo in dir.
-// dir must be a valid VCS repo compatible with v.
-func (v *Cmd) Log(dir, logTemplate string) ([]byte, error) {
-	if err := v.Download(dir); err != nil {
-		return []byte{}, err
-	}
-
-	const N = 50 // how many revisions to grab
-	return v.runOutput(dir, v.LogCmd, "limit", strconv.Itoa(N), "template", logTemplate)
-}
-
-// LogAtRev logs the change for repo in dir at the rev revision.
-// dir must be a valid VCS repo compatible with v.
-// rev must be a valid revision for the repo in dir.
-func (v *Cmd) LogAtRev(dir, rev, logTemplate string) ([]byte, error) {
-	if err := v.Download(dir); err != nil {
-		return []byte{}, err
-	}
-
-	// Append revision flag to LogCmd.
-	logAtRevCmd := v.LogCmd + " --rev=" + rev
-	return v.runOutput(dir, logAtRevCmd, "limit", strconv.Itoa(1), "template", logTemplate)
-}
-
-// A vcsPath describes how to convert an import path into a
-// version control system and repository name.
-type vcsPath struct {
-	prefix string                              // prefix this description applies to
-	re     string                              // pattern for import path
-	repo   string                              // repository to use (expand with match of re)
-	vcs    string                              // version control system to use (expand with match of re)
-	check  func(match map[string]string) error // additional checks
-	ping   bool                                // ping for scheme to use to download repo
-
-	regexp *regexp.Regexp // cached compiled form of re
-}
-
-// FromDir inspects dir and its parents to determine the
-// version control system and code repository to use.
-// On return, root is the import path
-// corresponding to the root of the repository.
-func FromDir(dir, srcRoot string) (vcs *Cmd, root string, err error) {
-	// Clean and double-check that dir is in (a subdirectory of) srcRoot.
-	dir = filepath.Clean(dir)
-	srcRoot = filepath.Clean(srcRoot)
-	if len(dir) <= len(srcRoot) || dir[len(srcRoot)] != filepath.Separator {
-		return nil, "", fmt.Errorf("directory %q is outside source root %q", dir, srcRoot)
-	}
-
-	var vcsRet *Cmd
-	var rootRet string
-
-	origDir := dir
-	for len(dir) > len(srcRoot) {
-		for _, vcs := range vcsList {
-			if _, err := os.Stat(filepath.Join(dir, "."+vcs.Cmd)); err == nil {
-				root := filepath.ToSlash(dir[len(srcRoot)+1:])
-				// Record first VCS we find, but keep looking,
-				// to detect mistakes like one kind of VCS inside another.
-				if vcsRet == nil {
-					vcsRet = vcs
-					rootRet = root
-					continue
-				}
-				// Allow .git inside .git, which can arise due to submodules.
-				if vcsRet == vcs && vcs.Cmd == "git" {
-					continue
-				}
-				// Otherwise, we have one VCS inside a different VCS.
-				return nil, "", fmt.Errorf("directory %q uses %s, but parent %q uses %s",
-					filepath.Join(srcRoot, rootRet), vcsRet.Cmd, filepath.Join(srcRoot, root), vcs.Cmd)
-			}
-		}
-
-		// Move to parent.
-		ndir := filepath.Dir(dir)
-		if len(ndir) >= len(dir) {
-			// Shouldn't happen, but just in case, stop.
-			break
-		}
-		dir = ndir
-	}
-
-	if vcsRet != nil {
-		return vcsRet, rootRet, nil
-	}
-
-	return nil, "", fmt.Errorf("directory %q is not using a known version control system", origDir)
-}
-
-// RepoRoot represents a version control system, a repo, and a root of
-// where to put it on disk.
-type RepoRoot struct {
-	VCS *Cmd
-
-	// Repo is the repository URL, including scheme.
-	Repo string
-
-	// Root is the import path corresponding to the root of the
-	// repository.
-	Root string
-}
-
-// RepoRootForImportPath analyzes importPath to determine the
-// version control system, and code repository to use.
-func RepoRootForImportPath(importPath string, verbose bool) (*RepoRoot, error) {
-	rr, err := RepoRootForImportPathStatic(importPath, "")
-	if err == errUnknownSite {
-		rr, err = RepoRootForImportDynamic(importPath, verbose)
-
-		// RepoRootForImportDynamic returns error detail
-		// that is irrelevant if the user didn't intend to use a
-		// dynamic import in the first place.
-		// Squelch it.
-		if err != nil {
-			if Verbose {
-				log.Printf("import %q: %v", importPath, err)
-			}
-			err = fmt.Errorf("unrecognized import path %q", importPath)
-		}
-	}
-
-	if err == nil && strings.Contains(importPath, "...") && strings.Contains(rr.Root, "...") {
-		// Do not allow wildcards in the repo root.
-		rr = nil
-		err = fmt.Errorf("cannot expand ... in %q", importPath)
-	}
-	return rr, err
-}
-
-var errUnknownSite = errors.New("dynamic lookup required to find mapping")
-
-// RepoRootForImportPathStatic attempts to map importPath to a
-// RepoRoot using the commonly-used VCS hosting sites in vcsPaths
-// (github.com/user/dir), or from a fully-qualified importPath already
-// containing its VCS type (foo.com/repo.git/dir)
-//
-// If scheme is non-empty, that scheme is forced.
-func RepoRootForImportPathStatic(importPath, scheme string) (*RepoRoot, error) {
-	if strings.Contains(importPath, "://") {
-		return nil, fmt.Errorf("invalid import path %q", importPath)
-	}
-	for _, srv := range vcsPaths {
-		if !strings.HasPrefix(importPath, srv.prefix) {
-			continue
-		}
-		m := srv.regexp.FindStringSubmatch(importPath)
-		if m == nil {
-			if srv.prefix != "" {
-				return nil, fmt.Errorf("invalid %s import path %q", srv.prefix, importPath)
-			}
-			continue
-		}
-
-		// Build map of named subexpression matches for expand.
-		match := map[string]string{
-			"prefix": srv.prefix,
-			"import": importPath,
-		}
-		for i, name := range srv.regexp.SubexpNames() {
-			if name != "" && match[name] == "" {
-				match[name] = m[i]
-			}
-		}
-		if srv.vcs != "" {
-			match["vcs"] = expand(match, srv.vcs)
-		}
-		if srv.repo != "" {
-			match["repo"] = expand(match, srv.repo)
-		}
-		if srv.check != nil {
-			if err := srv.check(match); err != nil {
-				return nil, err
-			}
-		}
-		vcs := ByCmd(match["vcs"])
-		if vcs == nil {
-			return nil, fmt.Errorf("unknown version control system %q", match["vcs"])
-		}
-		if srv.ping {
-			if scheme != "" {
-				match["repo"] = scheme + "://" + match["repo"]
-			} else {
-				for _, scheme := range vcs.Scheme {
-					if vcs.Ping(scheme, match["repo"]) == nil {
-						match["repo"] = scheme + "://" + match["repo"]
-						break
-					}
-				}
-			}
-		}
-		rr := &RepoRoot{
-			VCS:  vcs,
-			Repo: match["repo"],
-			Root: match["root"],
-		}
-		return rr, nil
-	}
-	return nil, errUnknownSite
-}
-
-// RepoRootForImportDynamic finds a *RepoRoot for a custom domain that's not
-// statically known by RepoRootForImportPathStatic.
-//
-// This handles custom import paths like "name.tld/pkg/foo" or just "name.tld".
-func RepoRootForImportDynamic(importPath string, verbose bool) (*RepoRoot, error) {
-	slash := strings.Index(importPath, "/")
-	if slash < 0 {
-		slash = len(importPath)
-	}
-	host := importPath[:slash]
-	if !strings.Contains(host, ".") {
-		return nil, errors.New("import path doesn't contain a hostname")
-	}
-	urlStr, body, err := httpsOrHTTP(importPath)
-	if err != nil {
-		return nil, fmt.Errorf("http/https fetch: %v", err)
-	}
-	defer body.Close()
-	imports, err := parseMetaGoImports(body)
-	if err != nil {
-		return nil, fmt.Errorf("parsing %s: %v", importPath, err)
-	}
-	metaImport, err := matchGoImport(imports, importPath)
-	if err != nil {
-		if err != errNoMatch {
-			return nil, fmt.Errorf("parse %s: %v", urlStr, err)
-		}
-		return nil, fmt.Errorf("parse %s: no go-import meta tags", urlStr)
-	}
-	if verbose {
-		log.Printf("get %q: found meta tag %#v at %s", importPath, metaImport, urlStr)
-	}
-	// If the import was "uni.edu/bob/project", which said the
-	// prefix was "uni.edu" and the RepoRoot was "evilroot.com",
-	// make sure we don't trust Bob and check out evilroot.com to
-	// "uni.edu" yet (possibly overwriting/preempting another
-	// non-evil student).  Instead, first verify the root and see
-	// if it matches Bob's claim.
-	if metaImport.Prefix != importPath {
-		if verbose {
-			log.Printf("get %q: verifying non-authoritative meta tag", importPath)
-		}
-		urlStr0 := urlStr
-		urlStr, body, err = httpsOrHTTP(metaImport.Prefix)
-		if err != nil {
-			return nil, fmt.Errorf("fetch %s: %v", urlStr, err)
-		}
-		imports, err := parseMetaGoImports(body)
-		if err != nil {
-			return nil, fmt.Errorf("parsing %s: %v", importPath, err)
-		}
-		if len(imports) == 0 {
-			return nil, fmt.Errorf("fetch %s: no go-import meta tag", urlStr)
-		}
-		metaImport2, err := matchGoImport(imports, importPath)
-		if err != nil || metaImport != metaImport2 {
-			return nil, fmt.Errorf("%s and %s disagree about go-import for %s", urlStr0, urlStr, metaImport.Prefix)
-		}
-	}
-
-	if err := validateRepoRoot(metaImport.RepoRoot); err != nil {
-		return nil, fmt.Errorf("%s: invalid repo root %q: %v", urlStr, metaImport.RepoRoot, err)
-	}
-	rr := &RepoRoot{
-		VCS:  ByCmd(metaImport.VCS),
-		Repo: metaImport.RepoRoot,
-		Root: metaImport.Prefix,
-	}
-	if rr.VCS == nil {
-		return nil, fmt.Errorf("%s: unknown vcs %q", urlStr, metaImport.VCS)
-	}
-	return rr, nil
-}
-
-// validateRepoRoot returns an error if repoRoot does not seem to be
-// a valid URL with scheme.
-func validateRepoRoot(repoRoot string) error {
-	url, err := url.Parse(repoRoot)
-	if err != nil {
-		return err
-	}
-	if url.Scheme == "" {
-		return errors.New("no scheme")
-	}
-	return nil
-}
-
-// metaImport represents the parsed <meta name="go-import"
-// content="prefix vcs reporoot" /> tags from HTML files.
-type metaImport struct {
-	Prefix, VCS, RepoRoot string
-}
-
-// errNoMatch is returned from matchGoImport when there's no applicable match.
-var errNoMatch = errors.New("no import match")
-
-// pathPrefix reports whether sub is a prefix of s,
-// only considering entire path components.
-func pathPrefix(s, sub string) bool {
-	// strings.HasPrefix is necessary but not sufficient.
-	if !strings.HasPrefix(s, sub) {
-		return false
-	}
-	// The remainder after the prefix must either be empty or start with a slash.
-	rem := s[len(sub):]
-	return rem == "" || rem[0] == '/'
-}
-
-// matchGoImport returns the metaImport from imports matching importPath.
-// An error is returned if there are multiple matches.
-// errNoMatch is returned if none match.
-func matchGoImport(imports []metaImport, importPath string) (_ metaImport, err error) {
-	match := -1
-	for i, im := range imports {
-		if !pathPrefix(importPath, im.Prefix) {
-			continue
-		}
-
-		if match != -1 {
-			err = fmt.Errorf("multiple meta tags match import path %q", importPath)
-			return
-		}
-		match = i
-	}
-	if match == -1 {
-		err = errNoMatch
-		return
-	}
-	return imports[match], nil
-}
-
-// expand rewrites s to replace {k} with match[k] for each key k in match.
-func expand(match map[string]string, s string) string {
-	for k, v := range match {
-		s = strings.Replace(s, "{"+k+"}", v, -1)
-	}
-	return s
-}
-
-// vcsPaths lists the known vcs paths.
-var vcsPaths = []*vcsPath{
-	// Github
-	{
-		prefix: "github.com/",
-		re:     `^(?P<root>github\.com/[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+)(/[\p{L}0-9_.\-]+)*$`,
-		vcs:    "git",
-		repo:   "https://{root}",
-		check:  noVCSSuffix,
-	},
-
-	// Bitbucket
-	{
-		prefix: "bitbucket.org/",
-		re:     `^(?P<root>bitbucket\.org/(?P<bitname>[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`,
-		repo:   "https://{root}",
-		check:  bitbucketVCS,
-	},
-
-	// Launchpad
-	{
-		prefix: "launchpad.net/",
-		re:     `^(?P<root>launchpad\.net/((?P<project>[A-Za-z0-9_.\-]+)(?P<series>/[A-Za-z0-9_.\-]+)?|~[A-Za-z0-9_.\-]+/(\+junk|[A-Za-z0-9_.\-]+)/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`,
-		vcs:    "bzr",
-		repo:   "https://{root}",
-		check:  launchpadVCS,
-	},
-
-	// Git at OpenStack
-	{
-		prefix: "git.openstack.org",
-		re:     `^(?P<root>git\.openstack\.org/[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+)(\.git)?(/[A-Za-z0-9_.\-]+)*$`,
-		vcs:    "git",
-		repo:   "https://{root}",
-		check:  noVCSSuffix,
-	},
-
-	// General syntax for any server.
-	{
-		re:   `^(?P<root>(?P<repo>([a-z0-9.\-]+\.)+[a-z0-9.\-]+(:[0-9]+)?/[A-Za-z0-9_.\-/]*?)\.(?P<vcs>bzr|git|hg|svn))(/[A-Za-z0-9_.\-]+)*$`,
-		ping: true,
-	},
-}
-
-func init() {
-	// fill in cached regexps.
-	// Doing this eagerly discovers invalid regexp syntax
-	// without having to run a command that needs that regexp.
-	for _, srv := range vcsPaths {
-		srv.regexp = regexp.MustCompile(srv.re)
-	}
-}
-
-// noVCSSuffix checks that the repository name does not
-// end in .foo for any version control system foo.
-// The usual culprit is ".git".
-func noVCSSuffix(match map[string]string) error {
-	repo := match["repo"]
-	for _, vcs := range vcsList {
-		if strings.HasSuffix(repo, "."+vcs.Cmd) {
-			return fmt.Errorf("invalid version control suffix in %s path", match["prefix"])
-		}
-	}
-	return nil
-}
-
-// bitbucketVCS determines the version control system for a
-// Bitbucket repository, by using the Bitbucket API.
-func bitbucketVCS(match map[string]string) error {
-	if err := noVCSSuffix(match); err != nil {
-		return err
-	}
-
-	var resp struct {
-		SCM string `json:"scm"`
-	}
-	url := expand(match, "https://api.bitbucket.org/2.0/repositories/{bitname}?fields=scm")
-	data, err := httpGET(url)
-	if err != nil {
-		return err
-	}
-	if err := json.Unmarshal(data, &resp); err != nil {
-		return fmt.Errorf("decoding %s: %v", url, err)
-	}
-
-	if ByCmd(resp.SCM) != nil {
-		match["vcs"] = resp.SCM
-		if resp.SCM == "git" {
-			match["repo"] += ".git"
-		}
-		return nil
-	}
-
-	return fmt.Errorf("unable to detect version control system for bitbucket.org/ path")
-}
-
-// launchpadVCS solves the ambiguity for "lp.net/project/foo". In this case,
-// "foo" could be a series name registered in Launchpad with its own branch,
-// and it could also be the name of a directory within the main project
-// branch one level up.
-func launchpadVCS(match map[string]string) error {
-	if match["project"] == "" || match["series"] == "" {
-		return nil
-	}
-	_, err := httpGET(expand(match, "https://code.launchpad.net/{project}{series}/.bzr/branch-format"))
-	if err != nil {
-		match["root"] = expand(match, "launchpad.net/{project}")
-		match["repo"] = expand(match, "https://{root}")
-	}
-	return nil
-}
diff --git a/go/vcs/vcs_test.go b/go/vcs/vcs_test.go
deleted file mode 100644
index a17b50d9d1d..00000000000
--- a/go/vcs/vcs_test.go
+++ /dev/null
@@ -1,309 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package vcs
-
-import (
-	"errors"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-// Test that RepoRootForImportPath creates the correct RepoRoot for a given importPath.
-// TODO(cmang): Add tests for SVN and BZR.
-func TestRepoRootForImportPath(t *testing.T) {
-	if runtime.GOOS == "android" {
-		t.Skipf("incomplete source tree on %s", runtime.GOOS)
-	}
-
-	tests := []struct {
-		path string
-		want *RepoRoot
-	}{
-		{
-			"github.com/golang/groupcache",
-			&RepoRoot{
-				VCS:  vcsGit,
-				Repo: "https://github.com/golang/groupcache",
-			},
-		},
-		// Unicode letters in directories (issue 18660).
-		{
-			"github.com/user/unicode/испытание",
-			&RepoRoot{
-				VCS:  vcsGit,
-				Repo: "https://github.com/user/unicode",
-			},
-		},
-	}
-
-	for _, test := range tests {
-		got, err := RepoRootForImportPath(test.path, false)
-		if err != nil {
-			t.Errorf("RepoRootForImportPath(%q): %v", test.path, err)
-			continue
-		}
-		want := test.want
-		if got.VCS.Name != want.VCS.Name || got.Repo != want.Repo {
-			t.Errorf("RepoRootForImportPath(%q) = VCS(%s) Repo(%s), want VCS(%s) Repo(%s)", test.path, got.VCS, got.Repo, want.VCS, want.Repo)
-		}
-	}
-}
-
-// Test that FromDir correctly inspects a given directory and returns the right VCS and root.
-func TestFromDir(t *testing.T) {
-	tempDir, err := ioutil.TempDir("", "vcstest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	for j, vcs := range vcsList {
-		dir := filepath.Join(tempDir, "example.com", vcs.Name, "."+vcs.Cmd)
-		if j&1 == 0 {
-			err := os.MkdirAll(dir, 0755)
-			if err != nil {
-				t.Fatal(err)
-			}
-		} else {
-			err := os.MkdirAll(filepath.Dir(dir), 0755)
-			if err != nil {
-				t.Fatal(err)
-			}
-			f, err := os.Create(dir)
-			if err != nil {
-				t.Fatal(err)
-			}
-			f.Close()
-		}
-
-		want := RepoRoot{
-			VCS:  vcs,
-			Root: path.Join("example.com", vcs.Name),
-		}
-		var got RepoRoot
-		got.VCS, got.Root, err = FromDir(dir, tempDir)
-		if err != nil {
-			t.Errorf("FromDir(%q, %q): %v", dir, tempDir, err)
-			continue
-		}
-		if got.VCS.Name != want.VCS.Name || got.Root != want.Root {
-			t.Errorf("FromDir(%q, %q) = VCS(%s) Root(%s), want VCS(%s) Root(%s)", dir, tempDir, got.VCS, got.Root, want.VCS, want.Root)
-		}
-	}
-}
-
-var parseMetaGoImportsTests = []struct {
-	in  string
-	out []metaImport
-}{
-	{
-		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
-	},
-	{
-		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
-		<meta name="go-import" content="baz/quux git http://github.com/rsc/baz/quux">`,
-		[]metaImport{
-			{"foo/bar", "git", "https://github.com/rsc/foo/bar"},
-			{"baz/quux", "git", "http://github.com/rsc/baz/quux"},
-		},
-	},
-	{
-		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
-		<meta name="go-import" content="foo/bar mod http://github.com/rsc/baz/quux">`,
-		[]metaImport{
-			{"foo/bar", "git", "https://github.com/rsc/foo/bar"},
-		},
-	},
-	{
-		`<meta name="go-import" content="foo/bar mod http://github.com/rsc/baz/quux">
-		<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
-		[]metaImport{
-			{"foo/bar", "git", "https://github.com/rsc/foo/bar"},
-		},
-	},
-	{
-		`<head>
-		<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
-		</head>`,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
-	},
-	{
-		`<meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">
-		<body>`,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
-	},
-	{
-		`<!doctype html><meta name="go-import" content="foo/bar git https://github.com/rsc/foo/bar">`,
-		[]metaImport{{"foo/bar", "git", "https://github.com/rsc/foo/bar"}},
-	},
-	{
-		// XML doesn't like <div style=position:relative>.
-		`<!doctype html><title>Page Not Found</title><meta name=go-import content="chitin.io/chitin git https://github.com/chitin-io/chitin"><div style=position:relative>DRAFT</div>`,
-		[]metaImport{{"chitin.io/chitin", "git", "https://github.com/chitin-io/chitin"}},
-	},
-	{
-		`<meta name="go-import" content="myitcv.io git https://github.com/myitcv/x">
-	        <meta name="go-import" content="myitcv.io/blah2 mod https://raw.githubusercontent.com/myitcv/pubx/master">
-	        `,
-		[]metaImport{{"myitcv.io", "git", "https://github.com/myitcv/x"}},
-	},
-}
-
-func TestParseMetaGoImports(t *testing.T) {
-	for i, tt := range parseMetaGoImportsTests {
-		out, err := parseMetaGoImports(strings.NewReader(tt.in))
-		if err != nil {
-			t.Errorf("test#%d: %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(out, tt.out) {
-			t.Errorf("test#%d:\n\thave %q\n\twant %q", i, out, tt.out)
-		}
-	}
-}
-
-func TestValidateRepoRoot(t *testing.T) {
-	tests := []struct {
-		root string
-		ok   bool
-	}{
-		{
-			root: "",
-			ok:   false,
-		},
-		{
-			root: "http://",
-			ok:   true,
-		},
-		{
-			root: "git+ssh://",
-			ok:   true,
-		},
-		{
-			root: "http#://",
-			ok:   false,
-		},
-		{
-			root: "-config",
-			ok:   false,
-		},
-		{
-			root: "-config://",
-			ok:   false,
-		},
-	}
-
-	for _, test := range tests {
-		err := validateRepoRoot(test.root)
-		ok := err == nil
-		if ok != test.ok {
-			want := "error"
-			if test.ok {
-				want = "nil"
-			}
-			t.Errorf("validateRepoRoot(%q) = %q, want %s", test.root, err, want)
-		}
-	}
-}
-
-func TestMatchGoImport(t *testing.T) {
-	tests := []struct {
-		imports []metaImport
-		path    string
-		mi      metaImport
-		err     error
-	}{
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/foo",
-			mi:   metaImport{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/foo/",
-			mi:   metaImport{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-				{Prefix: "example.com/user/fooa", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/foo",
-			mi:   metaImport{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-				{Prefix: "example.com/user/fooa", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/fooa",
-			mi:   metaImport{Prefix: "example.com/user/fooa", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-				{Prefix: "example.com/user/foo/bar", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/foo/bar",
-			err:  errors.New("should not be allowed to create nested repo"),
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-				{Prefix: "example.com/user/foo/bar", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/foo/bar/baz",
-			err:  errors.New("should not be allowed to create nested repo"),
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-				{Prefix: "example.com/user/foo/bar", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/foo/bar/baz/qux",
-			err:  errors.New("should not be allowed to create nested repo"),
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-				{Prefix: "example.com/user/foo/bar", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com/user/foo/bar/baz/",
-			err:  errors.New("should not be allowed to create nested repo"),
-		},
-		{
-			imports: []metaImport{
-				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-				{Prefix: "example.com/user/foo/bar", VCS: "git", RepoRoot: "https://example.com/repo/target"},
-			},
-			path: "example.com",
-			err:  errors.New("pathologically short path"),
-		},
-	}
-
-	for _, test := range tests {
-		mi, err := matchGoImport(test.imports, test.path)
-		if mi != test.mi {
-			t.Errorf("unexpected metaImport; got %v, want %v", mi, test.mi)
-		}
-
-		got := err
-		want := test.err
-		if (got == nil) != (want == nil) {
-			t.Errorf("unexpected error; got %v, want %v", got, want)
-		}
-	}
-}

From 5aa6acb96f843a0257c5c1c0e52753bcd18b77b3 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Date: Wed, 7 Jun 2023 18:20:44 +0700
Subject: [PATCH 18/26] go/analysis: add Sizes that matches gc size
 computations

For golang/go#60431
For golang/go#60734

Change-Id: I6a15a24e3e121635b33d77fde9170a41514c0db1
Reviewed-on: https://go-review.googlesource.com/c/tools/+/501495
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Damien Neil <dneil@google.com>
Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Robert Griesemer <gri@google.com>
Auto-Submit: Robert Griesemer <gri@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
---
 go/analysis/unitchecker/sizes.go       | 237 +++++++++++++++++++++++++
 go/analysis/unitchecker/sizes_test.go  |  85 +++++++++
 go/analysis/unitchecker/unitchecker.go |   2 +-
 3 files changed, 323 insertions(+), 1 deletion(-)
 create mode 100644 go/analysis/unitchecker/sizes.go
 create mode 100644 go/analysis/unitchecker/sizes_test.go

diff --git a/go/analysis/unitchecker/sizes.go b/go/analysis/unitchecker/sizes.go
new file mode 100644
index 00000000000..332e2e49a9b
--- /dev/null
+++ b/go/analysis/unitchecker/sizes.go
@@ -0,0 +1,237 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package unitchecker
+
+import (
+	"fmt"
+	"go/types"
+)
+
+type gcSizes struct {
+	WordSize int64 // word size in bytes - must be >= 4 (32bits)
+	MaxAlign int64 // maximum alignment in bytes - must be >= 1
+}
+
+func (s *gcSizes) Alignof(T types.Type) int64 {
+	// For arrays and structs, alignment is defined in terms
+	// of alignment of the elements and fields, respectively.
+	switch t := T.Underlying().(type) {
+	case *types.Array:
+		// spec: "For a variable x of array type: unsafe.Alignof(x)
+		// is the same as unsafe.Alignof(x[0]), but at least 1."
+		return s.Alignof(t.Elem())
+	case *types.Struct:
+		if t.NumFields() == 0 && isSyncAtomicAlign64(T) {
+			// Special case: sync/atomic.align64 is an
+			// empty struct we recognize as a signal that
+			// the struct it contains must be
+			// 64-bit-aligned.
+			//
+			// This logic is equivalent to the logic in
+			// cmd/compile/internal/types/size.go:calcStructOffset
+			return 8
+		}
+
+		// spec: "For a variable x of struct type: unsafe.Alignof(x)
+		// is the largest of the values unsafe.Alignof(x.f) for each
+		// field f of x, but at least 1."
+		max := int64(1)
+		for i, nf := 0, t.NumFields(); i < nf; i++ {
+			if a := s.Alignof(t.Field(i).Type()); a > max {
+				max = a
+			}
+		}
+		return max
+	case *types.Slice, *types.Interface:
+		// Multiword data structures are effectively structs
+		// in which each element has size PtrSize.
+		return s.WordSize
+	case *types.Basic:
+		// Strings are like slices and interfaces.
+		if t.Info()&types.IsString != 0 {
+			return s.WordSize
+		}
+	}
+	a := s.Sizeof(T) // may be 0
+	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
+	if a < 1 {
+		return 1
+	}
+	// complex{64,128} are aligned like [2]float{32,64}.
+	if isComplex(T) {
+		a /= 2
+	}
+	if a > s.MaxAlign {
+		return s.MaxAlign
+	}
+	return a
+}
+
+func isComplex(T types.Type) bool {
+	basic, ok := T.Underlying().(*types.Basic)
+	return ok && basic.Info()&types.IsComplex != 0
+}
+
+func (s *gcSizes) Offsetsof(fields []*types.Var) []int64 {
+	offsets := make([]int64, len(fields))
+	var offs int64
+	for i, f := range fields {
+		if offs < 0 {
+			// all remaining offsets are too large
+			offsets[i] = -1
+			continue
+		}
+		// offs >= 0
+		typ := f.Type()
+		a := s.Alignof(typ)
+		offs = roundUp(offs, a) // possibly < 0 if align overflows
+		offsets[i] = offs
+		if d := s.Sizeof(typ); d >= 0 && offs >= 0 {
+			offs += d // ok to overflow to < 0
+		} else {
+			offs = -1
+		}
+	}
+	return offsets
+}
+
+func (s *gcSizes) Sizeof(T types.Type) int64 {
+	switch t := T.Underlying().(type) {
+	case *types.Basic:
+		k := t.Kind()
+		if int(k) < len(basicSizes) {
+			if s := basicSizes[k]; s > 0 {
+				return int64(s)
+			}
+		}
+		switch k {
+		case types.String:
+			return s.WordSize * 2
+		case types.Int, types.Uint, types.Uintptr, types.UnsafePointer:
+			return s.WordSize
+		}
+		panic(fmt.Sprintf("unimplemented basic: %v (kind %v)", T, k))
+	case *types.Array:
+		n := t.Len()
+		if n <= 0 {
+			return 0
+		}
+		// n > 0
+		// gc: Size includes alignment padding.
+		esize := s.Sizeof(t.Elem())
+		if esize < 0 {
+			return -1 // array element too large
+		}
+		if esize == 0 {
+			return 0 // 0-size element
+		}
+		// esize > 0
+		// Final size is esize * n; and size must be <= maxInt64.
+		const maxInt64 = 1<<63 - 1
+		if esize > maxInt64/n {
+			return -1 // esize * n overflows
+		}
+		return esize * n
+	case *types.Slice:
+		return s.WordSize * 3
+	case *types.Struct:
+		n := t.NumFields()
+		if n == 0 {
+			return 0
+		}
+		// n > 0
+		fields := make([]*types.Var, n)
+		for i := range fields {
+			fields[i] = t.Field(i)
+		}
+		offsets := s.Offsetsof(fields)
+		// gc: The last field of a non-zero-sized struct is not allowed to
+		// have size 0.
+		last := s.Sizeof(fields[n-1].Type())
+		if last == 0 && offsets[n-1] > 0 {
+			last = 1
+		}
+		// gc: Size includes alignment padding.
+		return roundUp(offsets[n-1]+last, s.Alignof(t)) // may overflow to < 0 which is ok
+	case *types.Interface:
+		return s.WordSize * 2
+	case *types.Chan, *types.Map, *types.Pointer, *types.Signature:
+		return s.WordSize
+	default:
+		panic(fmt.Sprintf("Sizeof(%T) unimplemented", t))
+	}
+}
+
+func isSyncAtomicAlign64(T types.Type) bool {
+	named, ok := T.(*types.Named)
+	if !ok {
+		return false
+	}
+	obj := named.Obj()
+	return obj.Name() == "align64" &&
+		obj.Pkg() != nil &&
+		(obj.Pkg().Path() == "sync/atomic" ||
+			obj.Pkg().Path() == "runtime/internal/atomic")
+}
+
+// roundUp rounds o to a multiple of r, r is a power of 2.
+func roundUp(o int64, r int64) int64 {
+	if r < 1 || r > 8 || r&(r-1) != 0 {
+		panic(fmt.Sprintf("Round %d", r))
+	}
+	return (o + r - 1) &^ (r - 1)
+}
+
+var basicSizes = [...]byte{
+	types.Invalid:    1,
+	types.Bool:       1,
+	types.Int8:       1,
+	types.Int16:      2,
+	types.Int32:      4,
+	types.Int64:      8,
+	types.Uint8:      1,
+	types.Uint16:     2,
+	types.Uint32:     4,
+	types.Uint64:     8,
+	types.Float32:    4,
+	types.Float64:    8,
+	types.Complex64:  8,
+	types.Complex128: 16,
+}
+
+// common architecture word sizes and alignments
+var gcArchSizes = map[string]*gcSizes{
+	"386":      {4, 4},
+	"amd64":    {8, 8},
+	"amd64p32": {4, 8},
+	"arm":      {4, 4},
+	"arm64":    {8, 8},
+	"loong64":  {8, 8},
+	"mips":     {4, 4},
+	"mipsle":   {4, 4},
+	"mips64":   {8, 8},
+	"mips64le": {8, 8},
+	"ppc64":    {8, 8},
+	"ppc64le":  {8, 8},
+	"riscv64":  {8, 8},
+	"s390x":    {8, 8},
+	"sparc64":  {8, 8},
+	"wasm":     {8, 8},
+	// When adding more architectures here,
+	// update the doc string of sizesFor below.
+}
+
+// sizesFor returns the go/types.Sizes used by a compiler for an architecture.
+// The result is nil if a compiler/architecture pair is not known.
+func sizesFor(compiler, arch string) types.Sizes {
+	if compiler != "gc" {
+		return nil
+	}
+	s, ok := gcArchSizes[arch]
+	if !ok {
+		return nil
+	}
+	return s
+}
diff --git a/go/analysis/unitchecker/sizes_test.go b/go/analysis/unitchecker/sizes_test.go
new file mode 100644
index 00000000000..5d98a23338c
--- /dev/null
+++ b/go/analysis/unitchecker/sizes_test.go
@@ -0,0 +1,85 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package unitchecker
+
+import (
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"testing"
+)
+
+type gcSizeTest struct {
+	name string
+	src  string
+}
+
+var gcSizesTests = []gcSizeTest{
+	{
+		"issue60431",
+		`package main
+	
+	import "unsafe"
+	
+	// The foo struct size is expected to be rounded up to 16 bytes.
+	type foo struct {
+		a int64
+		b bool
+	}
+	
+	func main() {
+		var _ [unsafe.Sizeof(foo{}) - 16]byte
+	       println(unsafe.Sizeof(foo{}))
+	}`,
+	},
+	{
+		"issue60734",
+		`package main
+	
+	import (
+		"unsafe"
+	)
+	
+	// The Data struct size is expected to be rounded up to 16 bytes.
+	type Data struct {
+		Value  uint32   // 4 bytes
+		Label  [10]byte // 10 bytes
+		Active bool     // 1 byte
+		// padded with 1 byte to make it align
+	}
+	
+	const (
+		dataSize = unsafe.Sizeof(Data{})
+		dataSizeLiteral = 16
+	)
+	
+	func main() {
+		_ = [16]byte{0, 132, 95, 237, 80, 104, 111, 110, 101, 0, 0, 0, 0, 0, 1, 0}
+		_ = [dataSize]byte{0, 132, 95, 237, 80, 104, 111, 110, 101, 0, 0, 0, 0, 0, 1, 0}
+	       _ = [dataSizeLiteral]byte{0, 132, 95, 237, 80, 104, 111, 110, 101, 0, 0, 0, 0, 0, 1, 0}
+	}`,
+	},
+}
+
+func TestGCSizes(t *testing.T) {
+	for _, tc := range gcSizesTests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			fset := token.NewFileSet()
+			f, err := parser.ParseFile(fset, "x.go", tc.src, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			conf := types.Config{Importer: importer.Default(), Sizes: sizesFor("gc", "amd64")}
+			if _, err := conf.Check("main.go", fset, []*ast.File{f}, nil); err != nil {
+				t.Fatal(err) // type error
+			}
+		})
+	}
+}
diff --git a/go/analysis/unitchecker/unitchecker.go b/go/analysis/unitchecker/unitchecker.go
index ff22d23ce5c..8334cf06301 100644
--- a/go/analysis/unitchecker/unitchecker.go
+++ b/go/analysis/unitchecker/unitchecker.go
@@ -218,7 +218,7 @@ func run(fset *token.FileSet, cfg *Config, analyzers []*analysis.Analyzer) ([]re
 	})
 	tc := &types.Config{
 		Importer: importer,
-		Sizes:    types.SizesFor("gc", build.Default.GOARCH), // assume gccgo ≡ gc?
+		Sizes:    sizesFor("gc", build.Default.GOARCH), // assume gccgo ≡ gc?
 	}
 	info := &types.Info{
 		Types:      make(map[ast.Expr]types.TypeAndValue),

From 969078be460fb5efe195a1d4c69e3701298e9a21 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@google.com>
Date: Tue, 27 Jun 2023 17:21:13 +0000
Subject: [PATCH 19/26] Revert "go/analysis: add Sizes that matches gc size
 computations"

This reverts CL 501495 (commit 5aa6acb96f843a0257c5c1c0e52753bcd18b77b3).

Reason for revert: Per internal discussion, we should fix go/types.
                   See issue #61035.

Change-Id: Ia63587af701b864acc1b43939954eae76572a407
Reviewed-on: https://go-review.googlesource.com/c/tools/+/506596
Reviewed-by: Robert Griesemer <gri@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Auto-Submit: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Robert Griesemer <gri@google.com>
Reviewed-by: Russ Cox <rsc@golang.org>
---
 go/analysis/unitchecker/sizes.go       | 237 -------------------------
 go/analysis/unitchecker/sizes_test.go  |  85 ---------
 go/analysis/unitchecker/unitchecker.go |   2 +-
 3 files changed, 1 insertion(+), 323 deletions(-)
 delete mode 100644 go/analysis/unitchecker/sizes.go
 delete mode 100644 go/analysis/unitchecker/sizes_test.go

diff --git a/go/analysis/unitchecker/sizes.go b/go/analysis/unitchecker/sizes.go
deleted file mode 100644
index 332e2e49a9b..00000000000
--- a/go/analysis/unitchecker/sizes.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package unitchecker
-
-import (
-	"fmt"
-	"go/types"
-)
-
-type gcSizes struct {
-	WordSize int64 // word size in bytes - must be >= 4 (32bits)
-	MaxAlign int64 // maximum alignment in bytes - must be >= 1
-}
-
-func (s *gcSizes) Alignof(T types.Type) int64 {
-	// For arrays and structs, alignment is defined in terms
-	// of alignment of the elements and fields, respectively.
-	switch t := T.Underlying().(type) {
-	case *types.Array:
-		// spec: "For a variable x of array type: unsafe.Alignof(x)
-		// is the same as unsafe.Alignof(x[0]), but at least 1."
-		return s.Alignof(t.Elem())
-	case *types.Struct:
-		if t.NumFields() == 0 && isSyncAtomicAlign64(T) {
-			// Special case: sync/atomic.align64 is an
-			// empty struct we recognize as a signal that
-			// the struct it contains must be
-			// 64-bit-aligned.
-			//
-			// This logic is equivalent to the logic in
-			// cmd/compile/internal/types/size.go:calcStructOffset
-			return 8
-		}
-
-		// spec: "For a variable x of struct type: unsafe.Alignof(x)
-		// is the largest of the values unsafe.Alignof(x.f) for each
-		// field f of x, but at least 1."
-		max := int64(1)
-		for i, nf := 0, t.NumFields(); i < nf; i++ {
-			if a := s.Alignof(t.Field(i).Type()); a > max {
-				max = a
-			}
-		}
-		return max
-	case *types.Slice, *types.Interface:
-		// Multiword data structures are effectively structs
-		// in which each element has size PtrSize.
-		return s.WordSize
-	case *types.Basic:
-		// Strings are like slices and interfaces.
-		if t.Info()&types.IsString != 0 {
-			return s.WordSize
-		}
-	}
-	a := s.Sizeof(T) // may be 0
-	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
-	if a < 1 {
-		return 1
-	}
-	// complex{64,128} are aligned like [2]float{32,64}.
-	if isComplex(T) {
-		a /= 2
-	}
-	if a > s.MaxAlign {
-		return s.MaxAlign
-	}
-	return a
-}
-
-func isComplex(T types.Type) bool {
-	basic, ok := T.Underlying().(*types.Basic)
-	return ok && basic.Info()&types.IsComplex != 0
-}
-
-func (s *gcSizes) Offsetsof(fields []*types.Var) []int64 {
-	offsets := make([]int64, len(fields))
-	var offs int64
-	for i, f := range fields {
-		if offs < 0 {
-			// all remaining offsets are too large
-			offsets[i] = -1
-			continue
-		}
-		// offs >= 0
-		typ := f.Type()
-		a := s.Alignof(typ)
-		offs = roundUp(offs, a) // possibly < 0 if align overflows
-		offsets[i] = offs
-		if d := s.Sizeof(typ); d >= 0 && offs >= 0 {
-			offs += d // ok to overflow to < 0
-		} else {
-			offs = -1
-		}
-	}
-	return offsets
-}
-
-func (s *gcSizes) Sizeof(T types.Type) int64 {
-	switch t := T.Underlying().(type) {
-	case *types.Basic:
-		k := t.Kind()
-		if int(k) < len(basicSizes) {
-			if s := basicSizes[k]; s > 0 {
-				return int64(s)
-			}
-		}
-		switch k {
-		case types.String:
-			return s.WordSize * 2
-		case types.Int, types.Uint, types.Uintptr, types.UnsafePointer:
-			return s.WordSize
-		}
-		panic(fmt.Sprintf("unimplemented basic: %v (kind %v)", T, k))
-	case *types.Array:
-		n := t.Len()
-		if n <= 0 {
-			return 0
-		}
-		// n > 0
-		// gc: Size includes alignment padding.
-		esize := s.Sizeof(t.Elem())
-		if esize < 0 {
-			return -1 // array element too large
-		}
-		if esize == 0 {
-			return 0 // 0-size element
-		}
-		// esize > 0
-		// Final size is esize * n; and size must be <= maxInt64.
-		const maxInt64 = 1<<63 - 1
-		if esize > maxInt64/n {
-			return -1 // esize * n overflows
-		}
-		return esize * n
-	case *types.Slice:
-		return s.WordSize * 3
-	case *types.Struct:
-		n := t.NumFields()
-		if n == 0 {
-			return 0
-		}
-		// n > 0
-		fields := make([]*types.Var, n)
-		for i := range fields {
-			fields[i] = t.Field(i)
-		}
-		offsets := s.Offsetsof(fields)
-		// gc: The last field of a non-zero-sized struct is not allowed to
-		// have size 0.
-		last := s.Sizeof(fields[n-1].Type())
-		if last == 0 && offsets[n-1] > 0 {
-			last = 1
-		}
-		// gc: Size includes alignment padding.
-		return roundUp(offsets[n-1]+last, s.Alignof(t)) // may overflow to < 0 which is ok
-	case *types.Interface:
-		return s.WordSize * 2
-	case *types.Chan, *types.Map, *types.Pointer, *types.Signature:
-		return s.WordSize
-	default:
-		panic(fmt.Sprintf("Sizeof(%T) unimplemented", t))
-	}
-}
-
-func isSyncAtomicAlign64(T types.Type) bool {
-	named, ok := T.(*types.Named)
-	if !ok {
-		return false
-	}
-	obj := named.Obj()
-	return obj.Name() == "align64" &&
-		obj.Pkg() != nil &&
-		(obj.Pkg().Path() == "sync/atomic" ||
-			obj.Pkg().Path() == "runtime/internal/atomic")
-}
-
-// roundUp rounds o to a multiple of r, r is a power of 2.
-func roundUp(o int64, r int64) int64 {
-	if r < 1 || r > 8 || r&(r-1) != 0 {
-		panic(fmt.Sprintf("Round %d", r))
-	}
-	return (o + r - 1) &^ (r - 1)
-}
-
-var basicSizes = [...]byte{
-	types.Invalid:    1,
-	types.Bool:       1,
-	types.Int8:       1,
-	types.Int16:      2,
-	types.Int32:      4,
-	types.Int64:      8,
-	types.Uint8:      1,
-	types.Uint16:     2,
-	types.Uint32:     4,
-	types.Uint64:     8,
-	types.Float32:    4,
-	types.Float64:    8,
-	types.Complex64:  8,
-	types.Complex128: 16,
-}
-
-// common architecture word sizes and alignments
-var gcArchSizes = map[string]*gcSizes{
-	"386":      {4, 4},
-	"amd64":    {8, 8},
-	"amd64p32": {4, 8},
-	"arm":      {4, 4},
-	"arm64":    {8, 8},
-	"loong64":  {8, 8},
-	"mips":     {4, 4},
-	"mipsle":   {4, 4},
-	"mips64":   {8, 8},
-	"mips64le": {8, 8},
-	"ppc64":    {8, 8},
-	"ppc64le":  {8, 8},
-	"riscv64":  {8, 8},
-	"s390x":    {8, 8},
-	"sparc64":  {8, 8},
-	"wasm":     {8, 8},
-	// When adding more architectures here,
-	// update the doc string of sizesFor below.
-}
-
-// sizesFor returns the go/types.Sizes used by a compiler for an architecture.
-// The result is nil if a compiler/architecture pair is not known.
-func sizesFor(compiler, arch string) types.Sizes {
-	if compiler != "gc" {
-		return nil
-	}
-	s, ok := gcArchSizes[arch]
-	if !ok {
-		return nil
-	}
-	return s
-}
diff --git a/go/analysis/unitchecker/sizes_test.go b/go/analysis/unitchecker/sizes_test.go
deleted file mode 100644
index 5d98a23338c..00000000000
--- a/go/analysis/unitchecker/sizes_test.go
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package unitchecker
-
-import (
-	"go/ast"
-	"go/importer"
-	"go/parser"
-	"go/token"
-	"go/types"
-	"testing"
-)
-
-type gcSizeTest struct {
-	name string
-	src  string
-}
-
-var gcSizesTests = []gcSizeTest{
-	{
-		"issue60431",
-		`package main
-	
-	import "unsafe"
-	
-	// The foo struct size is expected to be rounded up to 16 bytes.
-	type foo struct {
-		a int64
-		b bool
-	}
-	
-	func main() {
-		var _ [unsafe.Sizeof(foo{}) - 16]byte
-	       println(unsafe.Sizeof(foo{}))
-	}`,
-	},
-	{
-		"issue60734",
-		`package main
-	
-	import (
-		"unsafe"
-	)
-	
-	// The Data struct size is expected to be rounded up to 16 bytes.
-	type Data struct {
-		Value  uint32   // 4 bytes
-		Label  [10]byte // 10 bytes
-		Active bool     // 1 byte
-		// padded with 1 byte to make it align
-	}
-	
-	const (
-		dataSize = unsafe.Sizeof(Data{})
-		dataSizeLiteral = 16
-	)
-	
-	func main() {
-		_ = [16]byte{0, 132, 95, 237, 80, 104, 111, 110, 101, 0, 0, 0, 0, 0, 1, 0}
-		_ = [dataSize]byte{0, 132, 95, 237, 80, 104, 111, 110, 101, 0, 0, 0, 0, 0, 1, 0}
-	       _ = [dataSizeLiteral]byte{0, 132, 95, 237, 80, 104, 111, 110, 101, 0, 0, 0, 0, 0, 1, 0}
-	}`,
-	},
-}
-
-func TestGCSizes(t *testing.T) {
-	for _, tc := range gcSizesTests {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			fset := token.NewFileSet()
-			f, err := parser.ParseFile(fset, "x.go", tc.src, 0)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			conf := types.Config{Importer: importer.Default(), Sizes: sizesFor("gc", "amd64")}
-			if _, err := conf.Check("main.go", fset, []*ast.File{f}, nil); err != nil {
-				t.Fatal(err) // type error
-			}
-		})
-	}
-}
diff --git a/go/analysis/unitchecker/unitchecker.go b/go/analysis/unitchecker/unitchecker.go
index 8334cf06301..ff22d23ce5c 100644
--- a/go/analysis/unitchecker/unitchecker.go
+++ b/go/analysis/unitchecker/unitchecker.go
@@ -218,7 +218,7 @@ func run(fset *token.FileSet, cfg *Config, analyzers []*analysis.Analyzer) ([]re
 	})
 	tc := &types.Config{
 		Importer: importer,
-		Sizes:    sizesFor("gc", build.Default.GOARCH), // assume gccgo ≡ gc?
+		Sizes:    types.SizesFor("gc", build.Default.GOARCH), // assume gccgo ≡ gc?
 	}
 	info := &types.Info{
 		Types:      make(map[ast.Expr]types.TypeAndValue),

From d362be0cdb73ca5215ecaaf1514120c6b8b955e9 Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Wed, 28 Jun 2023 11:17:51 -0400
Subject: [PATCH 20/26] gopls/internal/lsp/filecache: reduce GC frequency

This is a mitigation for observed high idle CPU usage.

Also, eliminate the obsolete special case for builders,
now that each CI run gets a fresh GOPLSCACHE.

Updates golang/go#61049

Change-Id: I8689ab9ebf4d9ef75d9e1a0f4bc7bc9d109bef71
Reviewed-on: https://go-review.googlesource.com/c/tools/+/506815
TryBot-Result: Gopher Robot <gobot@golang.org>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Bryan Mills <bcmills@google.com>
Run-TryBot: Alan Donovan <adonovan@google.com>
---
 gopls/internal/lsp/filecache/filecache.go | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/gopls/internal/lsp/filecache/filecache.go b/gopls/internal/lsp/filecache/filecache.go
index 624f8722837..286b4586c68 100644
--- a/gopls/internal/lsp/filecache/filecache.go
+++ b/gopls/internal/lsp/filecache/filecache.go
@@ -385,7 +385,16 @@ func hashExecutable() (hash [32]byte, err error) {
 // process, possibly running a different version of gopls, possibly
 // running concurrently.
 func gc(goplsDir string) {
-	const period = 1 * time.Minute // period between collections
+	// period between collections
+	//
+	// This was increased from 1 minute as an immediate measure to
+	// reduce the CPU cost of gopls when idle, which was around
+	// 15% of a core (#61049). A better solution might be to avoid
+	// walking the entire tree every period. e.g. walk only the
+	// subtree corresponding to this gopls executable every period,
+	// and the subtrees for other gopls instances every hour.
+	const period = 5 * time.Minute
+
 	// Sleep statDelay*batchSize between stats to smooth out I/O.
 	//
 	// The constants below were chosen using the following heuristics:
@@ -396,17 +405,7 @@ func gc(goplsDir string) {
 	//    sleeping after every stat (due to OS optimizations).
 	const statDelay = 100 * time.Microsecond // average delay between stats, to smooth out I/O
 	const batchSize = 1000                   // # of stats to process before sleeping
-	maxAge := 5 * 24 * time.Hour             // max time since last access before file is deleted
-
-	// This environment variable is set when running under a Go test builder.
-	// We use it to trigger much more aggressive cache eviction to prevent
-	// filling of the tmp volume by short-lived test processes.
-	// A single run of the gopls tests takes on the order of a minute
-	// and produces <50MB of cache data, so these are still generous.
-	if os.Getenv("GO_BUILDER_NAME") != "" {
-		maxAge = 1 * time.Hour
-		SetBudget(250 * 1e6) // 250MB
-	}
+	const maxAge = 5 * 24 * time.Hour        // max time since last access before file is deleted
 
 	// The macOS filesystem is strikingly slow, at least on some machines.
 	// /usr/bin/find achieves only about 25,000 stats per second

From 27fd94e099b2bbd4c660f0b140af121af9a943c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Olivier=20Mengu=C3=A9?= <olivier.mengue@gmail.com>
Date: Thu, 29 Jun 2023 10:20:26 +0200
Subject: [PATCH 21/26] internal/fastwalk: doc formatting fixes (including
 godoc links)

* add godoc links
* fix minor typos

Change-Id: Iea7727913c412ccad259d62e75325903327fdb9a
Reviewed-on: https://go-review.googlesource.com/c/tools/+/506775
Reviewed-by: Bryan Mills <bcmills@google.com>
Run-TryBot: Heschi Kreinick <heschi@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Heschi Kreinick <heschi@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Auto-Submit: Bryan Mills <bcmills@google.com>
---
 internal/fastwalk/fastwalk.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/internal/fastwalk/fastwalk.go b/internal/fastwalk/fastwalk.go
index 798fe599be4..c40c7e93106 100644
--- a/internal/fastwalk/fastwalk.go
+++ b/internal/fastwalk/fastwalk.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package fastwalk provides a faster version of filepath.Walk for file system
+// Package fastwalk provides a faster version of [filepath.Walk] for file system
 // scanning tools.
 package fastwalk
 
@@ -23,31 +23,31 @@ var ErrTraverseLink = errors.New("fastwalk: traverse symlink, assuming target is
 // Child directories will still be traversed.
 var ErrSkipFiles = errors.New("fastwalk: skip remaining files in directory")
 
-// Walk is a faster implementation of filepath.Walk.
+// Walk is a faster implementation of [filepath.Walk].
 //
-// filepath.Walk's design necessarily calls os.Lstat on each file,
+// [filepath.Walk]'s design necessarily calls [os.Lstat] on each file,
 // even if the caller needs less info.
 // Many tools need only the type of each file.
 // On some platforms, this information is provided directly by the readdir
 // system call, avoiding the need to stat each file individually.
 // fastwalk_unix.go contains a fork of the syscall routines.
 //
-// See golang.org/issue/16399
+// See golang.org/issue/16399.
 //
 // Walk walks the file tree rooted at root, calling walkFn for
 // each file or directory in the tree, including root.
 //
-// If fastWalk returns filepath.SkipDir, the directory is skipped.
+// If Walk returns [filepath.SkipDir], the directory is skipped.
 //
-// Unlike filepath.Walk:
+// Unlike [filepath.Walk]:
 //   - file stat calls must be done by the user.
 //     The only provided metadata is the file type, which does not include
 //     any permission bits.
 //   - multiple goroutines stat the filesystem concurrently. The provided
 //     walkFn must be safe for concurrent use.
-//   - fastWalk can follow symlinks if walkFn returns the TraverseLink
+//   - Walk can follow symlinks if walkFn returns the TraverseLink
 //     sentinel error. It is the walkFn's responsibility to prevent
-//     fastWalk from going into symlink cycles.
+//     Walk from going into symlink cycles.
 func Walk(root string, walkFn func(path string, typ os.FileMode) error) error {
 	// TODO(bradfitz): make numWorkers configurable? We used a
 	// minimum of 4 to give the kernel more info about multiple

From 87ad891fe35467be3d692a3f37fef9fb5cb08dcd Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Mon, 12 Jun 2023 11:35:40 -0400
Subject: [PATCH 22/26] gopls/internal/lsp/source/typerefs: move test into
 _test.go

This change moves logic needed only by the test
into the test package. (I got quite confused trying
to understand the algorithm before I realized this code
is never used in the product.)

Also:
- move Decode trace logic into test.
- expose PackageSet.AddDeclaringPackage to test.
- rename Symbol.PackageID(PackageIndex) to
  PackageIndex.DeclaringPackage(Symbol) to match.
- use receiver name 'index' consistently.

Fixes golang/go#60598

Change-Id: Icb88bde030a18bcab71d4cb74e0004fe27c815f4
Reviewed-on: https://go-review.googlesource.com/c/tools/+/502536
Run-TryBot: Alan Donovan <adonovan@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
gopls-CI: kokoro <noreply+kokoro@google.com>
Reviewed-by: Robert Findley <rfindley@google.com>
---
 gopls/internal/lsp/cache/check.go             |  6 +-
 .../lsp/source/typerefs/packageset.go         | 35 ++++++----
 .../typerefs/{pkgrefs.go => pkggraph_test.go} | 68 ++++++++++++++-----
 .../lsp/source/typerefs/pkgrefs_test.go       |  5 +-
 gopls/internal/lsp/source/typerefs/refs.go    | 38 ++---------
 .../internal/lsp/source/typerefs/refs_test.go |  2 +-
 6 files changed, 82 insertions(+), 72 deletions(-)
 rename gopls/internal/lsp/source/typerefs/{pkgrefs.go => pkggraph_test.go} (79%)

diff --git a/gopls/internal/lsp/cache/check.go b/gopls/internal/lsp/cache/check.go
index 9329d4bd0d1..0e3b03233f8 100644
--- a/gopls/internal/lsp/cache/check.go
+++ b/gopls/internal/lsp/cache/check.go
@@ -884,15 +884,15 @@ func (b *packageHandleBuilder) getTransitiveRefsLocked(id PackageID) map[string]
 	for name := range ph.refs {
 		if token.IsExported(name) {
 			pkgs := b.s.pkgIndex.NewSet()
-			for _, node := range ph.refs[name] {
+			for _, sym := range ph.refs[name] {
 				// TODO: opt: avoid int -> PackageID -> int conversions here.
-				id := node.PackageID(b.s.pkgIndex)
+				id := b.s.pkgIndex.DeclaringPackage(sym)
 				pkgs.Add(id)
 				otherRefs := b.getTransitiveRefsLocked(id)
 				if otherRefs == nil {
 					return nil // a predecessor failed: exit early
 				}
-				if otherSet, ok := otherRefs[node.Name]; ok {
+				if otherSet, ok := otherRefs[sym.Name]; ok {
 					pkgs.Union(otherSet)
 				}
 			}
diff --git a/gopls/internal/lsp/source/typerefs/packageset.go b/gopls/internal/lsp/source/typerefs/packageset.go
index 2f1937dbcb9..afa31244b37 100644
--- a/gopls/internal/lsp/source/typerefs/packageset.go
+++ b/gopls/internal/lsp/source/typerefs/packageset.go
@@ -34,25 +34,25 @@ func NewPackageIndex() *PackageIndex {
 
 // idx returns the packageIdx referencing id, creating one if id is not yet
 // tracked by the receiver.
-func (r *PackageIndex) idx(id source.PackageID) int {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	if i, ok := r.m[id]; ok {
+func (index *PackageIndex) idx(id source.PackageID) int {
+	index.mu.Lock()
+	defer index.mu.Unlock()
+	if i, ok := index.m[id]; ok {
 		return i
 	}
-	i := len(r.ids)
-	r.m[id] = i
-	r.ids = append(r.ids, id)
+	i := len(index.ids)
+	index.m[id] = i
+	index.ids = append(index.ids, id)
 	return i
 }
 
 // id returns the PackageID for idx.
 //
 // idx must have been created by this PackageIndex instance.
-func (r *PackageIndex) id(idx int) source.PackageID {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	return r.ids[idx]
+func (index *PackageIndex) id(idx int) source.PackageID {
+	index.mu.Lock()
+	defer index.mu.Unlock()
+	return index.ids[idx]
 }
 
 // A PackageSet is a set of source.PackageIDs, optimized for inuse memory
@@ -70,18 +70,27 @@ const blockSize = bits.UintSize
 //
 // PackageSets may only be combined with other PackageSets from the same
 // instance.
-func (s *PackageIndex) NewSet() *PackageSet {
+func (index *PackageIndex) NewSet() *PackageSet {
 	return &PackageSet{
-		parent: s,
+		parent: index,
 		sparse: make(map[int]blockType),
 	}
 }
 
+// DeclaringPackage returns the ID of the symbol's declaring package.
+// The package index must be the one used during decoding.
+func (index *PackageIndex) DeclaringPackage(sym Symbol) source.PackageID {
+	return index.id(sym.pkgIdx)
+}
+
 // Add records a new element in the package set.
 func (s *PackageSet) Add(id source.PackageID) {
 	s.add(s.parent.idx(id))
 }
 
+// AddDeclaringPackage adds sym's declaring package to the set.
+func (s *PackageSet) AddDeclaringPackage(sym Symbol) { s.add(sym.pkgIdx) }
+
 func (s *PackageSet) add(idx int) {
 	i := int(idx)
 	s.sparse[i/blockSize] |= 1 << (i % blockSize)
diff --git a/gopls/internal/lsp/source/typerefs/pkgrefs.go b/gopls/internal/lsp/source/typerefs/pkggraph_test.go
similarity index 79%
rename from gopls/internal/lsp/source/typerefs/pkgrefs.go
rename to gopls/internal/lsp/source/typerefs/pkggraph_test.go
index b2c94de2015..514bf02ecad 100644
--- a/gopls/internal/lsp/source/typerefs/pkgrefs.go
+++ b/gopls/internal/lsp/source/typerefs/pkggraph_test.go
@@ -2,15 +2,23 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package typerefs
+package typerefs_test
+
+// This file is logically part of the test in pkgrefs_test.go: that
+// file defines the test assertion logic; this file provides a
+// reference implementation of a client of the typerefs package.
 
 import (
+	"bytes"
 	"context"
+	"fmt"
+	"os"
 	"runtime"
 	"sync"
 
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/tools/gopls/internal/lsp/source"
+	"golang.org/x/tools/gopls/internal/lsp/source/typerefs"
 	"golang.org/x/tools/gopls/internal/span"
 )
 
@@ -19,9 +27,6 @@ const (
 	//
 	// Warning: produces a lot of output! Best to run with small package queries.
 	trace = false
-
-	// debug enables additional assertions.
-	debug = false
 )
 
 // A Package holds reference information for a single package.
@@ -32,18 +37,18 @@ type Package struct {
 	// transitiveRefs records, for each exported declaration in the package, the
 	// transitive set of packages within the containing graph that are
 	// transitively reachable through references, starting with the given decl.
-	transitiveRefs map[string]*PackageSet
+	transitiveRefs map[string]*typerefs.PackageSet
 
 	// ReachesViaDeps records the set of packages in the containing graph whose
 	// syntax may affect the current package's types. See the package
 	// documentation for more details of what this means.
-	ReachesByDeps *PackageSet
+	ReachesByDeps *typerefs.PackageSet
 }
 
 // A PackageGraph represents a fully analyzed graph of packages and their
 // dependencies.
 type PackageGraph struct {
-	pkgIndex *PackageIndex
+	pkgIndex *typerefs.PackageIndex
 	meta     source.MetadataSource
 	parse    func(context.Context, span.URI) (*source.ParsedGoFile, error)
 
@@ -63,7 +68,7 @@ type PackageGraph struct {
 // algorithm.
 func BuildPackageGraph(ctx context.Context, meta source.MetadataSource, ids []source.PackageID, parse func(context.Context, span.URI) (*source.ParsedGoFile, error)) (*PackageGraph, error) {
 	g := &PackageGraph{
-		pkgIndex: NewPackageIndex(),
+		pkgIndex: typerefs.NewPackageIndex(),
 		meta:     meta,
 		parse:    parse,
 		packages: make(map[source.PackageID]*futurePackage),
@@ -120,7 +125,7 @@ func (g *PackageGraph) Package(ctx context.Context, id source.PackageID) (*Packa
 func (g *PackageGraph) buildPackage(ctx context.Context, id source.PackageID) (*Package, error) {
 	p := &Package{
 		metadata:       g.meta.Metadata(id),
-		transitiveRefs: make(map[string]*PackageSet),
+		transitiveRefs: make(map[string]*typerefs.PackageSet),
 	}
 	var files []*source.ParsedGoFile
 	for _, filename := range p.metadata.CompiledGoFiles {
@@ -138,9 +143,10 @@ func (g *PackageGraph) buildPackage(ctx context.Context, id source.PackageID) (*
 	}
 
 	// Compute the symbol-level dependencies through this package.
-	// TODO(adonovan): opt: persist this in the filecache, keyed
+	data := typerefs.Encode(files, id, imports)
+
+	// data can be persisted in a filecache, keyed
 	// by hash(id, CompiledGoFiles, imports).
-	data := Encode(files, id, imports)
 
 	//      This point separates the local preprocessing
 	//  --  of a single package (above) from the global   --
@@ -150,9 +156,33 @@ func (g *PackageGraph) buildPackage(ctx context.Context, id source.PackageID) (*
 	// package and declarations in this package or another
 	// package. See the package documentation for a detailed
 	// description of what these edges do (and do not) represent.
-	classes := Decode(g.pkgIndex, id, data)
-
-	idx := g.pkgIndex.idx(id)
+	classes := typerefs.Decode(g.pkgIndex, id, data)
+
+	// Debug
+	if trace && len(classes) > 0 {
+		var buf bytes.Buffer
+		fmt.Fprintf(&buf, "%s\n", id)
+		for _, class := range classes {
+			for i, name := range class.Decls {
+				if i == 0 {
+					fmt.Fprintf(&buf, "\t")
+				}
+				fmt.Fprintf(&buf, " .%s", name)
+			}
+			// Group symbols by package.
+			var prevID PackageID
+			for _, sym := range class.Refs {
+				id := g.pkgIndex.DeclaringPackage(sym)
+				if id != prevID {
+					prevID = id
+					fmt.Fprintf(&buf, "\n\t\t-> %s:", id)
+				}
+				fmt.Fprintf(&buf, " .%s", sym.Name)
+			}
+			fmt.Fprintln(&buf)
+		}
+		os.Stderr.Write(buf.Bytes())
+	}
 
 	// Now compute the transitive closure of packages reachable
 	// from any exported symbol of this package.
@@ -164,8 +194,10 @@ func (g *PackageGraph) buildPackage(ctx context.Context, id source.PackageID) (*
 		// when the package id changes.
 		depP := p
 		for _, sym := range class.Refs {
-			assert(sym.pkgIdx != idx, "intra-package edge")
-			symPkgID := g.pkgIndex.id(sym.pkgIdx)
+			symPkgID := g.pkgIndex.DeclaringPackage(sym)
+			if symPkgID == id {
+				panic("intra-package edge")
+			}
 			if depP.metadata.ID != symPkgID {
 				// package changed
 				var err error
@@ -174,7 +206,7 @@ func (g *PackageGraph) buildPackage(ctx context.Context, id source.PackageID) (*
 					return nil, err
 				}
 			}
-			set.add(sym.pkgIdx)
+			set.AddDeclaringPackage(sym)
 			set.Union(depP.transitiveRefs[sym.Name])
 		}
 		for _, name := range class.Decls {
@@ -195,7 +227,7 @@ func (g *PackageGraph) buildPackage(ctx context.Context, id source.PackageID) (*
 
 // reachesByDeps computes the set of packages that are reachable through
 // dependencies of the package m.
-func (g *PackageGraph) reachesByDeps(ctx context.Context, m *source.Metadata) (*PackageSet, error) {
+func (g *PackageGraph) reachesByDeps(ctx context.Context, m *source.Metadata) (*typerefs.PackageSet, error) {
 	transitive := g.pkgIndex.NewSet()
 	for _, depID := range m.DepsByPkgPath {
 		dep, err := g.Package(ctx, depID)
diff --git a/gopls/internal/lsp/source/typerefs/pkgrefs_test.go b/gopls/internal/lsp/source/typerefs/pkgrefs_test.go
index b6e1ac242a4..39200a515dc 100644
--- a/gopls/internal/lsp/source/typerefs/pkgrefs_test.go
+++ b/gopls/internal/lsp/source/typerefs/pkgrefs_test.go
@@ -23,7 +23,6 @@ import (
 	"golang.org/x/tools/gopls/internal/astutil"
 	"golang.org/x/tools/gopls/internal/lsp/cache"
 	"golang.org/x/tools/gopls/internal/lsp/source"
-	"golang.org/x/tools/gopls/internal/lsp/source/typerefs"
 	"golang.org/x/tools/gopls/internal/span"
 	"golang.org/x/tools/internal/packagesinternal"
 	"golang.org/x/tools/internal/testenv"
@@ -87,7 +86,7 @@ func TestBuildPackageGraph(t *testing.T) {
 	})
 
 	t0 = time.Now()
-	g, err := typerefs.BuildPackageGraph(ctx, meta, ids, newParser().parse)
+	g, err := BuildPackageGraph(ctx, meta, ids, newParser().parse)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -263,7 +262,7 @@ func BenchmarkBuildPackageGraph(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := typerefs.BuildPackageGraph(ctx, meta, ids, newParser().parse)
+		_, err := BuildPackageGraph(ctx, meta, ids, newParser().parse)
 		if err != nil {
 			b.Fatal(err)
 		}
diff --git a/gopls/internal/lsp/source/typerefs/refs.go b/gopls/internal/lsp/source/typerefs/refs.go
index 27486c0111c..516afc6d185 100644
--- a/gopls/internal/lsp/source/typerefs/refs.go
+++ b/gopls/internal/lsp/source/typerefs/refs.go
@@ -11,7 +11,6 @@ import (
 	"go/ast"
 	"go/token"
 	"log"
-	"os"
 	"sort"
 	"strings"
 
@@ -65,12 +64,6 @@ type Symbol struct {
 	Name   string
 }
 
-// PackageID returns the symbol's package identifier.
-// The package index must be the one used during decoding.
-func (sym Symbol) PackageID(index *PackageIndex) source.PackageID {
-	return index.id(sym.pkgIdx)
-}
-
 // -- internals --
 
 // A symbolSet is a set of symbols used internally during index construction.
@@ -726,14 +719,16 @@ func (decl *declNode) find() *declNode {
 	return rep
 }
 
+const debugSCC = false // enable assertions in strong-component algorithm
+
 func checkCanonical(x *declNode) {
-	if debug {
+	if debugSCC {
 		assert(x == x.find(), "not canonical")
 	}
 }
 
 func assert(cond bool, msg string) {
-	if debug && !cond {
+	if debugSCC && !cond {
 		panic(msg)
 	}
 }
@@ -828,31 +823,6 @@ func decode(pkgIndex *PackageIndex, id source.PackageID, data []byte) []Class {
 		return classes[i].Decls[0] < classes[j].Decls[0]
 	})
 
-	// Debug
-	if trace && len(classes) > 0 {
-		var buf bytes.Buffer
-		fmt.Fprintf(&buf, "%s\n", id)
-		for _, class := range classes {
-			for i, name := range class.Decls {
-				if i == 0 {
-					fmt.Fprintf(&buf, "\t")
-				}
-				fmt.Fprintf(&buf, " .%s", name)
-			}
-			// Group symbols by package.
-			prevID := -1
-			for _, sym := range class.Refs {
-				if sym.pkgIdx != prevID {
-					prevID = sym.pkgIdx
-					fmt.Fprintf(&buf, "\n\t\t-> %s:", sym.PackageID(pkgIndex))
-				}
-				fmt.Fprintf(&buf, " .%s", sym.Name)
-			}
-			fmt.Fprintln(&buf)
-		}
-		os.Stderr.Write(buf.Bytes())
-	}
-
 	return classes
 }
 
diff --git a/gopls/internal/lsp/source/typerefs/refs_test.go b/gopls/internal/lsp/source/typerefs/refs_test.go
index adf79bd8f7e..b83c7812407 100644
--- a/gopls/internal/lsp/source/typerefs/refs_test.go
+++ b/gopls/internal/lsp/source/typerefs/refs_test.go
@@ -543,7 +543,7 @@ type Z map[ext.A]ext.B
 				for _, name := range class.Decls {
 					var syms []string
 					for _, sym := range class.Refs {
-						syms = append(syms, fmt.Sprintf("%s.%s", sym.PackageID(index), sym.Name))
+						syms = append(syms, fmt.Sprintf("%s.%s", index.DeclaringPackage(sym), sym.Name))
 					}
 					sort.Strings(syms)
 					got[name] = syms

From c4953641676aa4639fcbd2ca825c43cedeaa9e8c Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Mon, 26 Jun 2023 20:06:46 -0400
Subject: [PATCH 23/26] go/packages/gopackages: document -mode flag

Fixes golang/go#60995

Change-Id: I9bb9b2a95a1be7416e86a3759fd5aa7321f1fd06
Reviewed-on: https://go-review.googlesource.com/c/tools/+/506357
Auto-Submit: Alan Donovan <adonovan@google.com>
Run-TryBot: Alan Donovan <adonovan@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
---
 go/packages/gopackages/main.go | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/go/packages/gopackages/main.go b/go/packages/gopackages/main.go
index f202dff71da..bf0b5043fc6 100644
--- a/go/packages/gopackages/main.go
+++ b/go/packages/gopackages/main.go
@@ -34,7 +34,7 @@ type application struct {
 	Deps       bool            `flag:"deps" help:"show dependencies too"`
 	Test       bool            `flag:"test" help:"include any tests implied by the patterns"`
 	Mode       string          `flag:"mode" help:"mode (one of files, imports, types, syntax, allsyntax)"`
-	Private    bool            `flag:"private" help:"show non-exported declarations too"`
+	Private    bool            `flag:"private" help:"show non-exported declarations too (if -mode=syntax)"`
 	PrintJSON  bool            `flag:"json" help:"print package in JSON form"`
 	BuildFlags stringListValue `flag:"buildflag" help:"pass argument to underlying build system (may be repeated)"`
 }
@@ -56,6 +56,21 @@ func (app *application) DetailedHelp(f *flag.FlagSet) {
 Packages are specified using the notation of "go list",
 or other underlying build system.
 
+The mode flag determines how much information is computed and printed
+for the specified packages. In order of increasing computational cost,
+the legal values are:
+
+ -mode=files     shows only the names of the packages' files.
+ -mode=imports   also shows the imports. (This is the default.)
+ -mode=types     loads the compiler's export data and displays the
+                 type of each exported declaration.
+ -mode=syntax    parses and type checks syntax trees for the initial
+                 packages. (With the -private flag, the types of
+                 non-exported declarations are shown too.)
+                 Type information for dependencies is obtained from
+                 compiler export data.
+ -mode=allsyntax is like -mode=syntax but applied to all dependencies.
+
 Flags:
 `)
 	f.PrintDefaults()
@@ -189,7 +204,7 @@ func (app *application) print(lpkg *packages.Package) {
 		fmt.Printf("\t%s\n", err)
 	}
 
-	// package members (TypeCheck or WholeProgram mode)
+	// types of package members
 	if lpkg.Types != nil {
 		qual := types.RelativeTo(lpkg.Types)
 		scope := lpkg.Types.Scope()

From 14ec3c023fa0003b489ce1abe0484924ea5276f8 Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Wed, 28 Jun 2023 18:46:21 -0400
Subject: [PATCH 24/26] gopls/doc/contributing.md: document error handling
 strategies

Fixes golang/go#60969

Change-Id: Ia19cf735523b8d0022ae00d79db6a6f95d064f6e
Reviewed-on: https://go-review.googlesource.com/c/tools/+/506938
Run-TryBot: Alan Donovan <adonovan@google.com>
Reviewed-by: Hyang-Ah Hana Kim <hyangah@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
gopls-CI: kokoro <noreply+kokoro@google.com>
---
 gopls/doc/contributing.md | 46 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/gopls/doc/contributing.md b/gopls/doc/contributing.md
index 367280f53e3..0ac56caf269 100644
--- a/gopls/doc/contributing.md
+++ b/gopls/doc/contributing.md
@@ -46,6 +46,52 @@ The best way to contact the gopls team directly is via the
 gophers slack. Please feel free to ask any questions about your contribution or
 about contributing in general.
 
+
+## Error handling
+
+It is important for the user experience that, whenever practical,
+minor logic errors in a particular feature don't cause the server to
+crash.
+
+The representation of a Go program is complex. The import graph of
+package metadata, the syntax trees of parsed files, and their
+associated type information together form a huge API surface area.
+Even when the input is valid, there are many edge cases to consider,
+and this grows by an order of magnitude when you consider missing
+imports, parse errors, and type errors.
+
+What should you do when your logic must handle an error that you
+believe "can't happen"?
+
+- If it's possible to return an error, then use the `bug.Errorf`
+  function to return an error to the user, but also record the bug in
+  gopls' cache so that it is less likely to be ignored.
+
+- If it's safe to proceed, you can call `bug.Reportf` to record the
+  error and continue as normal.
+
+- If there's no way to proceed, call `bug.Fatalf` to record the error
+  and then stop the program with `log.Fatalf`. You can also use
+  `bug.Panicf` if there's a chance that a recover handler might save
+  the situation.
+
+- Only if you can prove locally that an error is impossible should you
+  call `log.Fatal`. If the error may happen for some input, however
+  unlikely, then you should use one of the approaches above. Also, if
+  the proof of safety depends on invariants broadly distributed across
+  the code base, then you should instead use `bug.Panicf`.
+
+Note also that panicking is preferable to `log.Fatal` because it
+allows VS Code's crash reporting to recognize and capture the stack.
+
+Bugs reported through `bug.Errorf` and friends are retrieved using the
+`gopls bug` command, which opens a GitHub Issue template and populates
+it with a summary of each bug and its frequency.
+The text of the bug is rather fastidiously printed to stdout to avoid
+sharing user names and error message strings (which could contain
+project identifiers) with GitHub.
+Users are invited to share it if they are willing.
+
 ## Testing
 
 To run tests for just `gopls/`, run,

From ad52c1ca35fb661c53eedbdee5f3b0e3c33e54e1 Mon Sep 17 00:00:00 2001
From: Tim King <taking@google.com>
Date: Tue, 6 Jun 2023 14:21:26 -0700
Subject: [PATCH 25/26] go/ssa/interp: support conversions to slices of named
 bytes

Support for conversions from string to slices of named byte and rune
types and vice versa.

Fixes golang/go#55115

Change-Id: Ie0fb94385f1bc89789fe299cc0c39063db676c21
Reviewed-on: https://go-review.googlesource.com/c/tools/+/501301
Reviewed-by: Alan Donovan <adonovan@google.com>
Auto-Submit: Tim King <taking@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
Run-TryBot: Tim King <taking@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
---
 go/ssa/interp/interp_test.go                  |  1 +
 go/ssa/interp/ops.go                          |  7 +---
 .../interp/testdata/fixedbugs/issue55115.go   | 38 +++++++++++++++++++
 3 files changed, 41 insertions(+), 5 deletions(-)
 create mode 100644 go/ssa/interp/testdata/fixedbugs/issue55115.go

diff --git a/go/ssa/interp/interp_test.go b/go/ssa/interp/interp_test.go
index 64ede78ae27..b3edc9916e2 100644
--- a/go/ssa/interp/interp_test.go
+++ b/go/ssa/interp/interp_test.go
@@ -129,6 +129,7 @@ var testdataTests = []string{
 	"width32.go",
 
 	"fixedbugs/issue52342.go",
+	"fixedbugs/issue55115.go",
 }
 
 func init() {
diff --git a/go/ssa/interp/ops.go b/go/ssa/interp/ops.go
index dd309bf9ca9..65d6452b783 100644
--- a/go/ssa/interp/ops.go
+++ b/go/ssa/interp/ops.go
@@ -1211,8 +1211,7 @@ func conv(t_dst, t_src types.Type, x value) value {
 
 	case *types.Slice:
 		// []byte or []rune -> string
-		// TODO(adonovan): fix: type B byte; conv([]B -> string).
-		switch ut_src.Elem().(*types.Basic).Kind() {
+		switch ut_src.Elem().Underlying().(*types.Basic).Kind() {
 		case types.Byte:
 			x := x.([]value)
 			b := make([]byte, 0, len(x))
@@ -1234,7 +1233,6 @@ func conv(t_dst, t_src types.Type, x value) value {
 		x = widen(x)
 
 		// integer -> string?
-		// TODO(adonovan): fix: test integer -> named alias of string.
 		if ut_src.Info()&types.IsInteger != 0 {
 			if ut_dst, ok := ut_dst.(*types.Basic); ok && ut_dst.Kind() == types.String {
 				return fmt.Sprintf("%c", x)
@@ -1246,8 +1244,7 @@ func conv(t_dst, t_src types.Type, x value) value {
 			switch ut_dst := ut_dst.(type) {
 			case *types.Slice:
 				var res []value
-				// TODO(adonovan): fix: test named alias of rune, byte.
-				switch ut_dst.Elem().(*types.Basic).Kind() {
+				switch ut_dst.Elem().Underlying().(*types.Basic).Kind() {
 				case types.Rune:
 					for _, r := range []rune(s) {
 						res = append(res, r)
diff --git a/go/ssa/interp/testdata/fixedbugs/issue55115.go b/go/ssa/interp/testdata/fixedbugs/issue55115.go
new file mode 100644
index 00000000000..0f856aeee0e
--- /dev/null
+++ b/go/ssa/interp/testdata/fixedbugs/issue55115.go
@@ -0,0 +1,38 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "reflect"
+
+func main() {
+	type MyByte byte
+	type MyRune rune
+	type MyString string
+
+	a := []MyByte{'a', 'b', 'c'}
+	if s := string(a); s != "abc" {
+		panic(s)
+	}
+
+	b := []MyRune{'五', '五'}
+	if s := string(b); s != "五五" {
+		panic(s)
+	}
+
+	c := []MyByte{'l', 'o', 'r', 'e', 'm'}
+	if s := MyString(c); s != MyString("lorem") {
+		panic(s)
+	}
+
+	d := "lorem"
+	if a := []MyByte(d); !reflect.DeepEqual(a, []MyByte{'l', 'o', 'r', 'e', 'm'}) {
+		panic(a)
+	}
+
+	e := 42
+	if s := MyString(e); s != "*" {
+		panic(s)
+	}
+}

From 675bf3c243d60cbba429fad9924e520e8a86074f Mon Sep 17 00:00:00 2001
From: Gopher Robot <gobot@golang.org>
Date: Wed, 5 Jul 2023 14:29:37 +0000
Subject: [PATCH 26/26] go.mod: update golang.org/x dependencies

Update golang.org/x dependencies to their latest tagged versions.
Once this CL is submitted, and post-submit testing succeeds on all
first-class ports across all supported Go versions, this repository
will be tagged with its next minor version.

Change-Id: Ie2c9be1584d1f27ee5d9e8c0639c1d074f4669d9
Reviewed-on: https://go-review.googlesource.com/c/tools/+/507839
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Run-TryBot: Gopher Robot <gobot@golang.org>
gopls-CI: kokoro <noreply+kokoro@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
Auto-Submit: Gopher Robot <gobot@golang.org>
---
 go.mod       |  6 +++---
 go.sum       | 18 +++++++++---------
 gopls/go.mod |  6 +++---
 gopls/go.sum | 18 +++++++++---------
 4 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/go.mod b/go.mod
index 6a8e4719268..df966e9b8eb 100644
--- a/go.mod
+++ b/go.mod
@@ -4,9 +4,9 @@ go 1.18 // tagx:compat 1.16
 
 require (
 	github.com/yuin/goldmark v1.4.13
-	golang.org/x/mod v0.11.0
-	golang.org/x/net v0.11.0
-	golang.org/x/sys v0.9.0
+	golang.org/x/mod v0.12.0
+	golang.org/x/net v0.12.0
+	golang.org/x/sys v0.10.0
 )
 
 require golang.org/x/sync v0.3.0
diff --git a/go.sum b/go.sum
index dc250710b23..50aa6b5226f 100644
--- a/go.sum
+++ b/go.sum
@@ -2,18 +2,18 @@ github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
+golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU=
-golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.11.0 h1:Gi2tvZIJyBtO9SDr1q9h5hEQCp/4L2RQ+ar0qjx2oNU=
-golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
+golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
+golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -26,19 +26,19 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
-golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
+golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
+golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
diff --git a/gopls/go.mod b/gopls/go.mod
index 10c1407351d..b3b6de4aa2b 100644
--- a/gopls/go.mod
+++ b/gopls/go.mod
@@ -7,10 +7,10 @@ require (
 	github.com/jba/printsrc v0.2.2
 	github.com/jba/templatecheck v0.6.0
 	github.com/sergi/go-diff v1.1.0
-	golang.org/x/mod v0.11.0
+	golang.org/x/mod v0.12.0
 	golang.org/x/sync v0.3.0
-	golang.org/x/sys v0.9.0
-	golang.org/x/text v0.10.0
+	golang.org/x/sys v0.10.0
+	golang.org/x/text v0.11.0
 	golang.org/x/tools v0.6.0
 	golang.org/x/vuln v0.0.0-20230110180137-6ad3e3d07815
 	gopkg.in/yaml.v3 v3.0.1
diff --git a/gopls/go.sum b/gopls/go.sum
index ef0c44020c8..a35f816f93b 100644
--- a/gopls/go.sum
+++ b/gopls/go.sum
@@ -44,7 +44,7 @@ github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJy
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
+golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
 golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e h1:+WEEuIdZHnUeJJmEUjyYC2gfUMj69yZXw17EnHg/otA=
 golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e/go.mod h1:Kr81I6Kryrl9sr8s2FK3vxD90NdsKWRuOIl2O4CvYbA=
 golang.org/x/exp/typeparams v0.0.0-20221208152030-732eee02a75a/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=
@@ -54,11 +54,11 @@ golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU=
-golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
+golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -72,15 +72,15 @@ golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
-golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
+golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
+golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58=
-golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
+golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/vuln v0.0.0-20230110180137-6ad3e3d07815 h1:A9kONVi4+AnuOr1dopsibH6hLi1Huy54cbeJxnq4vmU=
 golang.org/x/vuln v0.0.0-20230110180137-6ad3e3d07815/go.mod h1:XJiVExZgoZfrrxoTeVsFYrSSk1snhfpOEC95JL+A4T0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=