all: merge master (7404bd2) into gopls-release-branch.0.9

Also add back the gopls/go.mod replace directive, so that tests pass.

Merge List:

+ 2022-06-27 7404bd2 all: gofmt some recent file changes
+ 2022-06-27 ec0831a refactor/satisfy: don't crash on type parameters
+ 2022-06-27 66bbba3 internal/memoize: remove unused Store.generations map
+ 2022-06-27 56116ec internal/memoize: don't destroy reference counted handles
+ 2022-06-25 10494c7 cmd/digraph: fix typo
+ 2022-06-24 93a03c2 internal/lsp/cache: invalidate reverse closure when loading packages
+ 2022-06-24 c36379b internal/lsp/cache: don't set new metadata if existing is valid
+ 2022-06-24 e1ec1f3 internal/imports: use a module resolver if GOWORK is set
+ 2022-06-24 60ca636 internal/lsp: use camel case for inlay hint config fields
+ 2022-06-24 2994e99 internal/persistent: change map to use set/get as method names
+ 2022-06-23 22ab253 internal/lsp: rename viewport to range
+ 2022-06-23 3f5f798 internal/lsp/cache: use persistent map for storing files in the snapshot
+ 2022-06-22 f60e9bc internal/lsp/cache: use persistent map for storing gofiles in the snapshot
+ 2022-06-22 871637b internal/lsp: add settings for inlay hints and enable
+ 2022-06-22 a44cc76 cmd/stringer: use explicit NeedX values instead of deprecated LoadSyntax
+ 2022-06-22 4e231cb internal/lsp/cache: don't prune unreachable metadata on clone
+ 2022-06-22 a2de635 internal/lsp/cache: honor the go.work for computing workspace packages
+ 2022-06-22 cbb8e8e internal/span: optimise URI.Filename to avoid allocation
+ 2022-06-21 63d8015 internal/lsp/cache: minor simplifications to Symbols
+ 2022-06-21 59bd4fa internal/lsp: find references to package
+ 2022-06-21 a1303c8 internal/lsp: remove tooltip from inlay hints
+ 2022-06-21 641b30b internal/lsp: add inlay hints for inferred type params
+ 2022-06-21 70ccf57 go/packages: fix loading single file when outside of GOPATH, module
+ 2022-06-17 381ac87 internal/lsp/debug: reduce critical sections in trace
+ 2022-06-17 1e14d99 internal/lsp: add inlay hints for composite literal types
+ 2022-06-16 e987015 internal/lsp/cache: symbolize in parallel
+ 2022-06-16 88325aa internal/memoize: add trace region for Handle.run

Change-Id: I7501b2d80d2f6983f6b32ae5733444f0fec52fcc

Author: findleyr

cmd/digraph/digraph.go

@@ -34,7 +34,7 @@ The support commands are:
 	sccs
 		all strongly connected components (one per line)
 	scc <node>
-		the set of nodes nodes strongly connected to the specified one
+		the set of nodes strongly connected to the specified one
 	focus <node>
 		the subgraph containing all directed paths that pass through the specified node
 

cmd/stringer/stringer.go

