go.mod, vendor: update (#3358)

* go.mod, vendor: remove unnecessary dependencies

Commands:
1. go mod tidy
2. go mod vendor

* go.mod, vendor: update cloud.google.com/go

Commands:
1. go get -u cloud.google.com/go
2. go mod tidy
3. go mod vendor

* go.mod, vendor: update cloud.google.com/*

Commands:
1. go get -u cloud.google.com/storage cloud.google.com/logging
2. go mod tidy
3. go mod vendor

* go.mod, .golangci.yml, vendor: update *lint*

Commands:
1. go get -u golang.org/x/tools github.com/golangci/golangci-lint@v1.47.0
2. go mod tidy
3. go mod vendor
4. edit .golangci.yml to suppress new errors (resolved in the same PR later)

* all: fix lint errors

hash.go: copy() recommended by gosimple
parse.go: ent is never nil
verifier.go: signal.Notify() with unbuffered channel is bad. Have no idea why.

* .golangci.yml: adjust godot rules

check-all is deprecated, but still work
if you're hesitating too - I'll remove this commit

3 files changed, 0 insertions, 645 deletions

diff --git a/vendor/github.com/golangci/errcheck/LICENSE b/vendor/github.com/golangci/errcheck/LICENSE
deleted file mode 100644
index a2b16b5bd..000000000
--- a/vendor/github.com/golangci/errcheck/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-Copyright (c) 2013 Kamil Kisiel
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/golangci/errcheck/golangci/golangci.go b/vendor/github.com/golangci/errcheck/golangci/golangci.go
deleted file mode 100644
index 1095adeb4..000000000
--- a/vendor/github.com/golangci/errcheck/golangci/golangci.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package golangci
-
-import (
-	"regexp"
-
-	"github.com/golangci/errcheck/internal/errcheck"
-	"golang.org/x/tools/go/loader"
-)
-
-var dotStar = regexp.MustCompile(".*")
-
-type Issue errcheck.UncheckedError
-
-func Run(program *loader.Program, checkBlank, checkAsserts bool) ([]Issue, error) {
-	return RunWithConfig(program, &Config{
-		Blank:   checkBlank,
-		Asserts: checkAsserts,
-	})
-}
-
-// Config is a copy of the `errcheck.Checker` with exported `Exclude` field.
-type Config struct {
-	// ignore is a map of package names to regular expressions. Identifiers from a package are
-	// checked against its regular expressions and if any of the expressions match the call
-	// is not checked.
-	Ignore map[string]*regexp.Regexp
-
-	// If blank is true then assignments to the blank identifier are also considered to be
-	// ignored errors.
-	Blank bool
-
-	// If asserts is true then ignored type assertion results are also checked
-	Asserts bool
-
-	// build tags
-	Tags []string
-
-	Verbose bool
-
-	// If true, checking of _test.go files is disabled
-	WithoutTests bool
-
-	// Excluded functions.
-	Exclude map[string]bool
-}
-
-// RunWithConfig runs the `errchecker` linter with all its options.
-func RunWithConfig(program *loader.Program, c *Config) ([]Issue, error) {
-	checker := errcheck.NewChecker()
-	checker.Tags = c.Tags
-	checker.Blank = c.Blank
-	checker.Asserts = c.Asserts
-	checker.Verbose = c.Verbose
-	checker.WithoutTests = c.WithoutTests
-
-	checker.SetExclude(c.Exclude)
-
-	checker.Ignore = map[string]*regexp.Regexp{}
-	for pkg, re := range c.Ignore {
-		checker.Ignore[pkg] = re
-	}
-
-	if err := checker.CheckProgram(program); err != nil {
-		if e, ok := err.(*errcheck.UncheckedErrors); ok {
-			return makeIssues(e), nil
-		}
-		if err == errcheck.ErrNoGoFiles {
-			return nil, nil
-		}
-
-		return nil, err
-	}
-
-	// no issues
-	return nil, nil
-}
-
-func makeIssues(e *errcheck.UncheckedErrors) []Issue {
-	var ret []Issue
-	for _, uncheckedError := range e.Errors {
-		ret = append(ret, Issue(uncheckedError))
-	}
-
-	return ret
-}
diff --git a/vendor/github.com/golangci/errcheck/internal/errcheck/errcheck.go b/vendor/github.com/golangci/errcheck/internal/errcheck/errcheck.go
deleted file mode 100644
index 2a698fcee..000000000
--- a/vendor/github.com/golangci/errcheck/internal/errcheck/errcheck.go
+++ /dev/null
@@ -1,538 +0,0 @@
-// Package errcheck is the library used to implement the errcheck command-line tool.
-//
-// Note: The API of this package has not been finalized and may change at any point.
-package errcheck
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"go/ast"
-	"go/build"
-	"go/token"
-	"go/types"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-	"sync"
-
-	"golang.org/x/tools/go/loader"
-)
-
-var errorType *types.Interface
-
-func init() {
-	errorType = types.Universe.Lookup("error").Type().Underlying().(*types.Interface)
-
-}
-
-var (
-	// ErrNoGoFiles is returned when CheckPackage is run on a package with no Go source files
-	ErrNoGoFiles = errors.New("package contains no go source files")
-)
-
-// UncheckedError indicates the position of an unchecked error return.
-type UncheckedError struct {
-	Pos      token.Position
-	Line     string
-	FuncName string
-}
-
-// UncheckedErrors is returned from the CheckPackage function if the package contains
-// any unchecked errors.
-// Errors should be appended using the Append method, which is safe to use concurrently.
-type UncheckedErrors struct {
-	mu sync.Mutex
-
-	// Errors is a list of all the unchecked errors in the package.
-	// Printing an error reports its position within the file and the contents of the line.
-	Errors []UncheckedError
-}
-
-func (e *UncheckedErrors) Append(errors ...UncheckedError) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	e.Errors = append(e.Errors, errors...)
-}
-
-func (e *UncheckedErrors) Error() string {
-	return fmt.Sprintf("%d unchecked errors", len(e.Errors))
-}
-
-// Len is the number of elements in the collection.
-func (e *UncheckedErrors) Len() int { return len(e.Errors) }
-
-// Swap swaps the elements with indexes i and j.
-func (e *UncheckedErrors) Swap(i, j int) { e.Errors[i], e.Errors[j] = e.Errors[j], e.Errors[i] }
-
-type byName struct{ *UncheckedErrors }
-
-// Less reports whether the element with index i should sort before the element with index j.
-func (e byName) Less(i, j int) bool {
-	ei, ej := e.Errors[i], e.Errors[j]
-
-	pi, pj := ei.Pos, ej.Pos
-
-	if pi.Filename != pj.Filename {
-		return pi.Filename < pj.Filename
-	}
-	if pi.Line != pj.Line {
-		return pi.Line < pj.Line
-	}
-	if pi.Column != pj.Column {
-		return pi.Column < pj.Column
-	}
-
-	return ei.Line < ej.Line
-}
-
-type Checker struct {
-	// ignore is a map of package names to regular expressions. Identifiers from a package are
-	// checked against its regular expressions and if any of the expressions match the call
-	// is not checked.
-	Ignore map[string]*regexp.Regexp
-
-	// If blank is true then assignments to the blank identifier are also considered to be
-	// ignored errors.
-	Blank bool
-
-	// If asserts is true then ignored type assertion results are also checked
-	Asserts bool
-
-	// build tags
-	Tags []string
-
-	Verbose bool
-
-	// If true, checking of _test.go files is disabled
-	WithoutTests bool
-
-	exclude map[string]bool
-}
-
-func NewChecker() *Checker {
-	c := Checker{}
-	c.SetExclude(map[string]bool{})
-	return &c
-}
-
-func (c *Checker) SetExclude(l map[string]bool) {
-	// Default exclude for stdlib functions
-	c.exclude = map[string]bool{
-		"math/rand.Read":         true,
-		"(*math/rand.Rand).Read": true,
-
-		"(*bytes.Buffer).Write":       true,
-		"(*bytes.Buffer).WriteByte":   true,
-		"(*bytes.Buffer).WriteRune":   true,
-		"(*bytes.Buffer).WriteString": true,
-
-		"(*strings.Builder).Write":       true,
-		"(*strings.Builder).WriteByte":   true,
-		"(*strings.Builder).WriteRune":   true,
-		"(*strings.Builder).WriteString": true,
-	}
-	for k := range l {
-		c.exclude[k] = true
-	}
-}
-
-func (c *Checker) logf(msg string, args ...interface{}) {
-	if c.Verbose {
-		fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	}
-}
-
-func (c *Checker) load(paths ...string) (*loader.Program, error) {
-	ctx := build.Default
-	for _, tag := range c.Tags {
-		ctx.BuildTags = append(ctx.BuildTags, tag)
-	}
-	loadcfg := loader.Config{
-		Build: &ctx,
-	}
-	rest, err := loadcfg.FromArgs(paths, !c.WithoutTests)
-	if err != nil {
-		return nil, fmt.Errorf("could not parse arguments: %s", err)
-	}
-	if len(rest) > 0 {
-		return nil, fmt.Errorf("unhandled extra arguments: %v", rest)
-	}
-
-	return loadcfg.Load()
-}
-
-func (c *Checker) CheckProgram(program *loader.Program) error {
-	var wg sync.WaitGroup
-	u := &UncheckedErrors{}
-	for _, pkgInfo := range program.InitialPackages() {
-		if pkgInfo.Pkg.Path() == "unsafe" { // not a real package
-			continue
-		}
-
-		wg.Add(1)
-
-		go func(pkgInfo *loader.PackageInfo) {
-			defer wg.Done()
-			c.logf("Checking %s", pkgInfo.Pkg.Path())
-
-			v := &visitor{
-				prog:    program,
-				pkg:     pkgInfo,
-				ignore:  c.Ignore,
-				blank:   c.Blank,
-				asserts: c.Asserts,
-				lines:   make(map[string][]string),
-				exclude: c.exclude,
-				errors:  []UncheckedError{},
-			}
-
-			for _, astFile := range v.pkg.Files {
-				ast.Walk(v, astFile)
-			}
-			u.Append(v.errors...)
-		}(pkgInfo)
-	}
-
-	wg.Wait()
-	if u.Len() > 0 {
-		sort.Sort(byName{u})
-		return u
-	}
-	return nil
-}
-
-// CheckPackages checks packages for errors.
-func (c *Checker) CheckPackages(paths ...string) error {
-	program, err := c.load(paths...)
-	if err != nil {
-		return fmt.Errorf("could not type check: %s", err)
-	}
-
-	return c.CheckProgram(program)
-}
-
-// visitor implements the errcheck algorithm
-type visitor struct {
-	prog    *loader.Program
-	pkg     *loader.PackageInfo
-	ignore  map[string]*regexp.Regexp
-	blank   bool
-	asserts bool
-	lines   map[string][]string
-	exclude map[string]bool
-
-	errors []UncheckedError
-}
-
-func getSelName(sel *ast.SelectorExpr) string {
-	if ident, ok := sel.X.(*ast.Ident); ok {
-		return fmt.Sprintf("%s.%s", ident.Name, sel.Sel.Name)
-	}
-
-	if s, ok := sel.X.(*ast.SelectorExpr); ok {
-		return fmt.Sprintf("%s.%s", getSelName(s), sel.Sel.Name)
-	}
-
-	return ""
-}
-
-func (v *visitor) fullNameForPrinting(call *ast.CallExpr) (string, bool) {
-	if ident, ok := call.Fun.(*ast.Ident); ok {
-		return ident.Name, true
-	}
-
-	sel, ok := call.Fun.(*ast.SelectorExpr)
-	if !ok {
-		return "", false
-	}
-
-	name := getSelName(sel)
-	if name != "" {
-		return name, true
-	}
-
-	fn, ok := v.pkg.ObjectOf(sel.Sel).(*types.Func)
-	if !ok {
-		// Shouldn't happen, but be paranoid
-		return "", false
-	}
-	// The name is fully qualified by the import path, possible type,
-	// function/method name and pointer receiver.
-	//
-	// TODO(dh): vendored packages will have /vendor/ in their name,
-	// thus not matching vendored standard library packages. If we
-	// want to support vendored stdlib packages, we need to implement
-	// FullName with our own logic.
-	return fn.FullName(), true
-}
-
-func (v *visitor) fullName(call *ast.CallExpr) (string, bool) {
-	if ident, ok := call.Fun.(*ast.Ident); ok {
-		return ident.Name, true
-	}
-
-	sel, ok := call.Fun.(*ast.SelectorExpr)
-	if !ok {
-		return "", false
-	}
-
-	fn, ok := v.pkg.ObjectOf(sel.Sel).(*types.Func)
-	if !ok {
-		// Shouldn't happen, but be paranoid
-		return "", false
-	}
-	// The name is fully qualified by the import path, possible type,
-	// function/method name and pointer receiver.
-	//
-	// TODO(dh): vendored packages will have /vendor/ in their name,
-	// thus not matching vendored standard library packages. If we
-	// want to support vendored stdlib packages, we need to implement
-	// FullName with our own logic.
-	return fn.FullName(), true
-}
-
-func (v *visitor) excludeCall(call *ast.CallExpr) bool {
-	if name, ok := v.fullName(call); ok {
-		return v.exclude[name]
-	}
-
-	return false
-}
-
-func (v *visitor) ignoreCall(call *ast.CallExpr) bool {
-	if v.excludeCall(call) {
-		return true
-	}
-
-	// Try to get an identifier.
-	// Currently only supports simple expressions:
-	//     1. f()
-	//     2. x.y.f()
-	var id *ast.Ident
-	switch exp := call.Fun.(type) {
-	case (*ast.Ident):
-		id = exp
-	case (*ast.SelectorExpr):
-		id = exp.Sel
-	default:
-		// eg: *ast.SliceExpr, *ast.IndexExpr
-	}
-
-	if id == nil {
-		return false
-	}
-
-	// If we got an identifier for the function, see if it is ignored
-	if re, ok := v.ignore[""]; ok && re.MatchString(id.Name) {
-		return true
-	}
-
-	if obj := v.pkg.Uses[id]; obj != nil {
-		if pkg := obj.Pkg(); pkg != nil {
-			if re, ok := v.ignore[pkg.Path()]; ok {
-				return re.MatchString(id.Name)
-			}
-
-			// if current package being considered is vendored, check to see if it should be ignored based
-			// on the unvendored path.
-			if nonVendoredPkg, ok := nonVendoredPkgPath(pkg.Path()); ok {
-				if re, ok := v.ignore[nonVendoredPkg]; ok {
-					return re.MatchString(id.Name)
-				}
-			}
-		}
-	}
-
-	return false
-}
-
-// nonVendoredPkgPath returns the unvendored version of the provided package path (or returns the provided path if it
-// does not represent a vendored path). The second return value is true if the provided package was vendored, false
-// otherwise.
-func nonVendoredPkgPath(pkgPath string) (string, bool) {
-	lastVendorIndex := strings.LastIndex(pkgPath, "/vendor/")
-	if lastVendorIndex == -1 {
-		return pkgPath, false
-	}
-	return pkgPath[lastVendorIndex+len("/vendor/"):], true
-}
-
-// errorsByArg returns a slice s such that
-// len(s) == number of return types of call
-// s[i] == true iff return type at position i from left is an error type
-func (v *visitor) errorsByArg(call *ast.CallExpr) []bool {
-	switch t := v.pkg.Types[call].Type.(type) {
-	case *types.Named:
-		// Single return
-		return []bool{isErrorType(t)}
-	case *types.Pointer:
-		// Single return via pointer
-		return []bool{isErrorType(t)}
-	case *types.Tuple:
-		// Multiple returns
-		s := make([]bool, t.Len())
-		for i := 0; i < t.Len(); i++ {
-			switch et := t.At(i).Type().(type) {
-			case *types.Named:
-				// Single return
-				s[i] = isErrorType(et)
-			case *types.Pointer:
-				// Single return via pointer
-				s[i] = isErrorType(et)
-			default:
-				s[i] = false
-			}
-		}
-		return s
-	}
-	return []bool{false}
-}
-
-func (v *visitor) callReturnsError(call *ast.CallExpr) bool {
-	if v.isRecover(call) {
-		return true
-	}
-	for _, isError := range v.errorsByArg(call) {
-		if isError {
-			return true
-		}
-	}
-	return false
-}
-
-// isRecover returns true if the given CallExpr is a call to the built-in recover() function.
-func (v *visitor) isRecover(call *ast.CallExpr) bool {
-	if fun, ok := call.Fun.(*ast.Ident); ok {
-		if _, ok := v.pkg.Uses[fun].(*types.Builtin); ok {
-			return fun.Name == "recover"
-		}
-	}
-	return false
-}
-
-func (v *visitor) addErrorAtPosition(position token.Pos, call *ast.CallExpr) {
-	pos := v.prog.Fset.Position(position)
-	lines, ok := v.lines[pos.Filename]
-	if !ok {
-		lines = readfile(pos.Filename)
-		v.lines[pos.Filename] = lines
-	}
-
-	line := "??"
-	if pos.Line-1 < len(lines) {
-		line = strings.TrimSpace(lines[pos.Line-1])
-	}
-
-	var name string
-	if call != nil {
-		name, _ = v.fullNameForPrinting(call)
-	}
-
-	v.errors = append(v.errors, UncheckedError{pos, line, name})
-}
-
-func readfile(filename string) []string {
-	var f, err = os.Open(filename)
-	if err != nil {
-		return nil
-	}
-	defer f.Close()
-
-	var lines []string
-	var scanner = bufio.NewScanner(f)
-	for scanner.Scan() {
-		lines = append(lines, scanner.Text())
-	}
-	return lines
-}
-
-func (v *visitor) Visit(node ast.Node) ast.Visitor {
-	switch stmt := node.(type) {
-	case *ast.ExprStmt:
-		if call, ok := stmt.X.(*ast.CallExpr); ok {
-			if !v.ignoreCall(call) && v.callReturnsError(call) {
-				v.addErrorAtPosition(call.Lparen, call)
-			}
-		}
-	case *ast.GoStmt:
-		if !v.ignoreCall(stmt.Call) && v.callReturnsError(stmt.Call) {
-			v.addErrorAtPosition(stmt.Call.Lparen, stmt.Call)
-		}
-	case *ast.DeferStmt:
-		if !v.ignoreCall(stmt.Call) && v.callReturnsError(stmt.Call) {
-			v.addErrorAtPosition(stmt.Call.Lparen, stmt.Call)
-		}
-	case *ast.AssignStmt:
-		if len(stmt.Rhs) == 1 {
-			// single value on rhs; check against lhs identifiers
-			if call, ok := stmt.Rhs[0].(*ast.CallExpr); ok {
-				if !v.blank {
-					break
-				}
-				if v.ignoreCall(call) {
-					break
-				}
-				isError := v.errorsByArg(call)
-				for i := 0; i < len(stmt.Lhs); i++ {
-					if id, ok := stmt.Lhs[i].(*ast.Ident); ok {
-						// We shortcut calls to recover() because errorsByArg can't
-						// check its return types for errors since it returns interface{}.
-						if id.Name == "_" && (v.isRecover(call) || isError[i]) {
-							v.addErrorAtPosition(id.NamePos, call)
-						}
-					}
-				}
-			} else if assert, ok := stmt.Rhs[0].(*ast.TypeAssertExpr); ok {
-				if !v.asserts {
-					break
-				}
-				if assert.Type == nil {
-					// type switch
-					break
-				}
-				if len(stmt.Lhs) < 2 {
-					// assertion result not read
-					v.addErrorAtPosition(stmt.Rhs[0].Pos(), nil)
-				} else if id, ok := stmt.Lhs[1].(*ast.Ident); ok && v.blank && id.Name == "_" {
-					// assertion result ignored
-					v.addErrorAtPosition(id.NamePos, nil)
-				}
-			}
-		} else {
-			// multiple value on rhs; in this case a call can't return
-			// multiple values. Assume len(stmt.Lhs) == len(stmt.Rhs)
-			for i := 0; i < len(stmt.Lhs); i++ {
-				if id, ok := stmt.Lhs[i].(*ast.Ident); ok {
-					if call, ok := stmt.Rhs[i].(*ast.CallExpr); ok {
-						if !v.blank {
-							continue
-						}
-						if v.ignoreCall(call) {
-							continue
-						}
-						if id.Name == "_" && v.callReturnsError(call) {
-							v.addErrorAtPosition(id.NamePos, call)
-						}
-					} else if assert, ok := stmt.Rhs[i].(*ast.TypeAssertExpr); ok {
-						if !v.asserts {
-							continue
-						}
-						if assert.Type == nil {
-							// Shouldn't happen anyway, no multi assignment in type switches
-							continue
-						}
-						v.addErrorAtPosition(id.NamePos, nil)
-					}
-				}
-			}
-		}
-	default:
-	}
-	return v
-}
-
-func isErrorType(t types.Type) bool {
-	return types.Implements(t, errorType)
-}