Upgrade golangci-lint, more linters

Introduces new linters and resolves issues with the latest golangci-lint version (v1.63.4).

pion/.goassets#220

.golangci.yml

@@ -25,17 +25,32 @@ linters-settings:
       - ^os.Exit$
       - ^panic$
       - ^print(ln)?$
+  varnamelen:
+    max-distance: 12
+    min-name-length: 2
+    ignore-type-assert-ok: true
+    ignore-map-index-ok: true
+    ignore-chan-recv-ok: true
+    ignore-decls:
+      - i int
+      - n int
+      - w io.Writer
+      - r io.Reader
+      - b []byte
 
 linters:
   enable:
     - asciicheck       # Simple linter to check that your code does not contain non-ASCII identifiers
     - bidichk          # Checks for dangerous unicode character sequences
     - bodyclose        # checks whether HTTP response body is closed successfully
+    - containedctx     # containedctx is a linter that detects struct contained context.Context field
     - contextcheck     # check the function whether use a non-inherited context
+    - cyclop           # checks function and package cyclomatic complexity
     - decorder         # check declaration order and count of types, constants, variables and functions
     - dogsled          # Checks assignments with too many blank identifiers (e.g. x, _, _, _, := f())
     - dupl             # Tool for code clone detection
     - durationcheck    # check for two durations multiplied together
+    - err113           # Golang linter to check the errors handling expressions
     - errcheck         # Errcheck is a program for checking for unchecked errors in go programs. These unchecked errors can be critical bugs in some cases
     - errchkjson       # Checks types passed to the json encoding functions. Reports unsupported types and optionally reports occations, where the check for the returned error can be omitted.
     - errname          # Checks that sentinel errors are prefixed with the `Err` and error types are suffixed with the `Error`.
@@ -46,66 +61,64 @@ linters:
     - forcetypeassert  # finds forced type assertions
     - gci              # Gci control golang package import order and make it always deterministic.
     - gochecknoglobals # Checks that no globals are present in Go code
-    - gochecknoinits   # Checks that no init functions are present in Go code
     - gocognit         # Computes and checks the cognitive complexity of functions
     - goconst          # Finds repeated strings that could be replaced by a constant
     - gocritic         # The most opinionated Go source code linter
+    - gocyclo          # Computes and checks the cyclomatic complexity of functions
+    - godot            # Check if comments end in a period
     - godox            # Tool for detection of FIXME, TODO and other comment keywords
-    - err113           # Golang linter to check the errors handling expressions
     - gofmt            # Gofmt checks whether code was gofmt-ed. By default this tool runs with -s option to check for code simplification
     - gofumpt          # Gofumpt checks whether code was gofumpt-ed.
     - goheader         # Checks is file header matches to pattern
     - goimports        # Goimports does everything that gofmt does. Additionally it checks unused imports
     - gomoddirectives  # Manage the use of 'replace', 'retract', and 'excludes' directives in go.mod.
-    - gomodguard       # Allow and block list linter for direct Go module dependencies. This is different from depguard where there are different block types for example version constraints and module recommendations.
     - goprintffuncname # Checks that printf-like functions are named with `f` at the end
     - gosec            # Inspects source code for security problems
     - gosimple         # Linter for Go source code that specializes in simplifying a code
     - govet            # Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string
     - grouper          # An analyzer to analyze expression groups.
     - importas         # Enforces consistent import aliases
     - ineffassign      # Detects when assignments to existing variables are not used
+    - lll              # Reports long lines
+    - maintidx         # maintidx measures the maintainability index of each function.
+    - makezero         # Finds slice declarations with non-zero initial length
     - misspell         # Finds commonly misspelled English words in comments
+    - nakedret         # Finds naked returns in functions greater than a specified function length
+    - nestif           # Reports deeply nested if statements
     - nilerr           # Finds the code that returns nil even if it checks that the error is not nil.
     - nilnil           # Checks that there is no simultaneous return of `nil` error and an invalid value.
