Vet is a tool that checks correctness of Go programs. It runs a suite of tests, each tailored to check for a particular class of errors. Examples include incorrect Printf format verbs or malformed build tags. Over time many checks have been added to vet's suite, but many more have been rejected as not appropriate for the tool. The criteria applied when selecting which checks to add are: Correctness: Vet's tools are about correctness, not style. A vet check must identify real or potential bugs that could cause incorrect compilation or execution. A check that only identifies stylistic points or alternative correct approaches to a situation is not acceptable. Frequency: Vet is run every day by many programmers, often as part of every compilation or submission. The cost in execution time is considerable, especially in aggregate, so checks must be likely enough to find real problems that they are worth the overhead of the added check. A new check that finds only a handful of problems across all existing programs, even if the problem is significant, is not worth adding to the suite everyone runs daily. Precision: Most of vet's checks are heuristic and can generate both false positives (flagging correct programs) and false negatives (not flagging incorrect ones). The rate of both these failures must be very small. A check that is too noisy will be ignored by the programmer overwhelmed by the output; a check that misses too many of the cases it's looking for will give a false sense of security. Neither is acceptable. A vet check must be accurate enough that everything it reports is worth examining, and complete enough to encourage real confidence.
Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string. Vet uses heuristics that do not guarantee all reports are genuine problems, but it can find errors not caught by the compilers.
It can be invoked three ways:
By package, from the go tool:
go vet package/path/name
vets the package whose path is provided.
go tool vet source/directory/*.go
vets the files named, all of which must be in the same package.
go tool vet source/directory
recursively descends the directory, vetting each package it finds.
Vet's exit code is 2 for erroneous invocation of the tool, 1 if a problem was reported, and 0 otherwise. Note that the tool does not check every possible problem and depends on unreliable heuristics so it should be used as guidance only, not as a firm indicator of program correctness.
By default the -all flag is set so all checks are performed. If any flags are explicitly set to true, only those tests are run. Conversely, if any flag is explicitly set to false, only those tests are disabled. Thus -printf=true runs the printf check, -printf=false runs all checks except the printf check.
Assembly declarations ¶
Mismatches between assembly files and Go function declarations.
Useless assignments ¶
Check for useless assignments.
Atomic mistakes ¶
Common mistaken usages of the sync/atomic package.
Boolean conditions ¶
Mistakes involving boolean operators.
Build tags ¶
Badly formed or misplaced +build tags.
Invalid uses of cgo ¶
Detect some violations of the cgo pointer passing rules.
Unkeyed composite literals ¶
Composite struct literals that do not use the field-keyed syntax.
Copying locks ¶
Locks that are erroneously passed by value.
Tests, benchmarks and documentation examples ¶
Mistakes involving tests including functions with incorrect names or signatures and example tests that document identifiers not in the package.
Failure to call the cancelation function returned by context.WithCancel.
The cancelation function returned by context.WithCancel, WithTimeout, and WithDeadline must be called or the new context will remain live until its parent context is cancelled. (The background context is never cancelled.)
Non-standard signatures for methods with familiar names, including:
Format GobEncode GobDecode MarshalJSON MarshalXML Peek ReadByte ReadFrom ReadRune Scan Seek UnmarshalJSON UnreadByte UnreadRune WriteByte WriteTo
Nil function comparison ¶
Comparisons between functions and nil.
Printf family ¶
Suspicious calls to functions in the Printf family, including any functions with these names, disregarding case:
Print Printf Println Fprint Fprintf Fprintln Sprint Sprintf Sprintln Error Errorf Fatal Fatalf Log Logf Panic Panicf Panicln
The -printfuncs flag can be used to redefine this list. If the function name ends with an 'f', the function is assumed to take a format descriptor string in the manner of fmt.Printf. If not, vet complains about arguments that look like format descriptor strings.
It also checks for errors such as using a Writer as the first argument of Printf.
Struct tags ¶
Range loop variables ¶
Incorrect uses of range loop variables in closures.
Shadowed variables ¶
Flag: -shadow=false (experimental; must be set explicitly)
Variables that may have been unintentionally shadowed.
Shifts equal to or longer than the variable's length.
Struct tags ¶
Struct tags that do not follow the format understood by reflect.StructTag.Get. Well-known encoding struct tags (json, xml) used with unexported fields.
Unreachable code ¶
Misuse of unsafe Pointers ¶
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.
Unused result of certain function calls ¶
Calls to well-known functions and methods that return a value that is discarded. By default, this includes functions like fmt.Errorf and fmt.Sprintf and methods like String and Error. The flags -unusedfuncs and -unusedstringmethods control the set.
Other flags ¶
These flags configure the behavior of vet:
-all (default true) Enable all non-experimental checks. -v Verbose mode -printfuncs A comma-separated list of print-like function names to supplement the standard list. For more information, see the discussion of the -printf flag. -shadowstrict Whether to be strict about shadowing; can be noisy.
Vet is a simple checker for static errors in Go source code. See doc.go for more information.
Source Files ¶
This package constructs a simple control-flow graph (CFG) of the statements and expressions within a single function.
|This package constructs a simple control-flow graph (CFG) of the statements and expressions within a single function.|
Package whitelist defines exceptions for the vet tool.
|Package whitelist defines exceptions for the vet tool.|