go-critic

https://go-critic.com
Admin
go-critic is a collection of checks that detect style, performance issues, and common programming...
Tokens:13,736
Snippets:308
Trust Score:6.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Simplify suspicious sort.Slice calls

Source: https://go-critic.com/overview.html

Highlights potentially incorrect or confusing calls to `sort.Slice`. The example shows a case where the sorting keys are accessed directly, which might be an error if `xs` and `keys` are not related as expected.

```go
sort.Slice(xs, func(i, j) bool { return keys[i] < keys[j] })
```

```go
sort.Slice(kv, func(i, j) bool { return kv[i].key < kv[j].key })
```

--------------------------------

### Simplify complex regexp patterns in Go

Source: https://go-critic.com/overview.html

Detects regular expression patterns that can be simplified using more concise syntax. For example, replacing `(?:a|b|c)` with `[abc]` and ` {3}` with `   `.

```go
regexp.MustCompile(`(?:a|b|c)   [a-z][a-z]*`)

```

```go
regexp.MustCompile(`[abc] {3}[a-z]+`)

```

--------------------------------

### Use parallel assignment for value swapping

Source: https://go-critic.com/overview.html

Recommends using parallel assignment for swapping values, which is more idiomatic and concise than using a temporary variable.

```go
*tmp = *x; *x = *y; *y = *tmp

```

```go
*x, *y = *y, *x

```

--------------------------------

### Use Idiomatic Empty String Checks

Source: https://go-critic.com/overview.html

Replaces `len(s) == 0` checks with the more idiomatic `s == ""` for better readability.

```go
len(s) == 0
```

```go
s == ""
```

--------------------------------

### Correct filepath.Join Usage

Source: https://go-critic.com/overview.html

Highlights potential issues with filepath.Join when a trailing slash is unnecessarily included in a directory path, which can lead to unexpected path constructions.

```go
filepath.Join("dir/", filename)
```

```go
filepath.Join("dir", filename)
```

--------------------------------

### Add explanations to //nolint comments

Source: https://go-critic.com/overview.html

Ensures that `//nolint` comments include a reason, improving code maintainability and understanding of why linting was suppressed.

```go
//nolint

```

```go
//nolint // reason

```

--------------------------------

### Optimize strings.Index with Byte Slices

Source: https://go-critic.com/overview.html

Identifies `strings.Index` calls on string slices that may cause unwanted allocations and suggests using `bytes.Index` with byte slices for better performance.

```go
strings.Index(string(x), y)
```

```go
bytes.Index(x, []byte(y))
```

--------------------------------

### Use defer for mutex unlock

Source: https://go-critic.com/overview.html

Recommends using `defer mu.Unlock()` after `mu.Lock()` to ensure the mutex is always unlocked, even if the function panics or returns early. This prevents deadlocks.

```go
mu.Lock(); mu.Unlock()
```

```go
mu.Lock(); defer mu.Unlock()
```

--------------------------------

### Correct suspicious argument order in strings.HasPrefix

Source: https://go-critic.com/overview.html

Identifies incorrect argument order in `strings.HasPrefix` calls. Ensure the prefix string is the first argument and the string to check is the second.

```go
strings.HasPrefix("#", userpass)
```

```go
strings.HasPrefix(userpass, "#")
```

--------------------------------

### Replace sync.Map load+delete with LoadAndDelete

Source: https://go-critic.com/overview.html

Identifies a common pattern of loading a value from `sync.Map` and then deleting it if it exists. This suggests using the more efficient `LoadAndDelete` method, which performs both operations atomically.

```go
v, ok := m.Load(k); if ok { m.Delete($k); f(v); }
```

```go
v, deleted := m.LoadAndDelete(k); if deleted { f(v) }
```

--------------------------------

### Use filepath.Join for path concatenation in Go

Source: https://go-critic.com/overview.html

Detects string concatenation using `os.PathSeparator` and suggests replacing it with `filepath.Join` for cross-platform compatibility and cleaner code.

```go
x + string(os.PathSeparator) + y

```

```go
filepath.Join(x, y)

```

--------------------------------

### Replace wg.Add(-1) with wg.Done()

Source: https://go-critic.com/overview.html

Suggests replacing `wg.Add(-1)` with `wg.Done()` for `sync.WaitGroup` usage, which is the idiomatic way to signal completion of a goroutine.

```go
wg.Add(-1)

```

```go
wg.Done()

```

--------------------------------

### Detect Multiple Imports of Same Package

Source: https://go-critic.com/overview.html

Flags situations where the same package is imported multiple times under different aliases, suggesting a cleanup opportunity.

```go
import (
	"fmt"
	printing "fmt" // Imported the second time
)
```

```go
import(
	"fmt"
)
```

--------------------------------

