How to use the command 'go vet' (with examples)

The ‘go vet’ command is a tool provided by the Go programming language that checks Go source code for suspicious constructs. It can help identify potential issues or bugs in the code, similar to a linter. This command returns a non-zero exit code if it finds any problems and a zero exit code if no issues are found. It is a useful tool for ensuring the quality and correctness of Go code.

Use case 1: Check the Go package in the current directory

Code:

go vet

Motivation: The first use case is simply running ‘go vet’ without any additional arguments. This will check the Go package in the current directory and report any suspicious constructs or problems it finds. This is useful when you want to quickly check the code in the current directory.

Explanation: The command ‘go vet’ without any arguments will automatically check the Go package in the current directory. It will analyze the code and identify any suspicious constructs or issues it detects.

Example output:

# main
./main.go:5: `main` function with wrong signature: func main()
        Main should have signature `func()`, not `func main()`

In this example output, ‘go vet’ identified an issue in the ‘main’ function in the ‘main.go’ file. It reports that the ‘main’ function has the wrong signature, as it should be func() instead of func main().

Use case 2: Check the Go package in the specified path

Code:

go vet path/to/file_or_directory

Motivation: In some cases, you may want to check a specific Go package located in a different directory than the current one. This use case allows you to specify the path to the package you want to check.

Explanation: By providing the path to a specific file or directory in the command, ‘go vet’ will analyze the Go package at that location and report any suspicious constructs it finds.

Example output:

# file.go
./path/to/file.go:10: undefined: SomeFunc

In this example output, ‘go vet’ found an issue in the ‘file.go’ file located in the ‘path/to’ directory. It reports that ‘SomeFunc’ is undefined, indicating a potential problem in the code.

Use case 3: List available checks that can be run with go vet

Code:

go tool vet help

Motivation: If you want to explore the available checks that can be run with ‘go vet’, this use case allows you to list them. It can be useful for understanding what specific aspects of your code the command checks for.

Explanation: The command ‘go tool vet help’ lists the available checks that can be run with ‘go vet’. It provides a list of check names that can be used with the ‘go tool vet help check_name’ command to view details and flags for a particular check.

Example output:

The following checks are known:
asmdecl       check assembly against Go declarations
assign        check for useless assignments
atomic        check for common mistakes using the sync/atomic package
bools         check for common mistakes involving boolean operators
build         check that the package is built using 'go build'
...

In this example output, ‘go tool vet help’ gives a list of available checks. It includes check names like ‘asmdecl’, ‘assign’, ‘atomic’, and ‘bools’, among others.

Use case 4: View details and flags for a particular check

Code:

go tool vet help check_name

Motivation: When you want to know more about a specific check and the flags it supports, this use case allows you to view the details and flags for that check. It gives you a better understanding of how the check works and how it can be customized.

Explanation: By providing the name of a specific check in the command, ‘go tool vet help check_name’ will display the details and flags associated with that check. It provides information on how the check works, what it looks for, and any additional configuration options available.

Example output:

asmdecl is an assembly against Go declarations checker.

asmdecl reports mismatches between assembly files and Go declaration files in the same package. For example, it looks for assembly functions that refer to Go global variables that don't exist, or vice versa.

Flags:
  -all
        report all mismatches (not just the first one)

In this example output, ‘go tool vet help asmdecl’ provides details about the ‘asmdecl’ check. It explains that the check reports mismatches between assembly files and Go declaration files in the same package. It also mentions the ‘-all’ flag, which can be used to report all mismatches instead of just the first one.

Use case 5: Display offending lines plus N lines of surrounding context

Code:

go vet -c=N

Motivation: If you want to see the specific lines of code that are causing issues, along with some surrounding context, this use case allows you to specify the number of lines of context to display. It can help you locate the problematic code and understand its surrounding context better.

Explanation: By using the ‘-c=N’ flag in the ‘go vet’ command, where ‘N’ is the number of lines of context to display, you can see the offending lines of code along with ‘N’ lines of surrounding context. It helps provide a better understanding of the code and its potential issues.

Example output:

# main
./main.go:5: `main` function with wrong signature: func main()
        Main should have signature `func()`, not `func main()`
        func main() {

In this example output, ‘go vet -c=2’ highlights the ‘main’ function with the wrong signature. It shows the line causing the issue along with two lines of surrounding context, providing more context about the problem.

Use case 6: Output analysis and errors in JSON format

Code:

go vet -json

Motivation: If you want to process the analysis and errors reported by ‘go vet’ programmatically or in a specific format, this use case allows you to output the analysis and errors in JSON format. It facilitates further processing, automation, or integration into other tools.

Explanation: By using the ‘-json’ flag in the ‘go vet’ command, the analysis and errors are outputted in JSON format. This allows for easy parsing and processing of the information for further use.

Example output:

{
  "Package": "main",
  "Errors": [
    {
      "Pos": "/path/to/file.go:10:1",
      "Message": "undefined: SomeFunc"
    }
  ]
}

In this example output, ‘go vet -json’ outputs the analysis and errors in JSON format. It includes the package name as well as a list of errors, each containing the position and corresponding error message.

Conclusion:

The ‘go vet’ command is a powerful tool for checking Go source code and identifying suspicious constructs or potential issues. By using the various command options and flags, you can customize the analysis and output to suit your needs. It helps ensure the quality and correctness of your Go code while providing helpful feedback and recommendations to improve your codebase.