Excavator: Bump go dependency github.com/golangci/golangci-lint/v2

Author: svc-excavator-bot

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/internal/x/tools/analysisinternal/analysis.go

@@ -8,25 +8,30 @@ package analysisinternal
 
 import (
 	"fmt"
-	"os"
+	"slices"
 
 	"golang.org/x/tools/go/analysis"
 )
 
-// MakeReadFile returns a simple implementation of the Pass.ReadFile function.
-func MakeReadFile(pass *analysis.Pass) func(filename string) ([]byte, error) {
+// A ReadFileFunc is a function that returns the
+// contents of a file, such as [os.ReadFile].
+type ReadFileFunc = func(filename string) ([]byte, error)
+
+// CheckedReadFile returns a wrapper around a Pass.ReadFile
+// function that performs the appropriate checks.
+func CheckedReadFile(pass *analysis.Pass, readFile ReadFileFunc) ReadFileFunc {
 	return func(filename string) ([]byte, error) {
 		if err := CheckReadable(pass, filename); err != nil {
 			return nil, err
 		}
-		return os.ReadFile(filename)
+		return readFile(filename)
 	}
 }
 
 // CheckReadable enforces the access policy defined by the ReadFile field of [analysis.Pass].
 func CheckReadable(pass *analysis.Pass, filename string) error {
-	if slicesContains(pass.OtherFiles, filename) ||
-		slicesContains(pass.IgnoredFiles, filename) {
+	if slices.Contains(pass.OtherFiles, filename) ||
+		slices.Contains(pass.IgnoredFiles, filename) {
 		return nil
 	}
 	for _, f := range pass.Files {
@@ -36,13 +41,3 @@ func CheckReadable(pass *analysis.Pass, filename string) error {
 	}
 	return fmt.Errorf("Pass.ReadFile: %s is not among OtherFiles, IgnoredFiles, or names of Files", filename)
 }
-
-// TODO(adonovan): use go1.21 slices.Contains.
-func slicesContains[S ~[]E, E comparable](slice S, x E) bool {
-	for _, elem := range slice {
-		if elem == x {
-			return true
-		}
-	}
-	return false
-}

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/internal/x/tools/diff/diff.go

@@ -7,6 +7,7 @@ package diff
 
 import (
 	"fmt"
+	"slices"
 	"sort"
 	"strings"
 )
@@ -64,7 +65,7 @@ func ApplyBytes(src []byte, edits []Edit) ([]byte, error) {
 // It may return a different slice.
 func validate(src string, edits []Edit) ([]Edit, int, error) {
 	if !sort.IsSorted(editsSort(edits)) {
-		edits = append([]Edit(nil), edits...)
+		edits = slices.Clone(edits)
 		SortEdits(edits)
 	}
 

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/internal/x/tools/diff/lcs/common.go

@@ -51,7 +51,7 @@ func (l lcs) fix() lcs {
 	// from the set of diagonals in l, find a maximal non-conflicting set
 	// this problem may be NP-complete, but we use a greedy heuristic,
 	// which is quadratic, but with a better data structure, could be D log D.
-	// indepedent is not enough: {0,3,1} and {3,0,2} can't both occur in an lcs
+	// independent is not enough: {0,3,1} and {3,0,2} can't both occur in an lcs
 	// which has to have monotone x and y
 	if len(l) == 0 {
 		return nil

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/internal/x/tools/diff/lcs/doc.go

@@ -139,7 +139,7 @@ computed labels. That is the worst case. Had the code noticed (x,y)=(u,v)=(3,3)
 from the edgegraph. The implementation looks for a number of special cases to try to avoid computing an extra forward path.
 
 If the two-sided algorithm has stop early (because D has become too large) it will have found a forward LCS and a
-backwards LCS. Ideally these go with disjoint prefixes and suffixes of A and B, but disjointness may fail and the two
+backwards LCS. Ideally these go with disjoint prefixes and suffixes of A and B, but disjointedness may fail and the two
 computed LCS may conflict. (An easy example is where A is a suffix of B, and shares a short prefix. The backwards LCS
 is all of A, and the forward LCS is a prefix of A.) The algorithm combines the two
 to form a best-effort LCS. In the worst case the forward partial LCS may have to

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/internal/x/tools/diff/lcs/old.go

@@ -105,7 +105,7 @@ func forward(e *editGraph) lcs {
 		return ans
 	}
 	// from D to D+1
-	for D := 0; D < e.limit; D++ {
+	for D := range e.limit {
 		e.setForward(D+1, -(D + 1), e.getForward(D, -D))
 		if ok, ans := e.fdone(D+1, -(D + 1)); ok {
 			return ans
@@ -199,13 +199,14 @@ func (e *editGraph) bdone(D, k int) (bool, lcs) {
 }
 
 // run the backward algorithm, until success or up to the limit on D.
+// (used only by tests)
 func backward(e *editGraph) lcs {
 	e.setBackward(0, 0, e.ux)
 	if ok, ans := e.bdone(0, 0); ok {
 		return ans
 	}
 	// from D to D+1
-	for D := 0; D < e.limit; D++ {
+	for D := range e.limit {
 		e.setBackward(D+1, -(D + 1), e.getBackward(D, -D)-1)
 		if ok, ans := e.bdone(D+1, -(D + 1)); ok {
 			return ans
@@ -299,7 +300,7 @@ func twosided(e *editGraph) lcs {
 	e.setBackward(0, 0, e.ux)
 
 	// from D to D+1
-	for D := 0; D < e.limit; D++ {
+	for D := range e.limit {
 		// just finished a backwards pass, so check
 		if got, ok := e.twoDone(D, D); ok {
 			return e.twolcs(D, D, got)
@@ -376,10 +377,7 @@ func (e *editGraph) twoDone(df, db int) (int, bool) {
 	if (df+db+e.delta)%2 != 0 {
 		return 0, false // diagonals cannot overlap
 	}
-	kmin := -db + e.delta
-	if -df > kmin {
-		kmin = -df
-	}
+	kmin := max(-df, -db+e.delta)
 	kmax := db + e.delta
 	if df < kmax {
 		kmax = df

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/internal/x/tools/diff/ndiff.go

@@ -72,7 +72,7 @@ func diffRunes(before, after []rune) []Edit {
 func runes(bytes []byte) []rune {
 	n := utf8.RuneCount(bytes)
 	runes := make([]rune, n)
-	for i := 0; i < n; i++ {
+	for i := range n {
 		r, sz := utf8.DecodeRune(bytes)
 		bytes = bytes[sz:]
 		runes[i] = r

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/internal/x/tools/diff/unified.go

@@ -129,12 +129,12 @@ func toUnified(fromName, toName string, content string, edits []Edit, contextLin
 
 		switch {
 		case h != nil && start == last:
-			//direct extension
+			// direct extension
 		case h != nil && start <= last+gap:
-			//within range of previous lines, add the joiners
+			// within range of previous lines, add the joiners
 			addEqualLines(h, lines, last, start)
 		default:
-			//need to start a new hunk
+			// need to start a new hunk
 			if h != nil {
 				// add the edge to the previous hunk
 				addEqualLines(h, lines, last, last+contextLines)

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/pkg/commands/internal/builder.go

@@ -257,7 +257,7 @@ func (b Builder) createVersion(orig string) (string, error) {
 			continue
 		}
 
-		dh, err := dirhash.HashDir(plugin.Path, "", dirhash.DefaultHash)
+		dh, err := hashDir(plugin.Path, "", dirhash.DefaultHash)
 		if err != nil {
 			return "", fmt.Errorf("hash plugin directory: %w", err)
 		}

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/pkg/commands/internal/dirhash.go

@@ -0,0 +1,93 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package internal
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+// Slightly modified copy of [dirhash.HashDir].
+// https://github.com/golang/mod/blob/v0.28.0/sumdb/dirhash/hash.go#L67-L79
+func hashDir(dir, prefix string, hash dirhash.Hash) (string, error) {
+	files, err := dirFiles(dir, prefix)
+	if err != nil {
+		return "", err
+	}
+
+	osOpen := func(name string) (io.ReadCloser, error) {
+		return os.Open(filepath.Join(dir, strings.TrimPrefix(name, prefix)))
+	}
+
+	return hash(files, osOpen)
+}
+
+// Modified copy of [dirhash.DirFiles].
+// https://github.com/golang/mod/blob/v0.28.0/sumdb/dirhash/hash.go#L81-L109
+// And adapted to globally follows the rules from https://github.com/golang/mod/blob/v0.28.0/zip/zip.go
+func dirFiles(dir, prefix string) ([]string, error) {
+	var files []string
+
+	dir = filepath.Clean(dir)
+
+	err := filepath.Walk(dir, func(file string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() {
+			if dir == file {
+				// Don't skip the top-level directory.
+				return nil
+			}
+
+			switch info.Name() {
+			// Skip vendor and node directories.
+			case "vendor", "node_modules":
+				return filepath.SkipDir
+
+			// Skip VCS directories.
+			case ".bzr", ".git", ".hg", ".svn":
+				return filepath.SkipDir
+			}
+
+			// Skip submodules (directories containing go.mod files).
+			if goModInfo, err := os.Lstat(filepath.Join(dir, "go.mod")); err == nil && !goModInfo.IsDir() {
+				return filepath.SkipDir
+			}
+
+			return nil
+		}
+
+		if file == dir {
+			return fmt.Errorf("%s is not a directory", dir)
+		}
+
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
+		rel := file
+
+		if dir != "." {
+			rel = file[len(dir)+1:]
+		}
+
+		f := filepath.Join(prefix, rel)
+
+		files = append(files, filepath.ToSlash(f))
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return files, nil
+}

generated_src/golangcilint/internal/github.com/golangci/golangci-lint/v2/pkg/commands/root.go

@@ -127,7 +127,7 @@ func forceRootParsePersistentFlags() (*rootOptions, error) {
 	fs := pflag.NewFlagSet("config flag set", pflag.ContinueOnError)
 
 	// Ignore unknown flags because we will parse the command flags later.
-	fs.ParseErrorsWhitelist = pflag.ParseErrorsWhitelist{UnknownFlags: true}
+	fs.ParseErrorsAllowlist = pflag.ParseErrorsAllowlist{UnknownFlags: true}
 
 	opts := &rootOptions{}