### Optimize string to byte slice conversions

Source: https://go-critic.com/overview.html

Identifies redundant conversions between `string` and `[]byte` when using `copy`. The `copy` function can directly accept a string as a source, eliminating the explicit conversion.

```go
copy(b, []byte(s))
```

```go
copy(b, s)
```

--------------------------------

### Use WriteByte for single-byte runes in Go

Source: https://go-critic.com/overview.html

Detects `w.WriteRune` calls with single-byte rune literals and suggests using `w.WriteByte` instead. This is a more efficient way to write single bytes.

```go
w.WriteRune('\n')

```

```go
w.WriteByte('\n')

```

--------------------------------

### Correct bad usage of sync.OnceFunc

Source: https://go-critic.com/overview.html

Identifies incorrect usage of `sync.OnceFunc`. The `OnceFunc` should be called once to create the function, and then that function should be called later.

```go
sync.OnceFunc(foo)()
```

```go
fooOnce := sync.OnceFunc(foo); ...; fooOnce()
```

--------------------------------

### Replace fmt.Sprint with fmt.Fprintf in Go

Source: https://go-critic.com/overview.html

Identifies `fmt.Sprint` or `fmt.Sprintln` calls used with a writer and suggests replacing them with `fmt.Fprintf` for potentially better performance by avoiding intermediate string allocations.

```go
w.Write([]byte(fmt.Sprintf("%x", 10)))

```

```go
fmt.Fprintf(w, "%x", 10)

```

--------------------------------

### Use Assignment in If/Switch Init Clauses

Source: https://go-critic.com/overview.html

Detects non-assignment statements within if or switch init clauses and suggests moving them outside for clarity and correctness.

```go
if sideEffect(); cond {
}
```

```go
sideEffect()
if cond {
}
```

--------------------------------

### Use regexp.MustCompile for constant patterns in Go

Source: https://go-critic.com/overview.html

Identifies `regexp.Compile` calls that are used to initialize a constant regular expression. It suggests replacing them with `regexp.MustCompile` to panic on invalid patterns at initialization time, simplifying error handling.

```go
re, _ := regexp.Compile("const pattern")

```

```go
re := regexp.MustCompile("const pattern")

```

--------------------------------

### Use standard 'Code generated' file comment

Source: https://go-critic.com/overview.html

Detects malformed 'code generated' file comments. Ensures the comment follows the standard format `// Code generated by <tool>. DO NOT EDIT.` for tools that generate Go code.

```go
// This file was automatically generated by foogen
```

```go
// Code generated by foogen. DO NOT EDIT.
```

--------------------------------

### Simplify time expression to UnixMilli

Source: https://go-critic.com/overview.html

Detects manual conversion of Unix timestamps to milliseconds by dividing by 1000. It suggests using the built-in `UnixMilli()` method for clarity and correctness.

```go
t.Unix() / 1000
```

```go
t.UnixMilli()
```

--------------------------------

### Simplify string concatenation

Source: https://go-critic.com/overview.html

Detects string concatenations using `strings.Join` on a small, fixed number of elements and suggests a simpler direct concatenation. This can improve readability for basic cases.

```go
strings.Join([]string{x, y}, "_")
```

```go
x + "_" + y
```

--------------------------------

### Handle Suspicious Empty Declarations

Source: https://go-critic.com/overview.html

Flags suspicious empty declaration blocks, such as `var()`, which are typically unnecessary.

```go
var()
```

```go
/* nothing */
```

--------------------------------

### Optimize bytes.Repeat with zero value

Source: https://go-critic.com/overview.html

Identifies `bytes.Repeat([]byte{0}, x)` and suggests using `make([]byte, x)` for better performance when creating a slice of zeros.

```go
bytes.Repeat([]byte{0}, x)

```

```go
make([]byte, x)

```

--------------------------------

### Detect Commented-Out Imports

Source: https://go-critic.com/overview.html

Flags commented-out import statements, helping to clean up unused imports.

```go
import (
	"fmt"
	"os"
)
```

```go
import (
	"fmt"
)
```

--------------------------------

### Prevent os.Exit/log.Fatal in Defer Functions

Source: https://go-critic.com/overview.html

Identifies calls to os.Exit or log.Fatalf within functions that also use defer, which can prevent deferred cleanup actions from executing.

```go
defer os.Remove(filename)
if bad {
	log.Fatalf("something bad happened")
}
```

```go
defer os.Remove(filename)
if bad {
	log.Printf("something bad happened")
	return
}
```

--------------------------------

### Simplify pointer to referential type parameters in Go

Source: https://go-critic.com/overview.html

Detects function parameters that are pointers to referential types (like `*map[string]int` or `*chan *int`) and suggests simplifying them to the referential type directly. This often makes the function signature cleaner and easier to use.

