Code Inspections in Go

'FailNow' in a non-test goroutine

Reports calls to testing.T.FailNow and similar methods located in goroutines in test files.

func TestFoo(t *testing.T) {
  go func() {
    t.Fatal("oops") //exits goroutine, not TestFoo
  }()
}

func TestFoo(t *testing.T) {
  go func() {
    t.Error("oops")
    return
  }()
}

Warning

'Unmarshal' is called with the incorrect argument

Reports calls to json.Unmarshal and similar functions if the argument that is passed to store the result is not a pointer or an interface.

var animals []Animal
err := json.Unmarshal(jsonData, animals) // always returns an error

var animals []Animal
err := json.Unmarshal(jsonData, &animals)

Warning

'context.CancelFunc' is not called

Reports execution paths that do not call the cancel function returned by context.WithCancel and similar functions.

func _(ctx context.Context, cancel func()) {
 var ctx2 context.Context
 ctx2, cancel = context.WithCancel(ctx)
 _ = ctx2
}

Warning

Defer/go statement calls 'recover' or 'panic' directly

Reports defer and go statements that call panic() or recover() directly.

• go panic(): a newly-started goroutine will panic immediately.

• defer panic(): a function with this statement will always panic on exit.

• go recover(): has no effect as newly-started goroutine cannot panic.

• defer recover(): function with this statement will silently stop panicking. This could be a valid usage, but an idiomatic way is to inspect the value returned by recover():

  defer func() {
    if r := recover(); r != nil {
      fmt.Println("Recovered from: ", r)
    }
  }()

Weak warning

Division by zero

Reports division by zero.

s := 3 / 0

Warning

Exceeded shift expression

Reports shift expressions that equal or exceed the width of the integer.

func shift(i int8) {
  fmt.Println(i << 8) // always prints 0
}

Warning

Imported package name as a name identifier

Reports declarations of variables, arguments or functions that overlap with the used import.

import "fmt"
import _ "fmt"
import iio "io"

func _() {
 fmt.Println("demo")
 demo := true
 _, _ = iio.EOF, demo
}

func demo() (int, int) {
 return 1, 2
}

func _() {
 _, _ = iio.EOF, demo
 fmt := "demo"
 iio := 1
 _, _ = iio, fmt
 a, _ := demo()
 _ = a
}

Warning

Impossible interface type assertion

Reports impossible interface-to-interface type assertions.

var v interface {
  Read()
}
_ = v.(io.Reader)

Warning

Incorrect 'strings.Replace' count argument

Reports strings.Replace calls with the replace count 0 instead of -1.

a := strings.Replace("SSS", "S", "H", 0) // replaces nothing
b := strings.Replace("SSS", "S", "H", -1) // replaces all S occurrences with H

Warning

Incorrect usage of 'fmt.Printf' and 'fmt.Println' functions

Reports incorrect usages of fmt.Printf, fmt.Println, and similar formatting and printing functions.

fmt.Printf("id: %s", 42)

fmt.Printf("id: %d", 42)

Weak warning

Incorrect usage of the 'errors.As' function

Reports calls of the errors.As function when the second argument is not a pointer to an interface or to a type that implements an error.

_, err := os.Open("non-existing")
var pathError *fs.PathError
if errors.As(err, pathError) { // a pointer to *fs.PathError is required
}

_, err := os.Open("non-existing")
var pathError *fs.PathError
if errors.As(err, &pathError) {
}

Warning

Incorrect usage of the 'sync/atomic' package

Reports assignment statements of the form x = atomic.AddUint64(&x, 1).

import (
 "sync/atomic"
)

type Counter uint64

func AtomicTests() {
 x := uint64(1)
 x = atomic.AddUint64(&x, 1)         // ERROR "direct assignment to atomic value"
 _, x = 10, atomic.AddUint64(&x, 1)  // ERROR "direct assignment to atomic value"
 x, _ = atomic.AddUint64(&x, 1), 10  // ERROR "direct assignment to atomic value"
}

Warning

Integer to string type conversion

Reports conversions of string(x)-alike expressions where x is an integer but not byte or rune.

func main() {
 a := 1
 _ = string(a)
}

