Code Inspections in Go

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

See Handling panics and Go statements.

Reports division by zero.

Division by zero will lead to a runtime panic.

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

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

While legal, such declarations will make using the package exported identifiers impossible after the declaration or create confusion when reading the code.

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

The count argument for how many times a string should be replaced should not be 0 as it will not replace anything and make the function call redundant. Use -1 instead.

Reports incorrect usage of Println -like and Printf -like functions.

Checks that the second argument to errors.As is a pointer to an interface or to a type implementing error.

See: https://golang.org/pkg/errors/#As

Reports common mistaken usages of the sync/atomic package.

Checks for invalid conversions of uintptr to unsafe/Pointer.

Reports likely incorrect uses of unsafe/Pointer to convert integers to pointers. A conversion from uintptr to unsafe/Pointer is invalid if it implies that there is a uintptr -typed word in memory that holds a pointer value, because that word will be invisible to stack copying and to the garbage collector.

Checks for locks mistakenly passed by value.

Inadvertently copying a value containing a lock (which is a type implementing sync/Locker, such as sync/Mutex or sync/WaitGroup), may cause both copies to work incorrectly. Generally such values should be referred to through a pointer.

Reports references to loop variables from within nested functions.

This analyzer checks for references to loop variables from within a function literal inside the loop body. It checks only instances where the function literal is called in a defer or go statement that is the last statement in the loop body.

See: Go Closures and Goroutines FAQ

Reports malformed build tags and build tags in the incorrect location.

See go build command: build constraints.

Reports that the struct tags conforms to Go conventions.

According to these conventions, tag strings are a concatenation of optionally space-separated key:"value" pairs. Each key is a non-empty string consisting of non-control characters other than space (U+0020 ' '), quote (U+0022 '"'), and colon (U+003A ':'). Each value is quoted using U+0022 '"' characters and Go string literal syntax.

Also, checks that fields with tags are exported.

Example of a good tag is:

Reports problems caused by incorrect use of nil value.

Analyses the data flow to determine if variables could have nil or not nil values. Based on this, reports potential bugs in the code. For example:

• Method calls with nil receiver could lead to 'nil pointer dereference'.

• nil slice indexing could cause panics.

• Comparisons like v == nil could be meaningless if v is known to be always nil or not nil.

• Variable has a corresponding error and it is not checked to be not nil. An error corresponds to a variable when they are defined or assigned together in statements like v, err := foo().

Checks that method whose name matches one of several well-known interface methods from the standard library has the correct signature.

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

If you receive this error then your code might not be as explicit as possible and might confuse other users.

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

Reports calls to functions/methods that return an error if the error is not handled.

Analyzes calls to functions such as json.Unmarshal. Reports a problem if the argument that is passed to store the result is not a pointer or an interface. Such calls are guaranteed to fail and return an error.

See: https://golang.org/pkg/encoding/json/#Unmarshal

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

Reports assignment to method receiver.

When assigning a value to the method receiver it won't be reflected outside of the method itself.

Values will be reflected in subsequent calls from the same method.

Reports defer statements inside loops.

Using defer in loops can lead to resource leaks or unpredictable execution order of the statements.

Reports empty for loops.

Running this code will make the CPU usage stay at maximum and will make the machine nearly unusable.

Reports missing return at end of function.

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

Reports assignments which are used as values.

Reports comments without a leading space.

Comments with leading space can be easier to read since the first word is separated from the comment by a space.

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

See Code review comments: comment sentences.

Reports error strings format issues.

Error strings should not be capitalized or end with punctuation mark.

See Code review comments: error strings for more details.

Reports exported types, functions, methods, constants and variables without comment.

See Code review comments: comment sentences and Code review comments: doc comments.

Reports an exported var or const in a comma separated list of declarations. For example:

Reports names starts with package name.

See Code review comments: package names for details.

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

See Code review comments: receiver names for details.

Reports structures which are initialized without specifying their field names.

When initializing a structure, it's better to explicitly state the name of the fields in order to ensure that in case of changes in the order of the fields or the name of the fields they will correctly continue to be addressed.

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

Reports unsorted imports.

Reports usage of snake case instead of camelcase for naming variables, constants and functions.

See Effective Go: MixedCaps.

Reports assignment of nil without explicit type.

nil value cannot be assigned to a variable that has no type.

Examples of incorrect code: incorrect := nil var incorrect = nil

Examples of correct code: incorrect := nil var correct *MyType = nil

Reports incompatible types in binary and unary expressions.

Reports usages of deprecated elements.

Checks switch statements for case duplicates.

Reports names redeclared in this block.

Reports var assignments in var or const declaration.

Reports method calls and field accesses on expressions with a double pointer type.

Such expressions require explicit dereference, for example, x.f() must be replaced with (*x).f().

Reports method expressions with extended receiver type syntax available since Go 1.10.

In Go versions prior 1.10 a receiver type of a method expression is restricted to be a type name or a pointer to type name.

Since Go 1.10 a receiver type can be any type.

This inspection checks function calls.

Reports impossible type assertions.

Reports composite literals with incompatible types and values.

Reports invalid expression conversion.

Conversion expression may be incorrect due to incompatible types or impermissible constant value truncation.

Reports invalid index and slice expressions.

Reports address operators applied to wrong operands.

Address operation can only be applied to addressable operand and pointer indirection can only be applied to operand of a pointer type.

See Go specifications: address operators.

Reports invalid imports.

Reports invalid receiver types.

Receiver type must be of the form T or *T (possibly using parentheses) where T is a type name.

T must not be a pointer or interface type and it must be declared in the same package as the method.

Reports recursive types declarations.

Reports goto statements which jumps over declaration.

For example:

Reports comparisons of string index with a single-byte string instead of byte.

Reports missing trailing comma before newline in composite literal.

Reports multiple packages in a single directory.

Reports non-function calls.

For example: f := 2 f() // error

Reports redundant parentheses in expressions and types.

Reports self-imports.

Reports incompatible types.

Reports underscores that are used as values.

Reports unexpected tildes.

Reports exported functions with unexported return types.

Unexported types can be difficult to use when viewing documentation under go doc.

Reports exported identifiers that are not used by other packages than the ones they are defined in.

Reports unresolved references.

Reports cgo import in test files.

Test files are not allowed to import the C package.

Reports invalid test functions signatures.

Reports redundant and suspect parts of boolean expressions.

Reports empty declarations.

Reports slice declaration with empty literal initializer instead of nil.

An empty slice can be represented by nil or an empty slice literal. The first approach is preferred as it does not lead to memory allocation.

See Code review comments: declaring empty slices.

Reports expressions of range clause which are redundant and can be deleted.

For example following for statements can be simplified:

Reports redundant comma in the end of argument lists and composite literals.

Reports import aliases that can be omitted.

Reports redundant second index in slices inspection.

Example: a[0:len(a)].

Reports redundant semicolons.

Reports redundant type conversion that can be omitted.

Example: var s = string("hello").

Reports redundant types in composite literals.

For example: [][]int{[]int{1}, []int{2}}

can be simplified to: [][]int {{1}, {2}}.

Reports self assignment.

Reports variable and constant types that can be omitted since it can be inferred by the compiler.

Reports unused constants.

Reports unused exported functions.

Reports unused exported types in main package and in tests.

Reports unused unexported functions.

Reports for unused global variables.

Reports unused import statements.

Reports unused label definitions.

Reports unused function parameters.

Reports unused types.

Reports unused variables.