```go
func f(m *map[string]int) (*chan *int)

```

```go
func f(m map[string]int) (chan *int)

```

--------------------------------

### Avoid Yoda style expressions

Source: https://go-critic.com/overview.html

Detects Yoda style expressions (e.g., `nil != ptr`) and suggests rewriting them in the conventional order (e.g., `ptr != nil`) for better readability.

```go
return nil != ptr

```

```go
return ptr != nil

```

--------------------------------

### Use flag.BoolVar for Flag Pointers

Source: https://go-critic.com/overview.html

Detects immediate dereferencing of flag package pointers and suggests using the appropriate `BoolVar`, `IntVar`, etc., for cleaner flag definition.

```go
b := *flag.Bool("b", false, "b docs")
```

```go
var b bool; flag.BoolVar(&b, "b", false, "b docs")
```

--------------------------------

### Replace Query with Exec for UPDATE statements

Source: https://go-critic.com/overview.html

Identifies `db.Query()` calls used for UPDATE statements, suggesting the use of `db.Exec()` instead, as `Exec` is intended for statements that modify data and do not return rows.

```go
_,	 err := db.Query("UPDATE ...")
```

```go
_,	 err := db.Exec("UPDATE ...")
```

--------------------------------

### Use http.NoBody for Nil Request Body

Source: https://go-critic.com/overview.html

Recommends using `http.NoBody` instead of `nil` for the request body in `http.NewRequest` calls, especially for methods that do not typically have a body.

```go
http.NewRequest("GET", url, nil)
```

```go
http.NewRequest("GET", url, http.NoBody)
```

--------------------------------

### Use WriteString for string writing in Go

Source: https://go-critic.com/overview.html

Detects `w.Write([]byte(...))` or `io.WriteString` calls and suggests using `w.WriteString` when writing string literals or variables. This can be more efficient as it avoids byte slice conversions.

```go
w.Write([]byte("foo"))

```

```go
w.WriteString("foo")

```

--------------------------------

### Combine function parameters by type in Go

Source: https://go-critic.com/overview.html

Detects when function parameters with the same type are declared separately and suggests combining them into a single parameter declaration. This simplifies function signatures.

```go
func foo(a, b int, c, d int, e, f int, g int) {}

```

```go
func foo(a, b, c, d, e, f, g int) {}

```

--------------------------------

### Refactor Defer in Loops

Source: https://go-critic.com/overview.html

Identifies loops that use defer, suggesting a refactoring into a separate function to manage resource cleanup properly.

```go
for _, filename := range []string{"foo", "bar"} {
	 f, err := os.Open(filename)
	
	defer f.Close()
}
```

```go
func process(filename string) {
	 f, err := os.Open(filename)
	
	defer f.Close()
}
/* ... */
for _, filename := range []string{"foo", "bar"} {
	process(filename)
}
```

--------------------------------

### Add detail to TODO comments

Source: https://go-critic.com/overview.html

Flags TODO comments that lack specific details, such as an assignee or a description of the task. It suggests adding context to make the TODO actionable.

```go
// TODO
	fiiWithCtx(nil, a, b)
```

```go
// TODO(admin): pass context.TODO() instead of nil
	fiiWithCtx(nil, a, b)
```

--------------------------------

### Simplify Deferred Function Literals

Source: https://go-critic.com/overview.html

Detects deferred function literals that can be simplified to a direct function call.

```go
defer func() { f() }()
```

```go
defer f()
```

--------------------------------

### Use sort.Strings instead of sort.StringSlice

Source: https://go-critic.com/overview.html

Detects the use of `sort.StringSlice` which is often unnecessary. Prefer `sort.Strings` for sorting string slices directly.

```go
xs = sort.StringSlice(xs)
```

```go
sort.Strings(xs)
```

--------------------------------

### Use strings.EqualFold for Case-Insensitive Comparison

Source: https://go-critic.com/overview.html

Replaces inefficient strings.ToLower comparisons with the more performant strings.EqualFold for case-insensitive string equality checks.

```go
strings.ToLower(x) == strings.ToLower(y)
```

```go
strings.EqualFold(x, y)
```

--------------------------------

### Detect nil return values in Go

Source: https://go-critic.com/overview.html

Identifies return statements where the result evaluates to nil. Use this to ensure functions always return valid values or explicitly return nil when intended.

```go
if err == nil {
	return err
}

```

```go
// (A) - return nil explicitly
if err == nil {
	return nil
}
// (B) - typo in "==", change to "!="
if err != nil {
	return err
}

```

--------------------------------

### Replace old-style octal literals in Go

Source: https://go-critic.com/overview.html

Detects and suggests replacing old-style octal literals (e.g., 02) with the modern Go syntax (e.g., 0o2). This improves code readability and consistency.

