[gopls-release-branch.0.6] all: merge master into gopls-release-branch.0.6

11e8f6b internal/lsp: refactor codeAction
1523bb4 internal/lsp: fix time.Duration hover name check
bcb2d7b internal/lsp: fix bad completion for variadic functions
7ee2955 internal/lsp/cache: refactor and improve go get quick fixes
1e524e2 internal/lsp/source: add the nilness analyzer
d34cf35 internal/lsp/source: return nil for foldingRange in case of parse error
c5f5f4b gopls/doc: clarify how to set remote.listen.timeout
3e1cb95 internal/lsp/source: correct workspace symbol logic for unpacking receivers
397283d internal/lsp/protocol/typescript: fix lint errors in .ts code
d19d8cf internal/lsp/protocol/typecript: fix type merging
50ca8d0 all: recognize new error from go command when no go.mod is found
2cde57b internal/lsp: remove redundant didChange notifications
376db57 internal/lsp: use pre-existing quick fixes for analysis diagnostics
144d5ce internal/lsp: run type error analyzers as part of diagnostics
24439e3 internal/lsp/source: eliminate GetTypeCheckDiagnostics
dafbee5 internal/lsp: show human-readable const time.Duration as a comment
9c452d8 internal/lsp/cache: don't rely on related diagnostics if unsupported
2ac05c8 internal/lsp: key GC details off package ID
303d8bb gopls/internal/hooks: compile URL regexp once
94327d3 internal/lsp/cache: show type errors on parse errors in other files
16b2c87 gopls/internal/regtest: add a failing test for issue 44736
7800253 internal/lsp/cache: split up sourceDiagnostics
47985cf internal/lsp/cache: refactor Go file parsing
6422c5c internal/lsp/cache: invalidate metadata on magic comment changes
f9c628b gopls/internal/regtest: add test for bad embed rules
89a9cb6 internal/lsp/cache: parse filenames from go list errors correctly
eb48d3f internal/lsp/cache: refactor diagnostic suppression
7a079fc internal/lsp/cache: fix related error processing
f5a4005 cmd/eg: don't do rewrites within the template file itself
28e7a3b cmd/eg: use go/packages
54dc8c5 playground: remove /share registration, add Proxy
24aca17 cmd/guru: adjust describe qualifier function (fix describe test)
0150491 x/tools/internal/fastwalk: fixes "interrupted system call" error
b4639cc internal/lsp/protocol: fix vet error in tsprotocol.go
a43f69b go/expect: use parser.AllErrors when extracting Notes
f48e60b add comment and check action type neovim goimports
b8d1a33 internal/lsp/source: add the unusedwrite analyzer

Change-Id: I3bf12fb1e4a6431ea32e879774dd6c5e525b1ff1

Author: stamblerre

cmd/eg/eg.go

@@ -10,16 +10,18 @@ package main // import "golang.org/x/tools/cmd/eg"
 import (
 	"flag"
 	"fmt"
-	"go/build"
+	"go/ast"
 	"go/format"
 	"go/parser"
 	"go/token"
-	exec "golang.org/x/sys/execabs"
+	"go/types"
+	"io/ioutil"
 	"os"
+	"path/filepath"
 	"strings"
 
-	"golang.org/x/tools/go/buildutil"
-	"golang.org/x/tools/go/loader"
+	exec "golang.org/x/sys/execabs"
+	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/refactor/eg"
 )
 
@@ -32,13 +34,9 @@ var (
 	verboseFlag    = flag.Bool("v", false, "show verbose matcher diagnostics")
 )
 