func main() {
 a := 1
 _ = string(rune(a))
}

Warning

Invalid conversions of 'uintptr' to 'unsafe.Pointer'

Reports possibly incorrect conversions of uintptr to unsafe.Pointer.

nums := []int8{42, 24}
ptr := unsafe.Pointer(&nums[0])
addr := uintptr(ptr) // address is stored to a local variable
ptr = unsafe.Pointer(addr + uintptr(1))

nums := []int8{42, 24}
ptr := unsafe.Pointer(&nums[0])
ptr = unsafe.Pointer(uintptr(ptr) + uintptr(1))

Warning

Locks mistakenly passed by value

Reports locks that are mistakenly passed by values.

type SafeInt struct {
  m sync.Mutex
  i int
}

func (s SafeInt) Inc() { // mutex is copied
  s.m.Lock()
  s.i++
  s.m.Unlock()
}

type SafeInt struct {
  m sync.Mutex
  i int
}

func (s *SafeInt) Inc() {
  s.m.Lock()
  s.i++
  s.m.Unlock()
}

Warning

Loop variables captured by the func literal

Reports references to loop variables from within func literals in defer and go statements. Such variables might have unexpected values because they are not copied to func literals, and the func literals in defer and go are not executed immediately.

for _, v := range []string{"a", "b", "c"} {
  go func() {
    fmt.Println(v) // output will likely be `c c c`, not `a b c`
  }()
}

for _, v := range []string{"a", "b", "c"} {
  v := v // `v` is copied now
  go func() {
    fmt.Println(v)
  }()
}

Warning

Malformed build tag

Reports malformed build tags and build tags in the incorrect location. The go tool expects build tags to be located in particular places and follow a special syntax. If these requirements are not followed, build tags could either be ignored or the files could be incorrectly excluded from the build.

package main

// +build ignore

func main() {}

// +build ignore

package main

import "fmt"

Weak warning

Malformed struct tag

Reports struct tags that do not conform to Go conventions for struct tags.

type Example struct {
  Field int `json:"field" xml:"demo"`
}

Warning

Non-standard signature for well-known function names

Reports methods with certain names in the following cases:

• the method's name matches the name of several well-known interface methods from the standard library

• the signature does not match the signature of the corresponding interface method

type MyReader []byte

func (r MyReader) ReadByte(data []byte) (byte, error) {
}

type MyReader []byte

func (r MyReader) ReadByte() (byte, error) {
}

Warning

Reserved word used as name

Reports declarations of variables, arguments or functions that overlap with the built-in or reserved keyword.

type byte struct{}
type string interface{}

Warning

Shadowing variable

Reports declarations of variables that overlap with the declarations in the outer scope.

for i := 0; i < len(nums); i++ {
    for i := 0; i < len(nums); i++ {
    }
  }

for i := 0; i < len(nums); i++ {
    for j := 0; j < len(nums); j++ {
    }
  }

No highlighting, only fix

Unhandled error

Reports calls to functions and methods that do not handle the call result of the error type.

os.Remove("non-existing") // error is ignored

err := os.Remove("non-existing") // error is handled
if err != nil {
  return err
}

Warning

Unused function or method call result

Reports calls to certain functions and methods that do not handle a call result.

fmt.Errorf("error: %s", reason) // constructed error is ignored

err := fmt.Errorf("error: %s", reason)

Warning

'defer' in the loop

Reports defer statements inside loops.

func main() {
 for {
  field, err := db.Query("SELECT 1")
  if err != nil {
   // ...
  }
  defer field.Close()
  // ...
 }
}

Weak warning

Assignment to a receiver

Reports assignments to method receivers.

package main

import "fmt"

type demo struct {
 Val int
}

func (d *demo) change() {
 d = nil // Assignment to the method receiver propagates only to callees but not to callers
 d.myVal()
}

func (d *demo) myVal() {
 fmt.Printf("my val: %#v\n", d)
}

func (d demo) change2() {
 d = demo{} // Assignment to the method receiver doesn't propagate to other calls
 d.myVal()
}

func (d *demo) change3() {
 d.Val = 3
 d.myVal()
}