```go
foo(02)

```

```go
foo(0o2)

```

--------------------------------

### Optimize range loop value copies in Go

Source: https://go-critic.com/overview.html

Identifies loops that copy large objects in each iteration. It suggests using index access or taking the address to work with pointers, reducing memory overhead and improving performance.

```go
xs := make([][1024]byte, length)
for _, x := range xs {
	// Loop body.
}

```

```go
xs := make([][1024]byte, length)
for i := range xs {
	x := &xs[i]
	// Loop body.
}

```

--------------------------------

### Fix Non-Idiomatic Comment Formatting

Source: https://go-critic.com/overview.html

Use this to detect and correct comments with non-idiomatic formatting, ensuring a consistent style.

```go
//This is a comment
```

```go
// This is a comment
```

--------------------------------

### Replace sprintf %s with %q for quoted strings

Source: https://go-critic.com/overview.html

Detects instances where `fmt.Sprintf("%s", s)` is used to format a string with surrounding quotes. It suggests replacing this with `%q` for a more direct and efficient way to quote strings.

```go
fmt.Sprintf(`"%s"`, s)
```

```go
fmt.Sprintf(`%q`, s)
```

--------------------------------

### Detect Suspicious Formatting String Usage

Source: https://go-critic.com/overview.html

Identifies potentially incorrect usage of formatting strings, suggesting alternatives like `errors.New` or `fmt.Errorf` with explicit format specifiers.

```go
fmt.Errorf(msg)
```

```go
errors.New(msg) or fmt.Errorf("%s", msg)
```

--------------------------------

### Replace strings.Compare with less than operator

Source: https://go-critic.com/overview.html

Flags the use of `strings.Compare(x, y)` and suggests replacing it with the more idiomatic `x < y` for boolean comparison. This simplifies the code when only checking for less than, equal to, or greater than.

```go
strings.Compare(x, y)
```

```go
x < y
```

--------------------------------

### Simplify assignments using assignment operators

Source: https://go-critic.com/overview.html

Detects assignments that can be simplified by using compound assignment operators (e.g., `*=`, `+=`). This is a style improvement.

```go
x = x * 2
```

```go
x *= 2
```

--------------------------------

### Avoid Dereferencing `new` Expressions

Source: https://go-critic.com/overview.html

Detects immediate dereferencing of `new` expressions and suggests a simpler initialization, such as using a zero value.

```go
x := *new(bool)
```

```go
x := false
```

--------------------------------

### Replace If-Else Chains with Switch Statements

Source: https://go-critic.com/overview.html

Detects chains of if-else if statements and suggests refactoring them into a more readable and efficient switch statement.

```go
if cond1 {
	// Code A.
} else if cond2 {
	// Code B.
} else {
	// Code C.
}
```

```go
switch {
case cond1:
	// Code A.
case cond2:
	// Code B.
default:
	// Code C.
}
```

--------------------------------

### Combine multiple appends to the same slice

Source: https://go-critic.com/overview.html

Detects chains of `append` calls to the same slice that can be consolidated into a single `append` call for efficiency. This is a performance optimization.

```go
xs = append(xs, 1)
xs = append(xs, 2)
```

```go
xs = append(xs, 1, 2)
```

--------------------------------

### Name unnamed result parameters

Source: https://go-critic.com/overview.html

Suggests naming unnamed result parameters in function signatures for improved clarity and documentation. This is particularly useful for exported functions.

```go
func f() (float64, float64)

```

```go
func f() (x, y float64)

```

--------------------------------

### Use Named Fields for Mutexes

Source: https://go-critic.com/overview.html

Suggests using a named field for sync.Mutex or sync.RWMutex within a struct instead of embedding it directly, improving clarity and preventing accidental method calls.

```go
type Foo struct{ ...; sync.Mutex; ... }
```

```go
type Foo struct{ ...; mu sync.Mutex; ... }
```

--------------------------------

### Simplify function literals

Source: https://go-critic.com/overview.html

Detects function literals that can be replaced with a direct function reference, making the code more concise.

```go
func(x int) int { return fn(x) }

```

```go
fn

```

--------------------------------

### Optimize range loop expression copies in Go

Source: https://go-critic.com/overview.html

Detects expensive copies of range expressions in `for` loops, especially with large arrays. It suggests using a pointer to the array (`&xs`) to avoid copying the entire array, improving performance.

```go
var xs [2048]byte
for _, x := range xs { // Copies 2048 bytes
	// Loop body.
}

```

```go
var xs [2048]byte
for _, x := range &xs { // No copy
	// Loop body.
}

```

--------------------------------

### Prefer Method Calls Over Method Expressions

Source: https://go-critic.com/overview.html

