golangci-lint: Upgrade, fix issues, reconfigure

The golangci-lint being used was quite dated.
This change upgrades to the latest version.

Unfortunately, that's not sufficient.
The new list comes with a bunch of new linters.
'enable-all' is a difficult target to keep up with,
and will just litter code with a bunch of `//nolint` comments
or a bunch more exclusions.
Not all linters that come with golangci-lint have value.

As a fix, I've switched the golangci.yml to an opt-in list of linters.
We get the golangci-lint defaults
(errcheck, gosimple, govet, ineffassign, staticcheck, unused),
and add a few useful ones on top of it.
I tried to guess the linters that were being used
from the existing configuration and `//nolint` comments,
and made sure others I know are good are in there.

Note on revive:
I've included an opt-out for unused parameters for revive
because turning `newThing(required bool)` to `newThing(_ bool)`
is a loss of useful information.

The changes to the Go files are to fix the following issues:

```
camelcase.go:16: File is not `gofmt`-ed with `-s` (gofmt)
config_test.go:50:18: directive `//nolint: gosec` is unused for linter "gosec" (nolintlint)
defaults_test.go:28:25: G601: Implicit memory aliasing in for loop. (gosec)
doc.go:5: File is not `gofmt`-ed with `-s` (gofmt)
kong.go:446:18: directive `//nolint: gosec` is unused for linter "gosec" (nolintlint)
kong_test.go:503:20: G601: Implicit memory aliasing in for loop. (gosec)
model.go:493:10: composites: reflect.ValueError struct literal uses unkeyed fields (govet)
scanner.go:112: File is not `gofmt`-ed with `-s` (gofmt)
```

And to address broken nolint directives reported as follows by
golangci-lint.

```
[.. skipped .. ]
tag.go:65:1: directive `// nolint:gocyclo` should be written without leading space as `//nolint:gocyclo` (nolintlint)
tag.go:206:51: directive `// nolint: gocyclo` should be written without leading space as `//nolint: gocyclo` (nolintlint)
util_test.go:23:43: directive `// nolint: errcheck` should be written without leading space as `//nolint: errcheck` (nolintlint)
util_test.go:51:22: directive `// nolint: errcheck` should be written without leading space as `//nolint: errcheck` (nolintlint)
```

If you'd prefer 'enable-all', feel free to close this PR.

.golangci.yml

@@ -5,46 +5,26 @@ output:
   print-issued-lines: false
 
 linters:
-  enable-all: true
-  disable:
-    - maligned
-    - lll
-    - gochecknoglobals
-    - wsl
-    - funlen
-    - gocognit
-    - gomnd
-    - goprintffuncname
-    - paralleltest
-    - nlreturn
-    - goerr113
-    - ifshort
-    - testpackage
-    - wrapcheck
-    - exhaustivestruct
-    - forbidigo
-    - gci
-    - godot
-    - gofumpt
-    - cyclop
-    - errorlint
-    - nestif
-    - golint
-    - scopelint
-    - interfacer
-    - tagliatelle
-    - thelper
-    - godox
-    - goconst
-    - varnamelen
-    - ireturn
-    - exhaustruct
-    - nonamedreturns
-    - nilnil
+  enable:
+    - dupl
+    - exhaustive
+    - forcetypeassert
+    - gocritic
+    - gocyclo
+    - gofmt
+    - gosec
+    - nolintlint
+    - revive
+    - unconvert
 
 linters-settings:
   govet:
     check-shadowing: true
+    # These govet checks are disabled by default, but they're useful.
+    enable:
+      - niliness
+      - sortslice
+      - unusedwrite
   dupl:
     threshold: 100
   gocyclo:
@@ -66,3 +46,11 @@ issues:
     - 'bad syntax for struct tag pair'
     - 'result .* \(error\) is always nil'
     - 'package io/ioutil is deprecated'
+
+  exclude-rules:
+    # Don't warn on unused parameters.
+    # Parameter names are useful for documentation.
+    # Replacing them with '_' hides useful information.
+    - linters: [revive]
+      text: 'unused-parameter: parameter \S+ seems to be unused, consider removing or renaming it as _'
+

bin/golangci-lint

@@ -1 +1 @@
-.golangci-lint-1.46.2.pkg
+.golangci-lint-1.55.2.pkg

callbacks.go

@@ -41,7 +41,7 @@ func (b bindings) addProvider(provider interface{}) error {
 		errv := out[1]
 		var err error
 		if !errv.IsNil() {
-			err = errv.Interface().(error) // nolint
+			err = errv.Interface().(error) //nolint
 		}
 		return out[0], err
 	}
@@ -99,7 +99,7 @@ func callFunction(f reflect.Value, bindings bindings) error {
 	if out[0].IsNil() {
 		return nil
 	}
-	return out[0].Interface().(error) // nolint
+	return out[0].Interface().(error) //nolint
 }
 
 func callAnyFunction(f reflect.Value, bindings bindings) (out []any, err error) {

camelcase.go

@@ -13,37 +13,37 @@ import (
 //
 // Examples
 //
-//   "" =>                     [""]
-//   "lowercase" =>            ["lowercase"]
-//   "Class" =>                ["Class"]
-//   "MyClass" =>              ["My", "Class"]
-//   "MyC" =>                  ["My", "C"]
-//   "HTML" =>                 ["HTML"]
-//   "PDFLoader" =>            ["PDF", "Loader"]
-//   "AString" =>              ["A", "String"]
-//   "SimpleXMLParser" =>      ["Simple", "XML", "Parser"]
-//   "vimRPCPlugin" =>         ["vim", "RPC", "Plugin"]
-//   "GL11Version" =>          ["GL", "11", "Version"]
-//   "99Bottles" =>            ["99", "Bottles"]
-//   "May5" =>                 ["May", "5"]
-//   "BFG9000" =>              ["BFG", "9000"]
-//   "BöseÜberraschung" =>     ["Böse", "Überraschung"]
-//   "Two  spaces" =>          ["Two", "  ", "spaces"]
-//   "BadUTF8\xe2\xe2\xa1" =>  ["BadUTF8\xe2\xe2\xa1"]
+//	"" =>                     [""]
+//	"lowercase" =>            ["lowercase"]
+//	"Class" =>                ["Class"]
+//	"MyClass" =>              ["My", "Class"]
+//	"MyC" =>                  ["My", "C"]
+//	"HTML" =>                 ["HTML"]
+//	"PDFLoader" =>            ["PDF", "Loader"]
+//	"AString" =>              ["A", "String"]
+//	"SimpleXMLParser" =>      ["Simple", "XML", "Parser"]
+//	"vimRPCPlugin" =>         ["vim", "RPC", "Plugin"]
+//	"GL11Version" =>          ["GL", "11", "Version"]
+//	"99Bottles" =>            ["99", "Bottles"]
+//	"May5" =>                 ["May", "5"]
+//	"BFG9000" =>              ["BFG", "9000"]
+//	"BöseÜberraschung" =>     ["Böse", "Überraschung"]
+//	"Two  spaces" =>          ["Two", "  ", "spaces"]
+//	"BadUTF8\xe2\xe2\xa1" =>  ["BadUTF8\xe2\xe2\xa1"]
 //
 // Splitting rules
 //
-//  1) If string is not valid UTF-8, return it without splitting as
+//  1. If string is not valid UTF-8, return it without splitting as
 //     single item array.
-//  2) Assign all unicode characters into one of 4 sets: lower case
+//  2. Assign all unicode characters into one of 4 sets: lower case
 //     letters, upper case letters, numbers, and all other characters.
-//  3) Iterate through characters of string, introducing splits
+//  3. Iterate through characters of string, introducing splits
 //     between adjacent characters that belong to different sets.
-//  4) Iterate through array of split strings, and if a given string
+//  4. Iterate through array of split strings, and if a given string
 //     is upper case:
-//       if subsequent string is lower case:
-//         move last character of upper case string to beginning of
-//         lower case string
+//     if subsequent string is lower case:
+//     move last character of upper case string to beginning of
+//     lower case string
 func camelCase(src string) (entries []string) {
 	// don't split invalid utf8
 	if !utf8.ValidString(src) {

config_test.go

@@ -47,7 +47,7 @@ func makeConfig(t *testing.T, config interface{}) (path string, cleanup func())
 	t.Helper()
 	w, err := ioutil.TempFile("", "")
 	assert.NoError(t, err)
-	defer w.Close() // nolint: gosec
+	defer w.Close()
 	err = json.NewEncoder(w).Encode(config)
 	assert.NoError(t, err)
 	return w.Name(), func() { os.Remove(w.Name()) }

context.go

@@ -161,7 +161,7 @@ func (c *Context) Empty() bool {
 }
 
 // Validate the current context.
-func (c *Context) Validate() error { // nolint: gocyclo
+func (c *Context) Validate() error { //nolint: gocyclo
 	err := Visit(c.Model, func(node Visitable, next Next) error {
 		switch node := node.(type) {
 		case *Value:
@@ -347,7 +347,7 @@ func (c *Context) endParsing() {
 	}
 }
 
-func (c *Context) trace(node *Node) (err error) { // nolint: gocyclo
+func (c *Context) trace(node *Node) (err error) { //nolint: gocyclo
 	positional := 0
 	node.Active = true
 
@@ -377,7 +377,7 @@ func (c *Context) trace(node *Node) (err error) { // nolint: gocyclo
 				switch {
 				case v == "-":
 					fallthrough
-				default: // nolint
+				default: //nolint
 					c.scan.Pop()
 					c.scan.PushTyped(token.Value, PositionalArgumentToken)
 

defaults_test.go

@@ -24,6 +24,7 @@ func TestApplyDefaults(t *testing.T) {
 			expected: CLI{Str: "str", Duration: time.Second}},
 	}
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			err := ApplyDefaults(&tt.target)
 			assert.NoError(t, err)

doc.go

@@ -2,31 +2,31 @@
 //
 // Here's an example:
 //
-//     shell rm [-f] [-r] <paths> ...
-//     shell ls [<paths> ...]
+//	shell rm [-f] [-r] <paths> ...
+//	shell ls [<paths> ...]
 //
 // This can be represented by the following command-line structure:
 //
-//     package main
+//	package main
 //
-//     import "github.com/alecthomas/kong"
+//	import "github.com/alecthomas/kong"
 //
-//     var CLI struct {
-//       Rm struct {
-//         Force     bool `short:"f" help:"Force removal."`
-//         Recursive bool `short:"r" help:"Recursively remove files."`
+//	var CLI struct {
+//	  Rm struct {
+//	    Force     bool `short:"f" help:"Force removal."`
+//	    Recursive bool `short:"r" help:"Recursively remove files."`
 //
-//         Paths []string `arg help:"Paths to remove." type:"path"`
-//       } `cmd help:"Remove files."`
+//	    Paths []string `arg help:"Paths to remove." type:"path"`
+//	  } `cmd help:"Remove files."`
 //
-//       Ls struct {
-//         Paths []string `arg optional help:"Paths to list." type:"path"`
-//       } `cmd help:"List paths."`
-//     }
+//	  Ls struct {
+//	    Paths []string `arg optional help:"Paths to list." type:"path"`
+//	  } `cmd help:"List paths."`
+//	}
 //
-//     func main() {
-//       kong.Parse(&CLI)
-//     }
+//	func main() {
+//	  kong.Parse(&CLI)
+//	}
 //
 // See https://github.com/alecthomas/kong for details.
 package kong

global_test.go

@@ -21,7 +21,7 @@ func TestParseHandlingBadBuild(t *testing.T) {
 
 	defer func() {
 		if r := recover(); r != nil {
-			assert.Equal(t, "fail=' is not quoted properly", r.(error).Error()) // nolint
+			assert.Equal(t, "fail=' is not quoted properly", r.(error).Error()) //nolint
 		}
 	}()
 

guesswidth.go

@@ -1,3 +1,4 @@
+//go:build appengine || (!linux && !freebsd && !darwin && !dragonfly && !netbsd && !openbsd)
 // +build appengine !linux,!freebsd,!darwin,!dragonfly,!netbsd,!openbsd
 
 package kong

guesswidth_unix.go

@@ -27,9 +27,9 @@ func guessWidth(w io.Writer) int {
 
 		if _, _, err := syscall.Syscall6(
 			syscall.SYS_IOCTL,
-			uintptr(fd), // nolint: unconvert
+			uintptr(fd), //nolint: unconvert
 			uintptr(syscall.TIOCGWINSZ),
-			uintptr(unsafe.Pointer(&dimensions)), // nolint: gas
+			uintptr(unsafe.Pointer(&dimensions)), //nolint: gas
 			0, 0, 0,
 		); err == 0 {
 			if dimensions[1] == 0 {

help_test.go

@@ -600,7 +600,7 @@ func TestAutoGroup(t *testing.T) {
 			if node, ok := parent.(*kong.Node); ok {
 				return &kong.Group{
 					Key:   node.Name,
-					Title: strings.Title(node.Name) + " flags:", // nolint
+					Title: strings.Title(node.Name) + " flags:", //nolint
 				}
 			}
 			return nil

kong.go

@@ -412,7 +412,7 @@ func (k *Kong) FatalIfErrorf(err error, args ...interface{}) {
 	}
 	msg := err.Error()
 	if len(args) > 0 {
-		msg = fmt.Sprintf(args[0].(string), args[1:]...) + ": " + err.Error() // nolint
+		msg = fmt.Sprintf(args[0].(string), args[1:]...) + ": " + err.Error() //nolint
 	}
 	// Maybe display usage information.
 	var parseErr *ParseError
@@ -439,11 +439,11 @@ func (k *Kong) LoadConfig(path string) (Resolver, error) {
 	if err != nil {
 		return nil, err
 	}
-	r, err := os.Open(path) // nolint: gas
+	r, err := os.Open(path) //nolint: gas
 	if err != nil {
 		return nil, err
 	}
-	defer r.Close() // nolint: gosec
+	defer r.Close()
 
 	return k.loader(r)
 }

kong_test.go

@@ -495,6 +495,7 @@ func TestHooks(t *testing.T) {
 	p := mustNew(t, &cli, kong.Bind(ctx))
 
 	for _, test := range tests {
+		test := test
 		*ctx = hookContext{}
 		cli.One = hookCmd{}
 		t.Run(test.name, func(t *testing.T) {
@@ -753,7 +754,7 @@ func TestEmbedInterface(t *testing.T) {
 	_, err := p.Parse([]string{"--some-flag=foo", "--flag=yes"})
 	assert.NoError(t, err)
 	assert.Equal(t, "foo", cli.SomeFlag)
-	assert.Equal(t, "yes", cli.TestInterface.(*TestImpl).Flag) // nolint
+	assert.Equal(t, "yes", cli.TestInterface.(*TestImpl).Flag) //nolint
 }
 
 func TestExcludedField(t *testing.T) {
@@ -1352,7 +1353,7 @@ func TestHydratePointerCommandsAndEmbeds(t *testing.T) {
 	assert.Equal(t, &embed{Embed: true}, cli.Embed)
 }
 
-// nolint
+//nolint:revive
 type testIgnoreFields struct {
 	Foo struct {
 		Bar bool
@@ -1928,8 +1929,8 @@ func TestBoolPtrNil(t *testing.T) {
 
 func TestUnsupportedPtr(t *testing.T) {
 	type Foo struct {
-		x int // nolint
-		y int // nolint
+		x int //nolint
+		y int //nolint
 	}
 
 	var cli struct {