func main() {
 d := &demo{}
 d.myVal()
 d.change()
 d.myVal()
 d.Val = 2
 d.change2()
 d.myVal()
 d.change3()
 d.myVal()
}

Weak warning

Infinite 'for' loop

Reports empty for loops.

func main() {
 for {
 }
}

Warning

Unreachable code

Reports code that can never be executed because there exists no control flow path to the code from the rest of the program.

func _() int {
 print(1)
 return 2
 println() // This code is unreachable
 return 0
}

Warning

Comment has no leading space

Reports comments without a leading space.

//Prints JSON received from the createJSON function
func printJSON(output []byte) {
	fmt.Println(string(output))
}

Weak warning

Comment of exported element starts with the incorrect name

Reports comments that do not start with the name of the exported element.

// represents a request to run a command.
type Request struct {}

// Request represents a request to run a command.
type Request struct {} // better

Weak warning

Error string should not be capitalized or end with punctuation

Reports format issues in error strings.

err := fmt.Errorf("Cannot read the file!")
log.Printf("Reading %s: %v", file, err)

Weak warning

Exported element should have a comment

Reports exported declarations without a documentation comment. According to Doc Comments at golang.org, all top-level exported names should have doc comments.

Disabled

Exported element should have its own declaration

Reports exported variables or constants in comma-separated lists of declarations.

const C1, C3, C2, C44, C9, C11, C6 = 1, 2, 3, 1, 3, 2, 1

const (
 C3  = 2
 C2  = 3
 C44 = 1
 C9  = 3
 C11 = 2
 C6  = 1
 C1  = 1
)

Weak warning

Name starts with a package name

Reports exported names that start with a package name. This inspection does not report such names in the main package.

package myPackage

func MyPackageGetIP() {

}

Weak warning

Receiver has a generic name

Reports receiver names like me, this, self, or names that differ from other receiver names for this type.

func (self *MeterSnapshot) Rate5() float64 { return math.Float64frombits(self.rate5) }

Weak warning

Struct initialization without field names

Reports structures that are initialized without specifying their field names. By default, the inspection is available only when you use the type that is defined in a different package.

_ = io.LimitedReader{nil, 10}

_ = io.LimitedReader{N: 10}

• Report types defined in current package: reports situations when you declare and initialize struct in the same package. Consider the following example.

  d := struct {
    c string
   }{ "dsd "}

• Report struct literals without types: reports fields without names when the type (struct or interface) is omitted. Consider the following example when the type is omitted.

  _ = []io.LimitedReader{
   {nil, 10},
   {nil, 20},
   }

  In the following example, the type is present but is redundant.

  _ = []io.LimitedReader{
   io.LimitedReader{nil, 10},
   io.LimitedReader{nil, 20},
  }

Weak warning

Unit-specific suffix for 'time.Duration'

Reports unit-specific suffixes in constant and variable names of time.Duration type.

var timeoutSeconds = 5 * time.Second

Weak warning

Unsorted imports

Reports unsorted imports.

import (
 "net"
 "errors"
 "fmt"
)

import (
 "errors"
 "fmt"
 "net"
)

Weak warning

Usage of Snake_Case

Reports usage of snake case instead of camelcase for naming variables, constants and functions. According to MixedCaps at golang.org, camelcase is a convention in Go.

func get_external_IP() (string, error) {}

Weak warning

Deprecated element

Reports usages of deprecated elements.

// Deprecated: Use io.SeekStart, io.SeekCurrent, and io.SeekEnd.
const (
 SEEK_SET int = 0 // seek relative to the origin of the file
 SEEK_CUR int = 1 // seek relative to the current offset
 SEEK_END int = 2 // seek relative to the end
)

Warning

Disabled GOPATH indexing

Reports disabled GOPATH indexing that might prevent proper resolution of code references.

Weak warning

Malformed test function name

Reports malformed names of tests, benchmarks, and examples.

func Testfoo(*testing.T) {} // the 'go' tool will not run this test

func TestFoo(*testing.T) {}

Warning

Missing trailing comma before a newline in a composite literal

Reports a missing trailing comma before a newline in composite literals, function call arguments, and function parameter lists.

func f(f int) (
 int,
 bool   // missing a trailing comma
){
 println(1, 2  // missing a trailing comma
 )
}