Detects method expression calls that can be simplified to direct method calls on a variable, improving code readability.

```go
f := foo{}
foo.bar(f)
```

```go
f := foo{}
f.bar()
```

--------------------------------

### Simplify suspicious regexp patterns

Source: https://go-critic.com/overview.html

Identifies potentially inefficient or incorrect regular expression patterns. This checker aims to simplify patterns and potentially improve performance or correctness.

```go
regexp.MustCompile(`(?:^aa|bb|cc)foo[aba]`)
```

```go
regexp.MustCompile(`^(?:aa|bb|cc)foo[ab]`)
```

--------------------------------

### Detect int truncation in comparisons

Source: https://go-critic.com/overview.html

Use this rule to find potential truncation issues when comparing integers of different sizes. Ensure correct type casting to avoid unexpected behavior.

```go
func f(x int32, y int16) bool {
  return int16(x) < y
}

```

```go
func f(x int32, int16) bool {
  return x < int32(y)
}

```

--------------------------------

### Use Consistent Case for Hex Literals

Source: https://go-critic.com/overview.html

Detects hex literals with mixed-case letter digits and suggests using a consistent case (e.g., all lowercase or all uppercase) for readability.

```go
x := 0X12
y := 0xfF
```

```go
x := 0x12
// (A)
y := 0xff
// (B)
y := 0xFF
```

--------------------------------

### Avoid Fallthrough with Multi-Case Values

Source: https://go-critic.com/overview.html

Detects fallthrough statements that can be avoided by combining cases with multiple values.

```go
switch kind {
case reflect.Int:
	fallthrough
case reflect.Int32:
	return Int
}
```

```go
switch kind {
case reflect.Int, reflect.Int32:
	return Int
}
```

--------------------------------

### Optimize slice clear loops

Source: https://go-critic.com/overview.html

Detects inefficient slice clearing loops and suggests using a more idiomatic range-based loop, which may be recognized by the Go compiler for optimization. The original loop iterates using an index, while the suggested idiom uses a range loop.

```go
for i := 0; i < len(buf); i++ { buf[i] = 0 }
```

```go
for i := range buf { buf[i] = 0 }
```

--------------------------------

### Correct Malformed Deprecated Doc-Comments

Source: https://go-critic.com/overview.html

Flags deprecated doc-comments that do not follow the expected format, suggesting the use of 'Deprecated:' prefix.

```go
// deprecated, use FuncNew instead
func FuncOld() int
```

```go
// Deprecated: use FuncNew instead
func FuncOld() int
```

--------------------------------

### Avoid Large Array Parameters

Source: https://go-critic.com/overview.html

Identifies function parameters that are large arrays, suggesting the use of pointers to avoid excessive copying and improve performance.

```go
func f(x [1024]int) {}
```

```go
func f(x *[1024]int) {}
```

--------------------------------

### Avoid rune slice allocation in Go

Source: https://go-critic.com/overview.html

Identifies expressions like `[]rune(s)[0]` that can lead to unnecessary rune slice allocations. It suggests using `utf8.DecodeRuneInString` for better performance.

```go
r := []rune(s)[0]

```

```go
r, _ := utf8.DecodeRuneInString(s)

```

--------------------------------

### Avoid Shadowing Imported Package Names

Source: https://go-critic.com/overview.html

Warns when a variable declaration shadows an imported package name, which can lead to confusion and errors. Suggests using a different variable name.

```go
// "path/filepath" is imported.
filepath := "foo.txt"
```

```go
filename := "foo.txt"
```

--------------------------------

### Reduce Nesting Depth

Source: https://go-critic.com/overview.html

Identifies code blocks with excessive nesting and suggests refactoring to reduce nesting depth, improving readability and maintainability.

```go
for _, v := range a {
	if v.Bool {
		body()
	}
}
```

```go
for _, v := range a {
	if !v.Bool {
		continue
	}
	body()
}
```

--------------------------------

### Detect switch statements convertible to if statements

Source: https://go-critic.com/overview.html

Identifies switch statements with a single case that can be more clearly expressed as an if statement. This rule helps simplify control flow.

```go
switch x := x.(type) {
case int:
	body()
}
```

```go
if x, ok := x.(int); ok {
	body()
}
```

--------------------------------

### Avoid shadowing predeclared identifiers in declarations

Source: https://go-critic.com/overview.html

Detects top-level declarations (like types or functions) that use names which shadow Go's predeclared identifiers. Use distinct names for custom types.

```go
type int struct {}
```

```go
type myInt struct {}
```

--------------------------------

### Fix off-by-one errors in Go slice indexing

Source: https://go-critic.com/overview.html

Identifies common off-by-one errors in Go slice indexing, such as accessing an index equal to the length of the slice. It suggests correcting this to `len(xs)-1` for valid access.