@@ -217,7 +217,7 @@ type Package struct {
 // parsePackage exits if there is an error.
 func (g *Generator) parsePackage(patterns []string, tags []string) {
 	cfg := &packages.Config{
-		Mode: packages.LoadSyntax,
+		Mode: packages.NeedName | packages.NeedTypes | packages.NeedTypesInfo | packages.NeedSyntax,
 		// TODO: Need to think about constants in test files. Maybe write type_string_test.go
 		// in a separate pass? For later.
 		Tests:      false,

go/packages/golist.go

@@ -302,11 +302,12 @@ func (state *golistState) runContainsQueries(response *responseDeduper, queries
 		}
 		dirResponse, err := state.createDriverResponse(pattern)
 
-		// If there was an error loading the package, or the package is returned
-		// with errors, try to load the file as an ad-hoc package.
+		// If there was an error loading the package, or no packages are returned,
+		// or the package is returned with errors, try to load the file as an
+		// ad-hoc package.
 		// Usually the error will appear in a returned package, but may not if we're
 		// in module mode and the ad-hoc is located outside a module.
-		if err != nil || len(dirResponse.Packages) == 1 && len(dirResponse.Packages[0].GoFiles) == 0 &&
+		if err != nil || len(dirResponse.Packages) == 0 || len(dirResponse.Packages) == 1 && len(dirResponse.Packages[0].GoFiles) == 0 &&
 			len(dirResponse.Packages[0].Errors) == 1 {
 			var queryErr error
 			if dirResponse, queryErr = state.adhocPackage(pattern, query); queryErr != nil {

go/packages/packages_test.go

@@ -2709,6 +2709,31 @@ func TestEmptyEnvironment(t *testing.T) {
 	}
 }
 
+func TestPackageLoadSingleFile(t *testing.T) {
+	tmp, err := ioutil.TempDir("", "a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmp)
+
+	filename := filepath.Join(tmp, "a.go")
+
+	if err := ioutil.WriteFile(filename, []byte(`package main; func main() { println("hello world") }`), 0775); err != nil {
+		t.Fatal(err)
+	}
+
+	pkgs, err := packages.Load(&packages.Config{Mode: packages.LoadSyntax, Dir: tmp}, "file="+filename)
+	if err != nil {
+		t.Fatalf("could not load package: %v", err)
+	}
+	if len(pkgs) != 1 {
+		t.Fatalf("expected one package to be loaded, got %d", len(pkgs))
+	}
+	if len(pkgs[0].CompiledGoFiles) != 1 || pkgs[0].CompiledGoFiles[0] != filename {
+		t.Fatalf("expected one compiled go file (%q), got %v", filename, pkgs[0].CompiledGoFiles)
+	}
+}
+
 func errorMessages(errors []packages.Error) []string {
 	var msgs []string
 	for _, err := range errors {

gopls/doc/generate.go

@@ -63,6 +63,9 @@ func doMain(baseDir string, write bool) (bool, error) {
 	if ok, err := rewriteFile(filepath.Join(baseDir, "gopls/doc/analyzers.md"), api, write, rewriteAnalyzers); !ok || err != nil {
 		return ok, err
 	}
+	if ok, err := rewriteFile(filepath.Join(baseDir, "gopls/doc/inlayHints.md"), api, write, rewriteInlayHints); !ok || err != nil {
+		return ok, err
+	}
 
 	return true, nil
 }
@@ -102,6 +105,7 @@ func loadAPI() (*source.APIJSON, error) {
 	} {
 		api.Analyzers = append(api.Analyzers, loadAnalyzers(m)...)
 	}
+	api.Hints = loadHints(source.AllInlayHints)
 	for _, category := range []reflect.Value{
 		reflect.ValueOf(defaults.UserOptions),
 	} {
@@ -146,6 +150,14 @@ func loadAPI() (*source.APIJSON, error) {
 						Default: def,
 					})
 				}
+			case "hints":
+				for _, a := range api.Hints {
+					opt.EnumKeys.Keys = append(opt.EnumKeys.Keys, source.EnumKey{
+						Name:    fmt.Sprintf("%q", a.Name),
+						Doc:     a.Doc,
+						Default: strconv.FormatBool(a.Default),
+					})
+				}
 			}
 		}
 	}
@@ -488,6 +500,23 @@ func loadAnalyzers(m map[string]*source.Analyzer) []*source.AnalyzerJSON {
 	return json
 }
 
+func loadHints(m map[string]*source.Hint) []*source.HintJSON {
+	var sorted []string
+	for _, h := range m {
+		sorted = append(sorted, h.Name)
+	}
+	sort.Strings(sorted)
+	var json []*source.HintJSON
+	for _, name := range sorted {
+		h := m[name]
+		json = append(json, &source.HintJSON{
+			Name: h.Name,
+			Doc:  h.Doc,
+		})
+	}
+	return json
+}
+
 func lowerFirst(x string) string {
 	if x == "" {
 		return x
@@ -699,6 +728,21 @@ func rewriteAnalyzers(doc []byte, api *source.APIJSON) ([]byte, error) {
 	return replaceSection(doc, "Analyzers", section.Bytes())
 }
 
+func rewriteInlayHints(doc []byte, api *source.APIJSON) ([]byte, error) {
+	section := bytes.NewBuffer(nil)
+	for _, hint := range api.Hints {
+		fmt.Fprintf(section, "## **%v**\n\n", hint.Name)
+		fmt.Fprintf(section, "%s\n\n", hint.Doc)
+		switch hint.Default {
+		case true:
+			fmt.Fprintf(section, "**Enabled by default.**\n\n")
+		case false:
+			fmt.Fprintf(section, "**Disabled by default. Enable it by setting `\"hints\": {\"%s\": true}`.**\n\n", hint.Name)
+		}
+	}
+	return replaceSection(doc, "Hints", section.Bytes())
+}
+
 func replaceSection(doc []byte, sectionName string, replacement []byte) ([]byte, error) {
 	re := regexp.MustCompile(fmt.Sprintf(`(?s)<!-- BEGIN %v.* -->\n(.*?)<!-- END %v.* -->`, sectionName, sectionName))
 	idx := re.FindSubmatchIndex(doc)

gopls/doc/inlayHints.md

@@ -0,0 +1,73 @@
+# Hints
+
+This document describes the inlay hints that `gopls` uses inside the editor.
+
+<!-- BEGIN Hints: DO NOT MANUALLY EDIT THIS SECTION -->
+## **assignVariableTypes**
+
+Enable/disable inlay hints for variable types in assign statements:
+
+	i/* int/*, j/* int/* := 0, len(r)-1
+
+**Disabled by default. Enable it by setting `"hints": {"assignVariableTypes": true}`.**
+
+## **compositeLiteralFields**
+
+Enable/disable inlay hints for composite literal field names:
+
+	{in: "Hello, world", want: "dlrow ,olleH"}
+
+**Disabled by default. Enable it by setting `"hints": {"compositeLiteralFields": true}`.**
+
+## **compositeLiteralTypes**
+
+Enable/disable inlay hints for composite literal types:
+
+	for _, c := range []struct {
+		in, want string
+	}{
+		/*struct{ in string; want string }*/{"Hello, world", "dlrow ,olleH"},
+	}
+
+**Disabled by default. Enable it by setting `"hints": {"compositeLiteralTypes": true}`.**
+
+## **constantValues**
+
+Enable/disable inlay hints for constant values:
+
+	const (
+		KindNone   Kind = iota/* = 0*/
+		KindPrint/*  = 1*/
+		KindPrintf/* = 2*/
+		KindErrorf/* = 3*/
+	)
+
+**Disabled by default. Enable it by setting `"hints": {"constantValues": true}`.**
+
+## **functionTypeParameters**
+
+Enable/disable inlay hints for implicit type parameters on generic functions:
+
+	myFoo/*[int, string]*/(1, "hello")
+
+**Disabled by default. Enable it by setting `"hints": {"functionTypeParameters": true}`.**
+
+## **parameterNames**
+
+Enable/disable inlay hints for parameter names:
+
+	parseInt(/* str: */ "123", /* radix: */ 8)
+
+**Disabled by default. Enable it by setting `"hints": {"parameterNames": true}`.**
+
+## **rangeVariableTypes**
+
+Enable/disable inlay hints for variable types in range statements:
+
+	for k/* int*/, v/* string/* := range []string{} {
+		fmt.Println(k, v)
+	}
+
+**Disabled by default. Enable it by setting `"hints": {"rangeVariableTypes": true}`.**
+
+<!-- END Hints: DO NOT MANUALLY EDIT THIS SECTION -->

gopls/doc/settings.md

@@ -35,6 +35,7 @@ still be able to independently override specific experimental features.
   * [Completion](#completion)
   * [Diagnostic](#diagnostic)
   * [Documentation](#documentation)
+  * [Inlayhint](#inlayhint)
   * [Navigation](#navigation)
 
 ### Build
@@ -370,6 +371,18 @@ linksInHover toggles the presence of links to documentation in hover.
 
 Default: `true`.
 
+#### Inlayhint
+
+##### **hints** *map[string]bool*
+
+**This setting is experimental and may be deleted.**
+
+hints specify inlay hints that users want to see.
+A full list of hints that gopls uses can be found
+[here](https://github.com/golang/tools/blob/master/gopls/doc/inlayHints.md).
+
+Default: `{}`.
+
 #### Navigation
 
 ##### **importShortcut** *enum*

gopls/go.mod

@@ -24,3 +24,5 @@ require (
 	golang.org/x/text v0.3.7 // indirect
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )
+
+replace golang.org/x/tools => ../

gopls/internal/regtest/misc/imports_test.go

@@ -214,3 +214,49 @@ func TestA(t *testing.T) {
 		)
 	})
 }
+
+// Test for golang/go#52784
+func TestGoWorkImports(t *testing.T) {
+	testenv.NeedsGo1Point(t, 18)
+	const pkg = `
+-- go.work --
+go 1.19
+
+use (
+        ./caller
+        ./mod
+)
+-- caller/go.mod --
+module caller.com
+
+go 1.18
+
+require mod.com v0.0.0
+
+replace mod.com => ../mod
+-- caller/caller.go --
+package main
+
+func main() {
+        a.Test()
+}
+-- mod/go.mod --
+module mod.com
+
+go 1.18
+-- mod/a/a.go --
+package a
+
+func Test() {
+}
+`
+	Run(t, pkg, func(t *testing.T, env *Env) {
+		env.OpenFile("caller/caller.go")
+		env.Await(env.DiagnosticAtRegexp("caller/caller.go", "a.Test"))
+
+		// Saving caller.go should trigger goimports, which should find a.Test in
+		// the mod.com module, thanks to the go.work file.
+		env.SaveBuffer("caller/caller.go")
+		env.Await(EmptyDiagnostics("caller/caller.go"))
+	})
+}