[gopls-release-branch.0.4] all: merge master in for gopls/v0.4.1

Change-Id: Icac9c3c2ee24e194b0f5e6e6f08a5b087e03268e

Author: stamblerre

cmd/goimports/goimports.go

@@ -160,7 +160,12 @@ func processFile(filename string, in io.Reader, out io.Writer, argType argumentT
 				// filename is "<standard input>"
 				return errors.New("can't use -w on stdin")
 			}
-			err = ioutil.WriteFile(filename, res, 0)
+			// On Windows, we need to re-set the permissions from the file. See golang/go#38225.
+			var perms os.FileMode
+			if fi, err := os.Stat(filename); err == nil {
+				perms = fi.Mode() & os.ModePerm
+			}
+			err = ioutil.WriteFile(filename, res, perms)
 			if err != nil {
 				return err
 			}

go/analysis/analysistest/analysistest.go

@@ -2,6 +2,7 @@
 package analysistest
 
 import (
+	"bytes"
 	"fmt"
 	"go/format"
 	"go/token"
@@ -20,8 +21,10 @@ import (
 	"golang.org/x/tools/go/analysis/internal/checker"
 	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/internal/lsp/diff"
+	"golang.org/x/tools/internal/lsp/diff/myers"
 	"golang.org/x/tools/internal/span"
 	"golang.org/x/tools/internal/testenv"
+	"golang.org/x/tools/txtar"
 )
 
 // WriteFiles is a helper function that creates a temporary directory
@@ -64,10 +67,38 @@ type Testing interface {
 	Errorf(format string, args ...interface{})
 }
 
+// RunWithSuggestedFixes behaves like Run, but additionally verifies suggested fixes.
+// It uses golden files placed alongside the source code under analysis:
+// suggested fixes for code in example.go will be compared against example.go.golden.
+//
+// Golden files can be formatted in one of two ways: as plain Go source code, or as txtar archives.
+// In the first case, all suggested fixes will be applied to the original source, which will then be compared against the golden file.
+// In the second case, suggested fixes will be grouped by their messages, and each set of fixes will be applied and tested separately.
+// Each section in the archive corresponds to a single message.
+//
+// A golden file using txtar may look like this:
+// 	-- turn into single negation --
+// 	package pkg
+//
+// 	func fn(b1, b2 bool) {
+// 		if !b1 { // want `negating a boolean twice`
+// 			println()
+// 		}
+// 	}
+//
+// 	-- remove double negation --
+// 	package pkg
+//
+// 	func fn(b1, b2 bool) {
+// 		if b1 { // want `negating a boolean twice`
+// 			println()
+// 		}
+// 	}
 func RunWithSuggestedFixes(t Testing, dir string, a *analysis.Analyzer, patterns ...string) []*Result {
 	r := Run(t, dir, a, patterns...)
 
-	fileEdits := make(map[*token.File][]diff.TextEdit)
+	// file -> message -> edits
+	fileEdits := make(map[*token.File]map[string][]diff.TextEdit)
 	fileContents := make(map[*token.File][]byte)
 
 	// Validate edits, prepare the fileEdits map and read the file contents.
@@ -100,7 +131,11 @@ func RunWithSuggestedFixes(t Testing, dir string, a *analysis.Analyzer, patterns
 					if err != nil {
 						t.Errorf("error converting edit to span %s: %v", file.Name(), err)
 					}
-					fileEdits[file] = append(fileEdits[file], diff.TextEdit{
+
+					if _, ok := fileEdits[file]; !ok {
+						fileEdits[file] = make(map[string][]diff.TextEdit)
+					}
+					fileEdits[file][sf.Message] = append(fileEdits[file][sf.Message], diff.TextEdit{
 						Span:    spn,
 						NewText: string(edit.NewText),
 					})
@@ -109,25 +144,77 @@ func RunWithSuggestedFixes(t Testing, dir string, a *analysis.Analyzer, patterns
 		}
 	}
 
-	for file, edits := range fileEdits {
+	for file, fixes := range fileEdits {
 		// Get the original file contents.
 		orig, ok := fileContents[file]
 		if !ok {
 			t.Errorf("could not find file contents for %s", file.Name())
 			continue
 		}
-		out := diff.ApplyEdits(string(orig), edits)
+
 		// Get the golden file and read the contents.
-		want, err := ioutil.ReadFile(file.Name() + ".golden")
+		ar, err := txtar.ParseFile(file.Name() + ".golden")
 		if err != nil {
 			t.Errorf("error reading %s.golden: %v", file.Name(), err)
-		}
-		formatted, err := format.Source([]byte(out))
-		if err != nil {
 			continue
 		}
-		if string(want) != string(formatted) {
-			t.Errorf("suggested fixes failed for %s, expected:\n%#v\ngot:\n%#v", file.Name(), string(want), string(formatted))
+
+		if len(ar.Files) > 0 {
+			// one virtual file per kind of suggested fix
+
+			if len(ar.Comment) != 0 {
+				// we allow either just the comment, or just virtual
+				// files, not both. it is not clear how "both" should
+				// behave.
+				t.Errorf("%s.golden has leading comment; we don't know what to do with it", file.Name())
+				continue
+			}
+
+			for sf, edits := range fixes {
+				found := false
+				for _, vf := range ar.Files {
+					if vf.Name == sf {
+						found = true
+						out := diff.ApplyEdits(string(orig), edits)
+						// the file may contain multiple trailing
+						// newlines if the user places empty lines
+						// between files in the archive. normalize
+						// this to a single newline.
+						want := string(bytes.TrimRight(vf.Data, "\n")) + "\n"
+						formatted, err := format.Source([]byte(out))
+						if err != nil {
+							continue
+						}
+						if want != string(formatted) {
+							d := myers.ComputeEdits("", want, string(formatted))
+							t.Errorf("suggested fixes failed for %s:\n%s", file.Name(), diff.ToUnified(fmt.Sprintf("%s.golden [%s]", file.Name(), sf), "actual", want, d))
+						}
+						break
+					}
+				}
+				if !found {
+					t.Errorf("no section for suggested fix %q in %s.golden", sf, file.Name())
+				}
+			}
+		} else {
+			// all suggested fixes are represented by a single file
+
+			var catchallEdits []diff.TextEdit
+			for _, edits := range fixes {
+				catchallEdits = append(catchallEdits, edits...)
+			}
+
+			out := diff.ApplyEdits(string(orig), catchallEdits)
+			want := string(ar.Comment)
+
+			formatted, err := format.Source([]byte(out))
+			if err != nil {
+				continue
+			}
+			if want != string(formatted) {
+				d := myers.ComputeEdits("", want, string(formatted))
+				t.Errorf("suggested fixes failed for %s:\n%s", file.Name(), diff.ToUnified(file.Name()+".golden", "actual", want, d))
+			}
 		}
 	}
 	return r

go/analysis/internal/analysisflags/flags.go

@@ -382,7 +382,7 @@ func (tree JSONTree) Add(fset *token.FileSet, id, name string, diags []analysis.
 func (tree JSONTree) Print() {
 	data, err := json.MarshalIndent(tree, "", "\t")
 	if err != nil {
-		log.Panicf("internal error: JSON marshalling failed: %v", err)
+		log.Panicf("internal error: JSON marshaling failed: %v", err)
 	}
 	fmt.Printf("%s\n", data)
 }

go/ast/inspector/inspector.go

@@ -150,7 +150,11 @@ func traverse(files []*ast.File) []event {
 		extent += int(f.End() - f.Pos())
 	}
 	// This estimate is based on the net/http package.
-	events := make([]event, 0, extent*33/100)
+	capacity := extent * 33 / 100
+	if capacity > 1e6 {
+		capacity = 1e6 // impose some reasonable maximum
+	}
+	events := make([]event, 0, capacity)
 
 	var stack []event
 	for _, f := range files {

go/gcexportdata/gcexportdata.go

@@ -85,15 +85,11 @@ func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package,
 		return gcimporter.ImportData(imports, path, path, bytes.NewReader(data))
 	}
 
-	// The indexed export format starts with an 'i'; the older
-	// binary export format starts with a 'c', 'd', or 'v'
-	// (from "version"). Select appropriate importer.
-	if len(data) > 0 && data[0] == 'i' {
-		_, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
-		return pkg, err
+	// The indexed export format starts with an 'i'.
+	if len(data) == 0 || data[0] != 'i' {
+		return nil, fmt.Errorf("unknown export data format")
 	}
-
-	_, pkg, err := gcimporter.BImportData(fset, imports, data, path)
+	_, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
 	return pkg, err
 }