```go
xs[len(xs)]

```

```go
xs[len(xs)-1]

```

--------------------------------

### Simplify slice expressions

Source: https://go-critic.com/overview.html

Detects slice expressions that can be simplified to the slice expression itself, often seen in `copy` operations.

```go
copy(b[:], values...)

```

```go
copy(b, values...)

```

--------------------------------

### Avoid shadowing predeclared identifiers in assignments

Source: https://go-critic.com/overview.html

Detects when local variables are assigned names that shadow Go's predeclared identifiers (e.g., `len`, `int`). Renaming these variables improves clarity.

```go
len := 10
```

```go
length := 10
```

--------------------------------

### Use lowercase for local variables and parameters

Source: https://go-critic.com/overview.html

Enforces the convention of using lowercase names for local variables and function parameters. This checker has a parameter to restrict its scope to parameters only.

```go
func f(IN int, OUT *int) (ERR error) {}
```

```go
func f(in int, out *int) (err error) {}
```

--------------------------------

### Avoid Unwanted Evaluation Order Dependencies

Source: https://go-critic.com/overview.html

Detects and suggests refactoring code where the evaluation order of expressions might lead to unexpected behavior or bugs.

```go
return x, f(&x)
```

```go
err := f(&x)
return x, err
```

--------------------------------

### Simplify boolean expressions

Source: https://go-critic.com/overview.html

Detects boolean expressions that can be simplified for better readability and maintainability. This includes simplifying negations and comparisons.

```go
a := !(elapsed >= expectElapsedMin)
b := !(x) == !(y)
```

```go
a := elapsed < expectElapsedMin
b := (x) == (y)
```

--------------------------------

### Avoid Reassigning External Errors

Source: https://go-critic.com/overview.html

Warns against reassigning error variables from external packages, which can mask actual errors and lead to incorrect program logic.

```go
io.EOF = nil
```

```go
/* don't do it */
```

--------------------------------

### Clean Up Map Literal Keys

Source: https://go-critic.com/overview.html

Identifies map literal keys with extraneous whitespace and suggests removing it for consistency and correctness.

```go
_ = map[string]int{
	"foo": 1,
	"bar ": 2,
}
```

```go
_ = map[string]int{
	"foo": 1,
	"bar": 2,
}
```

--------------------------------

### Detect Commented-Out Code in Functions

Source: https://go-critic.com/overview.html

Identifies commented-out code within function bodies. The `commentedOutCode.minLength` parameter can be used to set the minimum length of a comment to trigger a warning.

```go
// fmt.Println("Debugging hard")
foo(1, 2)
```

```go
foo(1, 2)
```

--------------------------------

### Simplify length checks

Source: https://go-critic.com/overview.html

Flags usages of `len(arr) <= 0` which can be simplified to `len(arr) == 0`. This makes the condition more direct and readable.

```go
len(arr) <= 0
```

```go
len(arr) == 0
```

--------------------------------

### Simplify switch true statements

Source: https://go-critic.com/overview.html

Detects switch statements that explicitly use `true` as the tag value (e.g., `switch true {...}`). It suggests simplifying this to a bare `switch {...}`, which is equivalent and more concise.

```go
switch true {...}
```

```go
switch {...}
```

--------------------------------

### Detect Duplicated Branch Bodies

Source: https://go-critic.com/overview.html

Flags conditional statements (if/else) where the bodies of the branches contain identical code, suggesting a potential logic error.

```go
if cond {
	println("cond=true")
} else {
	println("cond=true")
}
```

```go
if cond {
	println("cond=true")
} else {
	println("cond=false")
}
```

--------------------------------

### Detect Duplicated Option Function Arguments

Source: https://go-critic.com/overview.html

Identifies duplicated option function arguments in variadic function calls, which are usually redundant.

```go
doSomething(name,
		withWidth(w),
		withHeight(h),
		withWidth(w),
)
```

```go
doSomething(name,
		withWidth(w),
		withHeight(h),
)
```

--------------------------------

### Identify Suspicious Duplicated Arguments

Source: https://go-critic.com/overview.html

Detects instances where the same variable or expression is used for multiple arguments where it might be a mistake, such as in the `copy` function.

```go
copy(dst, dst)
```

```go
copy(dst, src)
```

--------------------------------

### Remove unnecessary braced statement blocks

Source: https://go-critic.com/overview.html

Identifies and removes redundant curly braces around single statements, simplifying the code structure.

```go
x := 1
{
	print(x)
}

```

```go
x := 1
print(x)

```

--------------------------------

### Move type definition before method declaration

Source: https://go-critic.com/overview.html

Enforces the convention of defining types before their methods. This improves code readability and organization.