+    - nlreturn         # nlreturn checks for a new line before return and branch statements to increase code clarity
     - noctx            # noctx finds sending http request without context.Context
     - predeclared      # find code that shadows one of Go's predeclared identifiers
     - revive           # golint replacement, finds style mistakes
     - staticcheck      # Staticcheck is a go vet on steroids, applying a ton of static analysis checks
     - stylecheck       # Stylecheck is a replacement for golint
     - tagliatelle      # Checks the struct tags.
     - tenv             # tenv is analyzer that detects using os.Setenv instead of t.Setenv since Go1.17
-    - tparallel        # tparallel detects inappropriate usage of t.Parallel() method in your Go test codes
+    - thelper          # thelper detects golang test helpers without t.Helper() call and checks the consistency of test helpers
     - typecheck        # Like the front-end of a Go compiler, parses and type-checks Go code
     - unconvert        # Remove unnecessary type conversions
     - unparam          # Reports unused function parameters
     - unused           # Checks Go code for unused constants, variables, functions and types
+    - varnamelen       # checks that the length of a variable's name matches its scope
     - wastedassign     # wastedassign finds wasted assignment statements
     - whitespace       # Tool for detection of leading and trailing whitespace
   disable:
     - depguard         # Go linter that checks if package imports are in a list of acceptable packages
-    - containedctx     # containedctx is a linter that detects struct contained context.Context field
-    - cyclop           # checks function and package cyclomatic complexity
     - funlen           # Tool for detection of long functions
-    - gocyclo          # Computes and checks the cyclomatic complexity of functions
-    - godot            # Check if comments end in a period
-    - gomnd            # An analyzer to detect magic numbers.
+    - gochecknoinits   # Checks that no init functions are present in Go code
+    - gomodguard       # Allow and block list linter for direct Go module dependencies. This is different from depguard where there are different block types for example version constraints and module recommendations.
+    - interfacebloat   # A linter that checks length of interface.
     - ireturn          # Accept Interfaces, Return Concrete Types
-    - lll              # Reports long lines
-    - maintidx         # maintidx measures the maintainability index of each function.
-    - makezero         # Finds slice declarations with non-zero initial length
-    - nakedret         # Finds naked returns in functions greater than a specified function length
-    - nestif           # Reports deeply nested if statements
-    - nlreturn         # nlreturn checks for a new line before return and branch statements to increase code clarity
+    - mnd              # An analyzer to detect magic numbers
     - nolintlint       # Reports ill-formed or insufficient nolint directives
     - paralleltest     # paralleltest detects missing usage of t.Parallel() method in your Go test
     - prealloc         # Finds slice declarations that could potentially be preallocated
     - promlinter       # Check Prometheus metrics naming via promlint
     - rowserrcheck     # checks whether Err of rows is checked successfully
     - sqlclosecheck    # Checks that sql.Rows and sql.Stmt are closed.
     - testpackage      # linter that makes you use a separate _test package
-    - thelper          # thelper detects golang test helpers without t.Helper() call and checks the consistency of test helpers
-    - varnamelen       # checks that the length of a variable's name matches its scope
+    - tparallel        # tparallel detects inappropriate usage of t.Parallel() method in your Go test codes
     - wrapcheck        # Checks that errors returned from external packages are wrapped
     - wsl              # Whitespace Linter - Forces you to use empty lines!
 
@@ -123,3 +136,6 @@ issues:
     - path: cmd
       linters:
         - forbidigo
+  max-issues-per-linter: 0
+  max-same-issues: 0
+

connctx/connctx.go

@@ -61,10 +61,11 @@ func New(conn net.Conn) ConnCtx {
 		nextConn: conn,
 		closed:   make(chan struct{}),
 	}
+
 	return c
 }
 