-func init() {
-	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
-}
-
 const usage = `eg: an example-based refactoring tool.
 
-Usage: eg -t template.go [-w] [-transitive] <args>...
+Usage: eg -t template.go [-w] [-transitive] <packages>
 
 -help            show detailed help message
 -t template.go	 specifies the template file (use -help to see explanation)
@@ -47,7 +45,7 @@ Usage: eg -t template.go [-w] [-transitive] <args>...
 -v               show verbose matcher diagnostics
 -beforeedit cmd  a command to exec before each file is modified.
                  "{}" represents the name of the file.
-` + loader.FromArgsUsage
+`
 
 func main() {
 	if err := doMain(); err != nil {
@@ -74,51 +72,73 @@ func doMain() error {
 		return fmt.Errorf("no -t template.go file specified")
 	}
 
-	conf := loader.Config{
-		Fset:       token.NewFileSet(),
-		ParserMode: parser.ParseComments,
+	tAbs, err := filepath.Abs(*templateFlag)
+	if err != nil {
+		return err
+	}
+	template, err := ioutil.ReadFile(tAbs)
+	if err != nil {
+		return err
 	}
 
-	// The first Created package is the template.
-	conf.CreateFromFilenames("template", *templateFlag)
+	cfg := &packages.Config{
+		Fset:  token.NewFileSet(),
+		Mode:  packages.NeedTypesInfo | packages.NeedName | packages.NeedTypes | packages.NeedSyntax | packages.NeedImports | packages.NeedDeps | packages.NeedCompiledGoFiles,
+		Tests: true,
+	}
 
-	if _, err := conf.FromArgs(args, true); err != nil {
+	pkgs, err := packages.Load(cfg, args...)
+	if err != nil {
 		return err
 	}
 
-	// Load, parse and type-check the whole program.
-	iprog, err := conf.Load()
+	tFile, err := parser.ParseFile(cfg.Fset, tAbs, template, parser.ParseComments)
+	if err != nil {
+		return err
+	}
+
+	// Type-check the template.
+	tInfo := types.Info{
+		Types:      make(map[ast.Expr]types.TypeAndValue),
+		Defs:       make(map[*ast.Ident]types.Object),
+		Uses:       make(map[*ast.Ident]types.Object),
+		Implicits:  make(map[ast.Node]types.Object),
+		Selections: make(map[*ast.SelectorExpr]*types.Selection),
+		Scopes:     make(map[ast.Node]*types.Scope),
+	}
+	conf := types.Config{
+		Importer: pkgsImporter(pkgs),
+	}
+	tPkg, err := conf.Check("egtemplate", cfg.Fset, []*ast.File{tFile}, &tInfo)
 	if err != nil {
 		return err
 	}
 
 	// Analyze the template.
-	template := iprog.Created[0]
-	xform, err := eg.NewTransformer(iprog.Fset, template.Pkg, template.Files[0], &template.Info, *verboseFlag)
+	xform, err := eg.NewTransformer(cfg.Fset, tPkg, tFile, &tInfo, *verboseFlag)
 	if err != nil {
 		return err
 	}
 
 	// Apply it to the input packages.
-	var pkgs []*loader.PackageInfo
+	var all []*packages.Package
 	if *transitiveFlag {
-		for _, info := range iprog.AllPackages {
-			pkgs = append(pkgs, info)
-		}
+		packages.Visit(pkgs, nil, func(p *packages.Package) { all = append(all, p) })
 	} else {
-		pkgs = iprog.InitialPackages()
+		all = pkgs
 	}
 	var hadErrors bool
 	for _, pkg := range pkgs {
-		if pkg == template {
-			continue
-		}
-		for _, file := range pkg.Files {
-			n := xform.Transform(&pkg.Info, pkg.Pkg, file)
+		for i, filename := range pkg.CompiledGoFiles {
+			if filename == tAbs {
+				// Don't rewrite the template file.
+				continue
+			}
+			file := pkg.Syntax[i]
+			n := xform.Transform(pkg.TypesInfo, pkg.Types, file)
 			if n == 0 {
 				continue
 			}
-			filename := iprog.Fset.File(file.Pos()).Name()
 			fmt.Fprintf(os.Stderr, "=== %s (%d matches)\n", filename, n)
 			if *writeFlag {
 				// Run the before-edit command (e.g. "chmod +w",  "checkout") if any.
@@ -138,17 +158,34 @@ func doMain() error {
 							args, err)
 					}
 				}
-				if err := eg.WriteAST(iprog.Fset, filename, file); err != nil {
+				if err := eg.WriteAST(cfg.Fset, filename, file); err != nil {
 					fmt.Fprintf(os.Stderr, "eg: %s\n", err)
 					hadErrors = true
 				}
 			} else {
-				format.Node(os.Stdout, iprog.Fset, file)
+				format.Node(os.Stdout, cfg.Fset, file)
 			}
 		}
 	}
 	if hadErrors {
 		os.Exit(1)
 	}
+
 	return nil
 }
+
+type pkgsImporter []*packages.Package
+
+func (p pkgsImporter) Import(path string) (tpkg *types.Package, err error) {
+	packages.Visit([]*packages.Package(p), func(pkg *packages.Package) bool {
+		if pkg.PkgPath == path {
+			tpkg = pkg.Types
+			return false
+		}
+		return true
+	}, nil)
+	if tpkg != nil {
+		return tpkg, nil
+	}
+	return nil, fmt.Errorf("package %q not found", path)
+}

cmd/godoc/handlers.go

@@ -14,11 +14,9 @@ import (
 	"golang.org/x/tools/godoc"
 	"golang.org/x/tools/godoc/redirect"
 	"golang.org/x/tools/godoc/vfs"
-)
 
-// This package registers "/compile" and "/share" handlers
-// that redirect to the golang.org playground.
-import _ "golang.org/x/tools/playground"
+	_ "golang.org/x/tools/playground" // register "/compile" playground redirect
+)
 
 var (
 	pres *godoc.Presentation

cmd/guru/describe.go

@@ -738,6 +738,22 @@ func formatMember(obj types.Object, maxname int) string {
 			}
 		}
 		if typestr == "" {
+			// The fix for #44515 changed the printing of unsafe.Pointer
+			// such that it uses a qualifier if one is provided. Using
+			// the types.RelativeTo qualifier provided here, the output
+			// is just "Pointer" rather than "unsafe.Pointer". This is
+			// consistent with the printing of non-type objects but it
+			// breaks an existing test which needs to work with older
+			// versions of Go. Re-establish the original output by not
+			// using a qualifier at all if we're printing a type from
+			// package unsafe - there's only unsafe.Pointer (#44596).
+			// NOTE: This correction can be removed (and the test's
+			// golden file adjusted) once we only run against go1.17
+			// or bigger.
+			qualifier := qualifier
+			if obj.Pkg() == types.Unsafe {
+				qualifier = nil
+			}
 			typestr = types.TypeString(typ, qualifier)
 		}
 		buf.WriteString(typestr)

cmd/present/play.go

@@ -18,7 +18,7 @@ import (
 	"golang.org/x/tools/playground/socket"
 	"golang.org/x/tools/present"
 
-	// This will register handlers at /compile and /share that will proxy to the
+	// This will register a handler at /compile that will proxy to the
 	// respective endpoints at play.golang.org. This allows the frontend to call
 	// these endpoints without needing cross-origin request sharing (CORS).
 	// Note that this is imported regardless of whether the endpoints are used or

go/expect/extract.go

@@ -42,7 +42,7 @@ func Parse(fset *token.FileSet, filename string, content []byte) ([]*Note, error
 		// there are ways you can break the parser such that it will not add all the
 		// comments to the ast, which may result in files where the tests are silently
 		// not run.
-		file, err := parser.ParseFile(fset, filename, src, parser.ParseComments)
+		file, err := parser.ParseFile(fset, filename, src, parser.ParseComments|parser.AllErrors)
 		if file == nil {
 			return nil, err
 		}

go/internal/packagesdriver/sizes.go

@@ -22,7 +22,7 @@ func GetSizesGolist(ctx context.Context, inv gocommand.Invocation, gocmdRunner *
 	stdout, stderr, friendlyErr, rawErr := gocmdRunner.RunRaw(ctx, inv)
 	var goarch, compiler string
 	if rawErr != nil {
-		if strings.Contains(rawErr.Error(), "cannot find main module") {
+		if rawErrMsg := rawErr.Error(); strings.Contains(rawErrMsg, "cannot find main module") || strings.Contains(rawErrMsg, "go.mod file not found") {
 			// User's running outside of a module. All bets are off. Get GOARCH and guess compiler is gc.
 			// TODO(matloob): Is this a problem in practice?
 			inv.Verb = "env"

go/packages/golist.go

@@ -584,7 +584,7 @@ func (state *golistState) createDriverResponse(words ...string) (*driverResponse
 				// golang/go#38990: go list silently fails to do cgo processing
 				pkg.CompiledGoFiles = nil
 				pkg.Errors = append(pkg.Errors, Error{
-					Msg:  "go list failed to return CompiledGoFiles; https://golang.org/issue/38990?",
+					Msg:  "go list failed to return CompiledGoFiles. This may indicate failure to perform cgo processing; try building at the command line. See https://golang.org/issue/38990.",
 					Kind: ListError,
 				})
 			}

godoc/static/playground.js

@@ -517,7 +517,7 @@ function PlaygroundOutput(el) {
       sharing = true;
 
       var sharingData = body();
-      $.ajax('/share', {
+      $.ajax('https://play.golang.org/share', {
         processData: false,
         data: sharingData,
         type: 'POST',

godoc/static/static.go

@@ -208,6 +208,46 @@ A useless comparison is one like f == nil as opposed to f() == nil.
 
 **Enabled by default.**
 
+## **nilness**
+
+check for redundant or impossible nil comparisons
+
+The nilness checker inspects the control-flow graph of each function in
+a package and reports nil pointer dereferences, degenerate nil
+pointers, and panics with nil values. A degenerate comparison is of the form
+x==nil or x!=nil where x is statically known to be nil or non-nil. These are
+often a mistake, especially in control flow related to errors. Panics with nil
+values are checked because they are not detectable by
+
+	if r := recover(); r != nil {
+
+This check reports conditions such as:
+
+	if f == nil { // impossible condition (f is a function)
+	}
+
+and:
+
+	p := &v
+	...
+	if p != nil { // tautological condition
+	}
+
+and:
+
+	if p == nil {
+		print(*p) // nil dereference
+	}
+
+and:
+
+	if p == nil {
+		panic(p)
+	}
+
+
+**Disabled by default. Enable it by setting `"analyses": {"nilness": true}`.**
+
 ## **printf**
 
 check consistency of Printf format strings and arguments
@@ -468,6 +508,35 @@ The set of functions may be controlled using flags.
 
 **Enabled by default.**
 
+## **unusedwrite**
+
+checks for unused writes
+
+The analyzer reports instances of writes to struct fields and
+arrays that are never read. Specifically, when a struct object
+or an array is copied, its elements are copied implicitly by
+the compiler, and any element write to this copy does nothing
+with the original object.
+
+For example:
+
+	type T struct { x int }
+	func f(input []T) {
+		for i, v := range input {  // v is a copy
+			v.x = i  // unused write to field x
+		}
+	}
+
+Another example is about non-pointer receiver:
+
+	type T struct { x int }
+	func (t T) f() {  // t is a copy
+		t.x = i  // unused write to field x
+	}
+
+
+**Disabled by default. Enable it by setting `"analyses": {"unusedwrite": true}`.**
+
 ## **fillreturns**
 
 suggested fixes for "wrong number of return values (want %d, got %d)"