```go
func (r rec) Method() {}
type rec struct{}

```

```go
type rec struct{}
func (r rec) Method() {}

```

--------------------------------

### Ensure exhaustive conditions

Source: https://go-critic.com/overview.html

Detects conditions that might be unsafe due to not being exhaustive. It suggests checking lengths or using more robust checks to prevent panics.

```go
xs != nil && xs[0] != nil

```

```go
len(xs) != 0 && xs[0] != nil

```

--------------------------------

### Detect Duplicated Case Clauses

Source: https://go-critic.com/overview.html

Identifies switch or select statements with duplicate case clauses, which can often be merged for clarity.

```go
switch x {
case ys[0], ys[1], ys[2], ys[0], ys[4]:
}
```

```go
switch x {
case ys[0], ys[1], ys[2], ys[3], ys[4]:
}
```

--------------------------------

### Replace Else With Nested If Using Else-If

Source: https://go-critic.com/overview.html

Detects `else` statements containing a nested `if` that can be simplified into an `else if` structure.

```go
if cond1 {
} else {
	if x := cond2; x {
	}
}
```

```go
if cond1 {
} else if x := cond2; x {
}
```

--------------------------------

### Detect redundant defer calls

Source: https://go-critic.com/overview.html

Flags defer statements that are unnecessary, such as when the deferred function call is the only operation in the block and can be executed directly.

```go
func() {
	defer os.Remove(filename)
}

```

```go
func() {
	os.Remove(filename)
}

```

--------------------------------

### Use type guard in type switches

Source: https://go-critic.com/overview.html

Detects type switches where a type guard clause with a variable can simplify the code. This avoids redundant type assertions within the switch cases.

```go
switch v.(type) {
case int:
	return v.(int)
case point:
	return v.(point).x + v.(point).y
default:
	return 0
}

```

```go
switch v := v.(type) {
case int:
	return v
case point:
	return v.x + v.y
default:
	return 0
}

```

--------------------------------

### Ensure Default Case is First or Last in Switch

Source: https://go-critic.com/overview.html

Detects when the default case in a switch statement is not in the first or last position, promoting a more standard structure.

```go
switch {
case x > y:
	// ...
default: // <- not the best position
	// ...
case x == 10:
	// ...
}
```

```go
switch {
case x > y:
	// ...
case x == 10:
	// ...
default: // <- last case (could also be the first one)
	// ...
}
```

--------------------------------

### Sanitize Flag Names

Source: https://go-critic.com/overview.html

Identifies flag names with leading/trailing spaces or other suspicious characters, recommending cleaner, more conventional names.

```go
b := flag.Bool(" foo ", false, "description")
```

```go
b := flag.Bool("foo", false, "description")
```

--------------------------------

### Remove unnecessary parentheses from type expressions

Source: https://go-critic.com/overview.html

Identifies and suggests removing redundant parentheses within type expressions for cleaner syntax.

```go
type foo [](func([](func())))

```

```go
type foo []func([]func())

```

--------------------------------

### Ensure return after http.Error in Go

Source: https://go-critic.com/overview.html

Detects `http.Error` calls that are not followed by a `return` statement within an `if err != nil` block. This helps prevent unintended execution of subsequent code after an HTTP error has been reported.

```go
if err != nil { http.Error(...); }

```

```go
if err != nil { http.Error(...); return; }

```

--------------------------------

### Simplify function return types

Source: https://go-critic.com/overview.html

Detects functions with a large number of return values and suggests refactoring them into a struct. This improves code readability and maintainability by grouping related return values.

```go
func fn() (a, b, c, d float32, _ int, _ bool)
```

```go
func fn() (resultStruct, bool)
```

--------------------------------

### Detect and Remove Doc-Comment Stubs

Source: https://go-critic.com/overview.html

Identifies comments that are used solely to silence go lint complaints about missing doc-comments. These can be removed or replaced with meaningful comments.

```go
// Foo ...
func Foo() {
}
```

```go
// (A) - remove the doc-comment stub
func Foo() {}
// (B) - replace it with meaningful comment
// Foo is a demonstration-only function.
func Foo() {}
```

--------------------------------

### Replace redundant fmt.Sprint calls in Go

Source: https://go-critic.com/overview.html

Detects redundant `fmt.Sprint` calls where the argument already implements a `String()` method. It suggests calling the `String()` method directly for cleaner code.

```go
fmt.Sprint(x)

```

```go
x.String()

```

--------------------------------

### Remove redundant statement labels

Source: https://go-critic.com/overview.html

Identifies and suggests removing unnecessary labels from statements, especially within loops, when they are not required for control flow.

```go
derp:
for x := range xs {
	if x == 0 {
		break derp
	}
}

```

```go
for x := range xs {
	if x == 0 {
		break
	}
}

```