-func (c *connCtx) ReadContext(ctx context.Context, b []byte) (int, error) {
+func (c *connCtx) ReadContext(ctx context.Context, b []byte) (int, error) { //nolint:cyclop
 	c.readMu.Lock()
 	defer c.readMu.Unlock()
 
@@ -85,6 +86,7 @@ func (c *connCtx) ReadContext(ctx context.Context, b []byte) (int, error) {
 			// context canceled
 			if err := c.nextConn.SetReadDeadline(veryOld); err != nil {
 				errSetDeadline.Store(err)
+
 				return
 			}
 			<-done
@@ -105,10 +107,11 @@ func (c *connCtx) ReadContext(ctx context.Context, b []byte) (int, error) {
 	if err2, ok := errSetDeadline.Load().(error); ok && err == nil && err2 != nil {
 		err = err2
 	}
+
 	return n, err
 }
 
-func (c *connCtx) WriteContext(ctx context.Context, b []byte) (int, error) {
+func (c *connCtx) WriteContext(ctx context.Context, b []byte) (int, error) { //nolint:cyclop
 	c.writeMu.Lock()
 	defer c.writeMu.Unlock()
 
@@ -129,6 +132,7 @@ func (c *connCtx) WriteContext(ctx context.Context, b []byte) (int, error) {
 			// context canceled
 			if err := c.nextConn.SetWriteDeadline(veryOld); err != nil {
 				errSetDeadline.Store(err)
+
 				return
 			}
 			<-done
@@ -149,6 +153,7 @@ func (c *connCtx) WriteContext(ctx context.Context, b []byte) (int, error) {
 	if err2, ok := errSetDeadline.Load().(error); ok && err == nil && err2 != nil {
 		err = err2
 	}
+
 	return n, err
 }
 
@@ -161,6 +166,7 @@ func (c *connCtx) Close() error {
 		c.readMu.Unlock()
 		c.writeMu.Unlock()
 	})
+
 	return err
 }
 

connctx/connctx_test.go

@@ -200,7 +200,7 @@ func TestWriteClosed(t *testing.T) {
 	}
 }
 
-// Test for TestLocalAddrAndRemoteAddr
+// Test for TestLocalAddrAndRemoteAddr.
 type stringAddr struct {
 	network string
 	addr    string
@@ -262,6 +262,7 @@ func BenchmarkBase(b *testing.B) {
 			if !errors.Is(err, io.EOF) {
 				b.Fatal(err)
 			}
+
 			break
 		}
 		if n != len(data) {
@@ -304,6 +305,7 @@ func BenchmarkWrite(b *testing.B) {
 			if !errors.Is(err, io.EOF) {
 				b.Fatal(err)
 			}
+
 			break
 		}
 		if n != len(data) {
@@ -346,6 +348,7 @@ func BenchmarkRead(b *testing.B) {
 			if !errors.Is(err, io.EOF) {
 				b.Fatal(err)
 			}
+
 			break
 		}
 		if n != len(data) {

connctx/pipe.go

@@ -10,5 +10,6 @@ import (
 // Pipe creates piped pair of ConnCtx.
 func Pipe() (ConnCtx, ConnCtx) {
 	ca, cb := net.Pipe()
+
 	return New(ca), New(cb)
 }

deadline/deadline.go

@@ -43,6 +43,7 @@ func (d *Deadline) timeout() {
 	d.mu.Lock()
 	if d.pending--; d.pending != 0 || d.state != deadlineStarted {
 		d.mu.Unlock()
+
 		return
 	}
 
@@ -54,34 +55,36 @@ func (d *Deadline) timeout() {
 }
 
 // Set new deadline. Zero value means no deadline.
-func (d *Deadline) Set(t time.Time) {
+func (d *Deadline) Set(setTo time.Time) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 
 	if d.state == deadlineStarted && d.timer.Stop() {
 		d.pending--
 	}
 
-	d.deadline = t
+	d.deadline = setTo
 	d.pending++
 
 	if d.state == deadlineExceeded {
 		d.done = make(chan struct{})
 	}
 
-	if t.IsZero() {
+	if setTo.IsZero() {
 		d.pending--
 		d.state = deadlineStopped
+
 		return
 	}
 
-	if dur := time.Until(t); dur > 0 {
+	if dur := time.Until(setTo); dur > 0 {
 		d.state = deadlineStarted
 		if d.timer == nil {
 			d.timer = afterFunc(dur, d.timeout)
 		} else {
 			d.timer.Reset(dur)
 		}
+
 		return
 	}
 
@@ -94,6 +97,7 @@ func (d *Deadline) Set(t time.Time) {
 func (d *Deadline) Done() <-chan struct{} {
 	d.mu.RLock()
 	defer d.mu.RUnlock()
+
 	return d.done
 }
 
@@ -105,6 +109,7 @@ func (d *Deadline) Err() error {
 	if d.state == deadlineExceeded {
 		return context.DeadlineExceeded
 	}
+
 	return nil
 }
 
@@ -115,6 +120,7 @@ func (d *Deadline) Deadline() (time.Time, bool) {
 	if d.deadline.IsZero() {
 		return d.deadline, false
 	}
+
 	return d.deadline, true
 }
 

deadline/deadline_test.go

@@ -124,27 +124,29 @@ func collectCh(ch <-chan byte, n int, timeout time.Duration) []byte {
 			return calls
 		}
 	}
+
 	return calls
 }
 
-func TestContext(t *testing.T) {
+func TestContext(t *testing.T) { //nolint:cyclop
 	t.Run("Cancel", func(t *testing.T) {
-		d := New()
+		deadline := New()
+
 		select {
-		case <-d.Done():
+		case <-deadline.Done():
 			t.Fatal("Deadline unexpectedly done")
 		case <-time.After(50 * time.Millisecond):
 		}
-		if err := d.Err(); err != nil {
+		if err := deadline.Err(); err != nil {
 			t.Errorf("Wrong Err(), expected: nil, got: %v", err)
 		}
-		d.Set(time.Unix(0, 1)) // exceeded
+		deadline.Set(time.Unix(0, 1)) // exceeded
 		select {
-		case <-d.Done():
+		case <-deadline.Done():
 		case <-time.After(50 * time.Millisecond):
 			t.Fatal("Timeout")
 		}
-		if err := d.Err(); !errors.Is(err, context.DeadlineExceeded) {
+		if err := deadline.Err(); !errors.Is(err, context.DeadlineExceeded) {
 			t.Errorf("Wrong Err(), expected: %v, got: %v", context.DeadlineExceeded, err)
 		}
 	})

dpipe/dpipe.go

@@ -21,6 +21,7 @@ import (
 func Pipe() (net.Conn, net.Conn) {
 	ch0 := make(chan []byte, 1000)
 	ch1 := make(chan []byte, 1000)
+
 	return &conn{
 			rCh:           ch0,
 			wCh:           ch1,
@@ -60,20 +61,23 @@ func (*conn) RemoteAddr() net.Addr { return pipeAddr{} }
 func (c *conn) SetDeadline(t time.Time) error {
 	c.readDeadline.Set(t)
 	c.writeDeadline.Set(t)
+
 	return nil
 }
 
 func (c *conn) SetReadDeadline(t time.Time) error {
 	c.readDeadline.Set(t)
+
 	return nil
 }
 
 func (c *conn) SetWriteDeadline(t time.Time) error {
 	c.writeDeadline.Set(t)
+
 	return nil
 }
 
-func (c *conn) Read(data []byte) (n int, err error) {
+func (c *conn) Read(data []byte) (n int, err error) { //nolint:cyclop
 	select {
 	case <-c.closed:
 		return 0, io.EOF
@@ -91,9 +95,11 @@ func (c *conn) Read(data []byte) (n int, err error) {
 		case d := <-c.rCh:
 			if len(d) <= len(data) {
 				copy(data, d)
+
 				return len(d), nil
 			}
 			copy(data, d[:len(data)])
+
 			return len(data), nil
 		case <-c.closed:
 			return 0, io.EOF
@@ -123,6 +129,7 @@ func (c *conn) Write(data []byte) (n int, err error) {
 		return 0, io.ErrClosedPipe
 	case <-c.writeDeadline.Done():
 		c.cleanWriteBuffer()
+
 		return 0, context.DeadlineExceeded
 	default:
 	}
@@ -135,6 +142,7 @@ func (c *conn) Write(data []byte) (n int, err error) {
 		return 0, io.ErrClosedPipe
 	case <-c.writeDeadline.Done():
 		c.cleanWriteBuffer()
+
 		return 0, context.DeadlineExceeded
 	case c.wCh <- cData:
 		return len(cData), nil
@@ -145,5 +153,6 @@ func (c *conn) Close() error {
 	c.closeOnce.Do(func() {
 		close(c.closed)
 	})
+
 	return nil
 }