Error

Redundant parentheses

Reports redundant parentheses in expressions and types.

func _(x (int), y ((string))) {
}
func _() {
 _ = (1 + 1)
 _ = (((1 + 1)))
 _ = (((1 + 1))) + (((2 + 2)))
}

func _(x int, y string) {
}
func _() {
 _ = 1 + 1
 _ = 1 + 1
 _ = (1 + 1) + (2 + 2)
}

Weak warning

Unexported return type of the exported function

Reports exported functions with unexported return types.

type hidden struct{}

func Exported() hidden { // Exported function with the `hidden` unexported return type
 return hidden{}
}

Warning

Unnecessarily exported identifier

Reports exported identifiers that are used only in the package where they are defined but are not used in other packages.

Disabled

Bool condition

Reports parts of boolean expressions that are either always true, always false, or redundant. Such boolean expressions can be simplified, which may improve a readability of the code. In some cases, this also indicates a presence of other issues.

func isNonZero(x, y int) bool {
  // the second comparison is either always true
  // or not executed at all
  return x > 0 && x > 0
}

Warning

Empty declaration

Reports empty declarations.

func main() {
 const () // empty declaration
}

Warning

Empty slice declared using a literal

Reports slice declarations with empty literal initializers used instead of nil.

s := []string{}

var s []string

Weak warning

Redundant blank argument in range

Reports optional blank variables in range loops.

for a, _ = range v {} // `for a, _ =` is the same as `for a =`

for a = range v {}

Warning

Redundant comma

Reports commas that may be omitted in the end of argument lists and composite literals.

s := []int{1, 2,} // the last comma may be omitted

Weak warning

Redundant import alias

Reports aliases of imported packages that may be omitted.

import fmt "fmt"

import "fmt"

Weak warning

Redundant second index in slices

Reports a redundant second index (a high bound) in slice expressions.

var a []int
a = a[0:len(a)] // `a[0:len(a)]` is the same as `a[0:]`

var a []int
a = a[0:]

Warning

Redundant semicolon

Reports redundant semicolons. Idiomatic Go programs have semicolons only in places such as for loop clauses, to separate the initializer, condition, and continuation elements. They are also necessary to separate multiple statements on a line. In other cases, you can omit them.

i := 1;

Weak warning

Redundant type conversion

Reports type conversions that may be omitted.

var s = string("hello")

var s = "hello"

Weak warning

Redundant types in composite literals

Reports redundant type declarations in composite literals.

nums := [][]int{[]int{1}, []int{2}}

nums := [][]int{{1},{2}}

Warning

Self assignment

Reports expressions that are assigned to themselves.

func importedVarSelfAssignment() {
 http.ErrNotSupported = http.ErrNotSupported
}

Weak warning

Type can be omitted

Reports types in variable and constant declarations that can be omitted since they can be inferred by the compiler. Such types are redundant, omitting them may improve readability of the code.

var s string = fmt.Sprintln("hi")

var s = fmt.Sprintln("hi")

Weak warning

Unused constant

Reports constants that are defined but are never used in code.

func main() {
 const i = 100
}

Warning

Unused exported function

Reports unused exported functions.

// Unused exported function
func ExportedUnusedFunc()  {

}

func main() {
 fmt.Println("Hello")
}

Warning

Unused exported type

Reports unused exported types in the main package and in tests. For more information about exported identifiers, see Exported identifiers at golang.org.

type User struct {}

func main() {}

Warning

Unused function

Reports unused unexported functions.

// Unused unexported function
func unExportedUnusedFunc()  {

}

func main() {
 fmt.Println("Hello")
}

Warning

Unused global variable

Reports global variables that are defined but are never used in code.

func main() {
 a := 422
}

func main() {
 _ := 422
}

Warning

Unused parameter

Reports unused function parameters.

func main() {
 printAll(
  42,
  "bird",
 )
}

func printAll(
 i int,
 s string,
) {
 fmt.Println(i)
}

Warning

Unused type

Reports unused types.

type user struct {
 FirstName string    `json:"firstname"`
 LastName  string    `json:"lastname"`
}

func main() {

}

Warning