--------------------------------

### Detect Suspicious Duplicated Sub-expressions

Source: https://go-critic.com/overview.html

Flags identical sub-expressions within a larger expression, which might indicate a copy-paste error.

```go
sort.Slice(xs, func(i, j int) bool {
	return xs[i].v < xs[i].v // Duplicated index
})
```

```go
sort.Slice(xs, func(i, j int) bool {
	return xs[i].v < xs[j].v
})
```

--------------------------------

### Correct suspicious strings.Replace call

Source: https://go-critic.com/overview.html

Identifies potentially incorrect usage of `strings.Replace`, specifically when the count argument is 0, which results in no replacements. Use -1 to replace all occurrences.

```go
strings.Replace(s, from, to, 0)
```

```go
strings.Replace(s, from, to, -1)
```

--------------------------------

### Replace type assertion chains with type switch

Source: https://go-critic.com/overview.html

This rule detects repetitive type assertions and suggests using a type switch for cleaner code. It's useful when checking a variable against multiple types sequentially.

```go
if x, ok := v.(T1); ok {
	// Code A, uses x.
} else if x, ok := v.(T2); ok {
	// Code B, uses x.
} else if x, ok := v.(T3); ok {
	// Code C, uses x.
}

```

```go
switch x := v.(T1) {
case cond1:
	// Code A, uses x.
case cond2:
	// Code B, uses x.
default:
	// Code C, uses x.
}

```

--------------------------------

### Escape special characters in regexp patterns in Go

Source: https://go-critic.com/overview.html

Detects potentially suspicious regular expression patterns that might not be escaping special characters correctly, leading to unintended matches. It suggests escaping characters like '.' to match them literally.

```go
regexp.MustCompile(`google.com|yandex.ru`)

```

```go
regexp.MustCompile(`google\.com|yandex\.ru`)

```

--------------------------------

### Avoid appending all slice data in a range loop in Go

Source: https://go-critic.com/overview.html

Identifies a pattern where a `for...range` loop appends all elements of the iterated slice to another slice within the loop body. It suggests appending individual elements instead for clarity and potential efficiency.

```go
for _, n := range ns {
	// ...
		rs = append(rs, ns...) // append all slice data
	}
}

```

```go
for _, n := range ns {
	// ...
		rs = append(rs, n)
	}
}

```

--------------------------------

### Check for unchecked errors in if statements

Source: https://go-critic.com/overview.html

This diagnostic rule flags if statements where an error is assigned but not checked, potentially leading to unhandled errors.

```go
if err := expr(); err2 != nil { /*...*/ }

```

```go
if err := expr(); err != nil { /*...*/ }

```

--------------------------------

### Correct erroneous case order in switch statements

Source: https://go-critic.com/overview.html

Identifies switch statement cases where a later case might be unreachable because an earlier case covers the same type or value. Reordering can ensure all cases are evaluated correctly.

```go
switch x.(type) {
case ast.Expr:
	fmt.Println("expr")
case *ast.BasicLit:
	fmt.Println("basic lit") // Never executed
}
```

```go
switch x.(type) {
case *ast.BasicLit:
	fmt.Println("basic lit") // Now reachable
case ast.Expr:
	fmt.Println("expr")
}
```

--------------------------------

### Simplify dereference expressions

Source: https://go-critic.com/overview.html

Detects situations where dereferencing a pointer or accessing an array element can be simplified by omitting redundant operators.

```go
(*k).field = 5
v := (*a)[5] // only if a is array

```

```go
k.field = 5
v := a[5]

```

--------------------------------

### Correct erroneous loop condition

Source: https://go-critic.com/overview.html

Detects loops with conditions that are likely incorrect, such as using `>` when `<` was intended, which could lead to unexpected behavior or no iterations.

```go
for i := 0; i > n; i++ {
	xs[i] = 0
}
```

```go
for i := 0; i < n; i++ {
	xs[i] = 0
}
```

--------------------------------

### Simplify redundant type assertions

Source: https://go-critic.com/overview.html

Detects and suggests removing unnecessary type assertions, such as asserting a value to `interface{}` when it already is. This simplifies function return types.

```go
func f(r io.Reader) interface{} {
	return r.(interface{})
}
```

```go
func f(r io.Reader) interface{} {
	return r
}
```

--------------------------------

### Detect suspicious append result assignments

Source: https://go-critic.com/overview.html

Identifies situations where the result of an append operation is assigned in a way that might be unintended. Use when reviewing code for potential logic errors related to slice modifications.

```go
p.positives = append(p.negatives, x)
p.negatives = append(p.negatives, y)
```

```go
p.positives = append(p.positives, x)
p.negatives = append(p.negatives, y)
```
Tokens:
Raw