mod: bump github.com/golangci/golangci-lint from 1.55.2 to 1.56.2

Bumps [github.com/golangci/golangci-lint](https://github.com/golangci/golangci-lint) from 1.55.2 to 1.56.2.
- [Release notes](https://github.com/golangci/golangci-lint/releases)
- [Changelog](https://github.com/golangci/golangci-lint/blob/master/CHANGELOG.md)
- [Commits](https://github.com/golangci/golangci-lint/compare/v1.55.2...v1.56.2)

---
updated-dependencies:
- dependency-name: github.com/golangci/golangci-lint
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

6 files changed, 121 insertions, 41 deletions

diff --git a/vendor/github.com/nishanths/exhaustive/comment.go b/vendor/github.com/nishanths/exhaustive/comment.go
index cc84beaf7..123e0181b 100644
--- a/vendor/github.com/nishanths/exhaustive/comment.go
+++ b/vendor/github.com/nishanths/exhaustive/comment.go
@@ -3,45 +3,14 @@ package exhaustive
 import (
 	"go/ast"
 	"go/token"
-	"regexp"
 	"strings"
 )
 
-// For definition of generated file see:
-// http://golang.org/s/generatedcode
-
-var generatedCodeRe = regexp.MustCompile(`^// Code generated .* DO NOT EDIT\.$`)
-
-func isGeneratedFile(file *ast.File) bool {
-	// NOTE: file.Comments includes file.Doc as well, so no need
-	// to separately check file.Doc.
-	for _, c := range file.Comments {
-		for _, cc := range c.List {
-			// This check handles the "must appear before the first
-			// non-comment, non-blank text in the file" requirement.
-			//
-			// According to https://golang.org/ref/spec#Source_file_organization
-			// the package clause is the first element in a file, which
-			// should make it the first non-comment, non-blank text.
-			if c.Pos() >= file.Package {
-				return false
-			}
-			// According to the docs:
-			//   '\r' has been removed.
-			//   '\n' has been removed for //-style comments
-			// This has also been manually verified.
-			if generatedCodeRe.MatchString(cc.Text) {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
 const (
-	ignoreComment  = "//exhaustive:ignore"
-	enforceComment = "//exhaustive:enforce"
+	ignoreComment                     = "//exhaustive:ignore"
+	enforceComment                    = "//exhaustive:enforce"
+	ignoreDefaultCaseRequiredComment  = "//exhaustive:ignore-default-case-required"
+	enforceDefaultCaseRequiredComment = "//exhaustive:enforce-default-case-required"
 )
 
 func hasCommentPrefix(comments []*ast.CommentGroup, comment string) bool {
diff --git a/vendor/github.com/nishanths/exhaustive/comment_go121.go b/vendor/github.com/nishanths/exhaustive/comment_go121.go
new file mode 100644
index 000000000..a7bbc8881
--- /dev/null
+++ b/vendor/github.com/nishanths/exhaustive/comment_go121.go
@@ -0,0 +1,11 @@
+//go:build go1.21
+
+package exhaustive
+
+import (
+	"go/ast"
+)
+
+func isGeneratedFile(file *ast.File) bool {
+	return ast.IsGenerated(file)
+}
diff --git a/vendor/github.com/nishanths/exhaustive/comment_pre_go121.go b/vendor/github.com/nishanths/exhaustive/comment_pre_go121.go
new file mode 100644
index 000000000..28d2ed493
--- /dev/null
+++ b/vendor/github.com/nishanths/exhaustive/comment_pre_go121.go
@@ -0,0 +1,27 @@
+//go:build !go1.21
+
+package exhaustive
+
+import (
+	"go/ast"
+	"regexp"
+)
+
+// For definition of generated file see:
+// http://golang.org/s/generatedcode
+
+var generatedCodeRe = regexp.MustCompile(`^// Code generated .* DO NOT EDIT\.$`)
+
+func isGeneratedFile(file *ast.File) bool {
+	for _, c := range file.Comments {
+		for _, cc := range c.List {
+			if cc.Pos() > file.Package {
+				break
+			}
+			if generatedCodeRe.MatchString(cc.Text) {
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/vendor/github.com/nishanths/exhaustive/doc.go b/vendor/github.com/nishanths/exhaustive/doc.go
index 8435e5d24..a745247db 100644
--- a/vendor/github.com/nishanths/exhaustive/doc.go
+++ b/vendor/github.com/nishanths/exhaustive/doc.go
@@ -10,8 +10,8 @@ The Go [language spec] does not have an explicit definition for enums. For
 the purpose of this analyzer, and by convention, an enum type is any named
 type that:
 
-  - has underlying type float, string, or integer (includes byte and rune);
-    and
+  - has an [underlying type] of float, string, or integer (includes byte
+    and rune); and
   - has at least one constant of its type defined in the same [block].
 
 In the example below, Biome is an enum type. The three constants are its
@@ -209,6 +209,7 @@ To ignore specific types, specify the -ignore-enum-types flag:
 	exhaustive -ignore-enum-types '^time\.Duration$|^example\.org/measure\.Unit$'
 
 [language spec]: https://golang.org/ref/spec
+[underlying type]: https://golang.org/ref/spec#Underlying_types
 [block]: https://golang.org/ref/spec#Blocks
 [BasicKind]: https://pkg.go.dev/go/types#BasicKind
 */
diff --git a/vendor/github.com/nishanths/exhaustive/exhaustive.go b/vendor/github.com/nishanths/exhaustive/exhaustive.go
index d67a60c32..013ac47bb 100644
--- a/vendor/github.com/nishanths/exhaustive/exhaustive.go
+++ b/vendor/github.com/nishanths/exhaustive/exhaustive.go
@@ -19,6 +19,7 @@ func registerFlags() {
 	Analyzer.Flags.BoolVar(&fExplicitExhaustiveMap, ExplicitExhaustiveMapFlag, false, `check map literal only if associated with "//exhaustive:enforce" comment`)
 	Analyzer.Flags.BoolVar(&fCheckGenerated, CheckGeneratedFlag, false, "check generated files")
 	Analyzer.Flags.BoolVar(&fDefaultSignifiesExhaustive, DefaultSignifiesExhaustiveFlag, false, "switch statement is unconditionally exhaustive if it has a default case")
+	Analyzer.Flags.BoolVar(&fDefaultCaseRequired, DefaultCaseRequiredFlag, false, "switch statement requires default case even if exhaustive")
 	Analyzer.Flags.Var(&fIgnoreEnumMembers, IgnoreEnumMembersFlag, "ignore constants matching `regexp`")
 	Analyzer.Flags.Var(&fIgnoreEnumTypes, IgnoreEnumTypesFlag, "ignore types matching `regexp`")
 	Analyzer.Flags.BoolVar(&fPackageScopeOnly, PackageScopeOnlyFlag, false, "only discover enums declared in file-level blocks")
@@ -36,6 +37,7 @@ const (
 	ExplicitExhaustiveMapFlag      = "explicit-exhaustive-map"
 	CheckGeneratedFlag             = "check-generated"
 	DefaultSignifiesExhaustiveFlag = "default-signifies-exhaustive"
+	DefaultCaseRequiredFlag        = "default-case-required"
 	IgnoreEnumMembersFlag          = "ignore-enum-members"
 	IgnoreEnumTypesFlag            = "ignore-enum-types"
 	PackageScopeOnlyFlag           = "package-scope-only"
@@ -52,6 +54,7 @@ var (
 	fExplicitExhaustiveMap      bool
 	fCheckGenerated             bool
 	fDefaultSignifiesExhaustive bool
+	fDefaultCaseRequired        bool
 	fIgnoreEnumMembers          regexpFlag
 	fIgnoreEnumTypes            regexpFlag
 	fPackageScopeOnly           bool
@@ -65,6 +68,7 @@ func resetFlags() {
 	fExplicitExhaustiveMap = false
 	fCheckGenerated = false
 	fDefaultSignifiesExhaustive = false
+	fDefaultCaseRequired = false
 	fIgnoreEnumMembers = regexpFlag{}
 	fIgnoreEnumTypes = regexpFlag{}
 	fPackageScopeOnly = false
@@ -121,6 +125,7 @@ func run(pass *analysis.Pass) (interface{}, error) {
 			conf := switchConfig{
 				explicit:                   fExplicitExhaustiveSwitch,
 				defaultSignifiesExhaustive: fDefaultSignifiesExhaustive,
+				defaultCaseRequired:        fDefaultCaseRequired,
 				checkGenerated:             fCheckGenerated,
 				ignoreConstant:             fIgnoreEnumMembers.re,
 				ignoreType:                 fIgnoreEnumTypes.re,
diff --git a/vendor/github.com/nishanths/exhaustive/switch.go b/vendor/github.com/nishanths/exhaustive/switch.go
index 000ef9886..d235fbec4 100644
--- a/vendor/github.com/nishanths/exhaustive/switch.go
+++ b/vendor/github.com/nishanths/exhaustive/switch.go
@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"go/types"
 	"regexp"
+	"strings"
 
 	"golang.org/x/tools/go/analysis"
 )
@@ -44,6 +45,7 @@ const (
 	resultNoEnforceComment     = "has no enforce comment"
 	resultEnumMembersAccounted = "required enum members accounted for"
 	resultDefaultCaseSuffices  = "default case satisfies exhaustiveness"
+	resultMissingDefaultCase   = "missing required default case"
 	resultReportedDiagnostic   = "reported diagnostic"
 	resultEnumTypes            = "invalid or empty composing enum types"
 )
@@ -52,11 +54,47 @@ const (
 type switchConfig struct {
 	explicit                   bool
 	defaultSignifiesExhaustive bool
+	defaultCaseRequired        bool
 	checkGenerated             bool
 	ignoreConstant             *regexp.Regexp // can be nil
 	ignoreType                 *regexp.Regexp // can be nil
 }
 
+// There are few possibilities, and often none, so we use a possibly-nil slice
+func userDirectives(comments []*ast.CommentGroup) []string {
+	var directives []string
+	for _, c := range comments {
+		for _, cc := range c.List {
+			// The order matters here: we always want to check the longest first.
+			for _, d := range []string{
+				enforceDefaultCaseRequiredComment,
+				ignoreDefaultCaseRequiredComment,
+				enforceComment,
+				ignoreComment,
+			} {
+				if strings.HasPrefix(cc.Text, d) {
+					directives = append(directives, d)
+					// The break here is important: once we associate a comment
+					// with a particular (longest-possible) directive, we don't want
+					// to map to another!
+					break
+				}
+			}
+		}
+	}
+	return directives
+}
+
+// Can be replaced with slices.Contains with go1.21
+func directivesIncludes(directives []string, d string) bool {
+	for _, ud := range directives {
+		if ud == d {
+			return true
+		}
+	}
+	return false
+}
+
 // switchChecker returns a node visitor that checks exhaustiveness of
 // enum switch statements for the supplied pass, and reports
 // diagnostics. The node visitor expects only *ast.SwitchStmt nodes.
@@ -80,17 +118,27 @@ func switchChecker(pass *analysis.Pass, cfg switchConfig, generated boolCache, c
 		sw := n.(*ast.SwitchStmt)
 
 		switchComments := comments.get(pass.Fset, file)[sw]
-		if !cfg.explicit && hasCommentPrefix(switchComments, ignoreComment) {
+		uDirectives := userDirectives(switchComments)
+		if !cfg.explicit && directivesIncludes(uDirectives, ignoreComment) {
 			// Skip checking of this switch statement due to ignore
 			// comment. Still return true because there may be nested
 			// switch statements that are not to be ignored.
 			return true, resultIgnoreComment
 		}
-		if cfg.explicit && !hasCommentPrefix(switchComments, enforceComment) {
+		if cfg.explicit && !directivesIncludes(uDirectives, enforceComment) {
 			// Skip checking of this switch statement due to missing
 			// enforce comment.
 			return true, resultNoEnforceComment
 		}
+		requireDefaultCase := cfg.defaultCaseRequired
+		if directivesIncludes(uDirectives, ignoreDefaultCaseRequiredComment) {
+			requireDefaultCase = false
+		}
+		if directivesIncludes(uDirectives, enforceDefaultCaseRequiredComment) {
+			// We have "if" instead of "else if" here in case of conflicting ignore/enforce directives.
+			// In that case, because this is second, we will default to enforcing.
+			requireDefaultCase = true
+		}
 
 		if sw.Tag == nil {
 			return true, resultNoSwitchTag // never possible for valid Go program?
@@ -114,13 +162,21 @@ func switchChecker(pass *analysis.Pass, cfg switchConfig, generated boolCache, c
 			checkl.add(e.typ, e.members, pass.Pkg == e.typ.Pkg())
 		}
 
-		def := analyzeSwitchClauses(sw, pass.TypesInfo, checkl.found)
+		defaultCaseExists := analyzeSwitchClauses(sw, pass.TypesInfo, checkl.found)
+		if !defaultCaseExists && requireDefaultCase {
+			// Even if the switch explicitly enumerates all the
+			// enum values, the user has still required all switches
+			// to have a default case. We check this first to avoid
+			// early-outs
+			pass.Report(makeMissingDefaultDiagnostic(sw, dedupEnumTypes(toEnumTypes(es))))
+			return true, resultMissingDefaultCase
+		}
 		if len(checkl.remaining()) == 0 {
 			// All enum members accounted for.
 			// Nothing to report.
 			return true, resultEnumMembersAccounted
 		}
-		if def && cfg.defaultSignifiesExhaustive {
+		if defaultCaseExists && cfg.defaultSignifiesExhaustive {
 			// Though enum members are not accounted for, the
 			// existence of the default case signifies
 			// exhaustiveness.  So don't report.
@@ -167,3 +223,14 @@ func makeSwitchDiagnostic(sw *ast.SwitchStmt, enumTypes []enumType, missing map[
 		),
 	}
 }
+
+func makeMissingDefaultDiagnostic(sw *ast.SwitchStmt, enumTypes []enumType) analysis.Diagnostic {
+	return analysis.Diagnostic{
+		Pos: sw.Pos(),
+		End: sw.End(),
+		Message: fmt.Sprintf(
+			"missing default case in switch of type %s",
+			diagnosticEnumTypes(enumTypes),
+		),
+	}
+}