From b2f2446b46bf02821d90ebedadae2bf7ae0e880e Mon Sep 17 00:00:00 2001 From: Taras Madan Date: Mon, 5 Sep 2022 14:27:54 +0200 Subject: 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 --- vendor/github.com/golangci/errcheck/LICENSE | 22 - .../golangci/errcheck/golangci/golangci.go | 85 ---- .../errcheck/internal/errcheck/errcheck.go | 538 --------------------- 3 files changed, 645 deletions(-) delete mode 100644 vendor/github.com/golangci/errcheck/LICENSE delete mode 100644 vendor/github.com/golangci/errcheck/golangci/golangci.go delete mode 100644 vendor/github.com/golangci/errcheck/internal/errcheck/errcheck.go (limited to 'vendor/github.com/golangci/errcheck') 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) -} -- cgit mrf-deployment