Go Analysis Framework: modular static analysis by go team
摘要
该包定义了模块化静态分析与分析驱动程序之间的接口。Analyzer 静态描述分析函数，包括名称、文档、标志、与其他分析器的关系及执行逻辑；Pass 描述对单个 Go 包的分析工作，提供语法树、类型信息、报告诊断（Diagnostic）的操作，以及访问依赖分析器结果的机制。支持 Facts 用于跨包的事实保存与传递，实现类似单独编译的模块化分析；Facts 需可序列化（使用 gob 编码）。还提供 Validate 函数检查配置、analysistest 子包用于测试，以及 singlechecker 和 multichecker 子包简化独立命令的创建。
荐读理由
Analyzer 接口、Requires 依赖图和 Facts 机制让你直接定义模块化 checker，Facts 自动跨包传播对象事实，驱动程序处理序列化与传播，拿来就能写自定义 Go 静态分析工具
原文
analysis
package
Opens a new window with list of versions in this module.
Latest Latest
This package is not in the latest version of its module.
Go to latest Published: Jul 9, 2026 License: BSD-3-Clause
Opens a new window with license information.
Opens a new window with list of imports.
Opens a new window with list of known importers.
Documentation ¶
Overview ¶
Package analysis defines the interface between a modular static analysis and an analysis driver program.
Background ¶
A static analysis is a function that inspects a package of Go code and reports a set of diagnostics (typically mistakes in the code), and perhaps produces other results as well, such as suggested refactorings or other facts. An analysis that reports mistakes is informally called a "checker". For example, the printf checker reports mistakes in fmt.Printf format strings.
A "modular" analysis is one that inspects one package at a time but can save information from a lower-level package and use it when inspecting a higher-level package, analogous to separate compilation in a toolchain. The printf checker is modular: when it discovers that a function such as log.Fatalf delegates to fmt.Printf, it records this fact, and checks calls to that function too, including calls made from another package.
By implementing a common interface, checkers from a variety of sources can be easily selected, incorporated, and reused in a wide range of driver programs including command-line tools (such as vet), text editors and IDEs, build and test systems (such as go build, Bazel, or Buck), test frameworks, code review tools, code-base indexers (such as SourceGraph), documentation viewers (such as godoc), batch pipelines for large code bases, and so on.
Analyzer ¶
The primary type in the API is Analyzer. An Analyzer statically describes an analysis function: its name, documentation, flags, relationship to other analyzers, and of course, its logic.
To define an analysis, a user declares a (logically constant) variable of type Analyzer. Here is a typical example from one of the analyzers in the go/analysis/passes/ subdirectory:
package unusedresult
var Analyzer = &analysis.Analyzer{
Name: "unusedresult",
Doc: "check for unused results of calls to some functions",
Run: run,
...
}
func run(pass *analysis.Pass) (interface{}, error) {
...
}
An analysis driver is a program such as vet that runs a set of analyses and prints the diagnostics that they report. The driver program must import the list of Analyzers it needs. Typically each Analyzer resides in a separate package. To add a new Analyzer to an existing driver, add another item to the list:
import ( "unusedresult"; "nilness"; "printf" )
var analyses = []*analysis.Analyzer{
unusedresult.Analyzer,
nilness.Analyzer,
printf.Analyzer,
}
A driver may use the name, flags, and documentation to provide on-line help that describes the analyses it performs. The doc comment contains a brief one-line summary, optionally followed by paragraphs of explanation.
The Analyzer type has more fields besides those shown above:
type Analyzer struct {
Name string
Doc string
Flags flag.FlagSet
Run func(*Pass) (interface{}, error)
RunDespiteErrors bool
ResultType reflect.Type
Requires []*Analyzer
FactTypes []Fact
}
The Flags field declares a set of named (global) flag variables that control analysis behavior. Unlike vet, analysis flags are not declared directly in the command line FlagSet; it is up to the driver to set the flag variables. A driver for a single analysis, a, might expose its flag f directly on the command line as -f, whereas a driver for multiple analyses might prefix the flag name by the analysis name (-a.f) to avoid ambiguity. An IDE might expose the flags through a graphical interface, and a batch pipeline might configure them from a config file. See the "findcall" analyzer for an example of flags in action.
The RunDespiteErrors flag indicates whether the analysis is equipped to handle ill-typed code. If not, the driver will skip the analysis if there were parse or type errors. The optional ResultType field specifies the type of the result value computed by this analysis and made available to other analyses. The Requires field specifies a list of analyses upon which this one depends and whose results it may access, and it constrains the order in which a driver may run analyses. The FactTypes field is discussed in the section on Modularity. The analysis package provides a Validate function to perform basic sanity checks on an Analyzer, such as that its Requires graph is acyclic, its fact and result types are unique, and so on.
Finally, the Run field contains a function to be called by the driver to execute the analysis on a single package. The driver passes it an instance of the Pass type.
Pass ¶
A Pass describes a single unit of work: the application of a particular Analyzer to a particular package of Go code. The Pass provides information to the Analyzer's Run function about the package being analyzed, and provides operations to the Run function for reporting diagnostics and other information back to the driver.
type Pass struct {
Fset *token.FileSet
Files []*ast.File
OtherFiles []string
IgnoredFiles []string
Pkg *types.Package
TypesInfo *types.Info
ResultOf map[*Analyzer]interface{}
Report func(Diagnostic)
...
}
The Fset, Files, Pkg, and TypesInfo fields provide the syntax trees, type information, and source positions for a single package of Go code.
The OtherFiles field provides the names of non-Go files such as assembly that are part of this package. Similarly, the IgnoredFiles field provides the names of Go and non-Go source files that are not part of this package with the current build configuration but may be part of other build configurations. The contents of these files may be read using Pass.ReadFile; see the "asmdecl" or "buildtags" analyzers for examples of loading non-Go files and reporting diagnostics against them.
The ResultOf field provides the results computed by the analyzers required by this one, as expressed in its Analyzer.Requires field. The driver runs the required analyzers first and makes their results available in this map. Each Analyzer must return a value of the type described in its Analyzer.ResultType field. For example, the "ctrlflow" analyzer returns a *ctrlflow.CFGs, which provides a control-flow graph for each function in the package (see golang.org/x/tools/go/cfg); the "inspect" analyzer returns a value that enables other Analyzers to traverse the syntax trees of the package more efficiently; and the "buildssa" analyzer constructs an SSA-form intermediate representation. Each of these Analyzers extends the capabilities of later Analyzers without adding a dependency to the core API, so an analysis tool pays only for the extensions it needs.
The Report function emits a diagnostic, a message associated with a source position. For most analyses, diagnostics are their primary result. For convenience, Pass provides a helper method, Reportf, to report a new diagnostic by formatting a string. Diagnostic is defined as:
type Diagnostic struct {
Pos token.Pos
Category string // optional
Message string
}
The optional Category field is a short identifier that classifies the kind of message when an analysis produces several kinds of diagnostic.
The Diagnostic struct does not have a field to indicate its severity because opinions about the relative importance of Analyzers and their diagnostics vary widely among users. The design of this framework does not hold each Analyzer responsible for identifying the severity of its diagnostics. Instead, we expect that drivers will allow the user to customize the filtering and prioritization of diagnostics based on the producing Analyzer and optional Category, according to the user's preferences.
Most Analyzers inspect typed Go syntax trees, but a few, such as asmdecl and buildtag, inspect the raw text of Go source files or even non-Go files such as assembly. To report a diagnostic against a line of a raw text file, use the following sequence:
content, err := pass.ReadFile(filename)
if err != nil { ... }
tf := fset.AddFile(filename, -1, len(content))
tf.SetLinesForContent(content)
...
pass.Reportf(tf.LineStart(line), "oops")
Modular analysis with Facts ¶
To improve efficiency and scalability, large programs are routinely built using separate compilation: units of the program are compiled separately, and recompiled only when one of their dependencies changes; independent modules may be compiled in parallel. The same technique may be applied to static analyses, for the same benefits. Such analyses are described as "modular".
A compiler’s type checker is an example of a modular static analysis. Many other checkers we would like to apply to Go programs can be understood as alternative or non-standard type systems. For example, vet's printf checker infers whether a function has the "printf wrapper" type, and it applies stricter checks to calls of such functions. In addition, it records which functions are printf wrappers for use by later analysis passes to identify other printf wrappers by induction. A result such as “f is a printf wrapper” that is not interesting by itself but serves as a stepping stone to an interesting result (such as a diagnostic) is called a Fact.
The analysis API allows an analysis to define new types of facts, to associate facts of these types with objects (named entities) declared within the current package, or with the package as a whole, and to query for an existing fact of a given type associated with an object or package.
An Analyzer that uses facts must declare their types:
var Analyzer = &analysis.Analyzer{
Name: "printf",
FactTypes: []analysis.Fact{new(isWrapper)},
...
}
type isWrapper struct{} // => *types.Func f “is a printf wrapper”
The driver program ensures that facts for a pass’s dependencies are generated before analyzing the package and is responsible for propagating facts from one package to another, possibly across address spaces. Consequently, Facts must be serializable. The API requires that drivers use the gob encoding, an efficient, robust, self-describing binary protocol. A fact type may implement the GobEncoder/GobDecoder interfaces if the default encoding is unsuitable. Facts should be stateless. Because serialized facts may appear within build outputs, the gob encoding of a fact must be deterministic, to avoid spurious cache misses in build systems that use content-addressable caches. The driver makes a single call to the gob encoder for all facts exported by a given analysis pass, so that the topology of shared data structures referenced by multiple facts is preserved.
The Pass type has functions to import and export facts, associated either with an object or with a package:
type Pass struct {
...
ExportObjectFact func(types.Object, Fact)
ImportObjectFact func(types.Object, Fact) bool
ExportPackageFact func(fact Fact)
ImportPackageFact func(*types.Package, Fact) bool
}
An Analyzer may only export facts associated with the current package or its objects, though it may import facts from any package or object that is an import dependency of the current package.
Conceptually, ExportObjectFact(obj, fact) inserts fact into a hidden map keyed by the pair (obj, TypeOf(fact)), and the ImportObjectFact function retrieves the entry from this map and copies its value into the variable pointed to by fact. This scheme assumes that the concrete type of fact is a pointer; this assumption is checked by the Validate function. See the "printf" analyzer for an example of object facts in action.
Some driver implementations (such as those based on Bazel and Blaze) do not currently apply analyzers to packages of the standard library. Therefore, for best results, analyzer authors should not rely on analysis facts being available for standard packages. For example, although the printf checker is capable of deducing during analysis of the log package that log.Printf is a printf wrapper, this fact is built in to the analyzer so that it correctly checks calls to log.Printf even when run in a driver that does not apply it to standard packages. We would like to remove this limitation in future.
Testing an Analyzer ¶
The analysistest subpackage provides utilities for testing an Analyzer. In a few lines of code, it is possible to run an analyzer on a package of testdata files and check that it reported all the expected diagnostics and facts (and no more). Expectations are expressed using "// want ..." comments in the input code.
Standalone commands ¶
Analyzers are provided in the form of packages that a driver program is expected to import. The vet command imports a set of several analyzers, but users may wish to define their own analysis commands that perform additional checks. To simplify the task of creating an analysis command, either for a single analyzer or for a whole suite, we provide the singlechecker and multichecker subpackages.
The singlechecker package provides the main function for a command that runs one analyzer. By convention, each analyzer such as go/analysis/passes/findcall should be accompanied by a singlechecker-based command such as go/analysis/passes/findcall/cmd/findcall, defined in its entirety as:
package main
import (
"golang.org/x/tools/go/analysis/passes/findcall"
"golang.org/x/tools/go/analysis/singlechecker"
)
func main() { singlechecker.Main(findcall.Analyzer) }
A tool that provides multiple analyzers can use multichecker in a similar way, giving it the list of Analyzers.
Index ¶
func Validate(analyzers []*Analyzer) error
type Analyzer
- func (a *Analyzer) String() string
type CycleInRequiresGraphError
- func (e *CycleInRequiresGraphError) Error() string
type Diagnostic
type Fact
type Module
type ModuleError
type ObjectFact
type PackageFact
type Pass
func (pass *Pass) ReportRangef(rng Range, format string, args ...any)
func (pass *Pass) Reportf(pos token.Pos, format string, args ...any)
func (pass *Pass) String() string
type Range
type RelatedInformation
type SuggestedFix
type TextEdit
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Validate ¶
func Validate(analyzers []*Analyzer) error
Validate reports an error if any of the analyzers are misconfigured. Checks include: that the name is a valid identifier; that the Doc is not empty; that the Run is non-nil; that the Requires graph is acyclic; that analyzer fact types are unique; that each fact type is a pointer.
Analyzer names need not be unique, though this may be confusing.
Types ¶
type Analyzer ¶
type Analyzer struct {
Name string
Doc string
URL string
Flags flag.FlagSet
Run func(*Pass) (any, error)
RunDespiteErrors bool
Requires []*Analyzer
ResultType reflect.Type
FactTypes []Fact
}
An Analyzer describes an analysis function and its options.
func (*Analyzer) String ¶
func (a *Analyzer) String() string
type CycleInRequiresGraphError ¶
type CycleInRequiresGraphError struct {
AnalyzerNames map[string]bool
}
func (*CycleInRequiresGraphError) Error ¶
func (e *CycleInRequiresGraphError) Error() string
type Diagnostic ¶
type Diagnostic struct {
Pos token.Pos
End token.Pos
Category string
Message string
URL string
SuggestedFixes []SuggestedFix
Related []RelatedInformation
}
A Diagnostic is a message associated with a source location or range.
An Analyzer may return a variety of diagnostics; the optional Category, which should be a constant, may be used to classify them. It is primarily intended to make it easy to look up documentation.
All Pos values are interpreted relative to Pass.Fset. If End is provided, the diagnostic is specified to apply to the range between Pos and End.
type Fact ¶
type Fact interface {
AFact()
}
A Fact is an intermediate fact produced during analysis.
Each fact is associated with a named declaration (a types.Object) or with a package as a whole. A single object or package may have multiple associated facts, but only one of any particular fact type.
A Fact represents a predicate such as "never returns", but does not represent the subject of the predicate such as "function F" or "package P".
Facts may be produced in one analysis pass and consumed by another analysis pass even if these are in different address spaces. If package P imports Q, all facts about Q produced during analysis of that package will be available during later analysis of P. Facts are analogous to type export data in a build system: just as export data enables separate compilation of several passes, facts enable "separate analysis".
Each pass (a, p) starts with the set of facts produced by the same analyzer a applied to the packages directly imported by p. The analysis may add facts to the set, and they may be exported in turn. An analysis's Run function may retrieve facts by calling Pass.Import{Object,Package}Fact and update them using Pass.Export{Object,Package}Fact.
A fact is logically private to its Analysis. To pass values between different analyzers, use the results mechanism; see Analyzer.Requires, Analyzer.ResultType, and Pass.ResultOf.
A Fact type must be a pointer. Facts are encoded and decoded using encoding/gob. A Fact may implement the GobEncoder/GobDecoder interfaces to customize its encoding. Fact encoding should not fail.
A Fact should not be modified once exported.
type Module ¶ added in v0.24.0
type Module struct {
Path string
Version string
Replace *Module
Time *time.Time
Main bool
Indirect bool
Dir string
GoMod string
GoVersion string
Error *ModuleError
}
A Module describes the module to which a package belongs.
type ModuleError ¶ added in v0.43.0
type ModuleError struct {
Err string
}
ModuleError holds errors loading a module.
type ObjectFact ¶
type ObjectFact struct {
Object types.Object
Fact Fact
}
ObjectFact is an object together with an associated fact.
type PackageFact ¶
type PackageFact struct {
Package *types.Package
Fact Fact
}
PackageFact is a package together with an associated fact.
type Pass ¶
type Pass struct {
Analyzer *Analyzer
Fset *token.FileSet
Files []*ast.File
OtherFiles []string
IgnoredFiles []string
Pkg *types.Package
TypesInfo *types.Info
TypesSizes types.Sizes
TypeErrors []types.Error
Module *Module
Report func(Diagnostic)
ResultOf map[*Analyzer]any
ReadFile func(filename string) ([]byte, error)
ImportObjectFact func(obj types.Object, fact Fact) bool
ImportPackageFact func(pkg *types.Package, fact Fact) bool
ExportObjectFact func(obj types.Object, fact Fact)
ExportPackageFact func(fact Fact)
AllPackageFacts func() []PackageFact
AllObjectFacts func() []ObjectFact
}
A Pass provides information to the Run function that applies a specific analyzer to a single Go package.
It forms the interface between the analysis logic and the driver program, and has both input and an output components.
As in a compiler, one pass may depend on the result computed by another.
The Run function should not call any of the Pass functions concurrently.
func (*Pass) ReportRangef ¶
func (pass *Pass) ReportRangef(rng Range, format string, args ...any)
ReportRangef is a helper function that reports a Diagnostic using the range provided. ast.Node values can be passed in as the range because they satisfy the Range interface.
func (*Pass) Reportf ¶
func (pass *Pass) Reportf(pos token.Pos, format string, args ...any)
Reportf is a helper function that reports a Diagnostic using the specified position and formatted error message.
func (*Pass) String ¶
func (pass *Pass) String() string
type Range ¶
type Range interface {
Pos() token.Pos
End() token.Pos
}
The Range interface provides a range. It's equivalent to and satisfied by ast.Node.
type RelatedInformation ¶
type RelatedInformation struct {
Pos token.Pos
End token.Pos
Message string
}
RelatedInformation contains information related to a diagnostic. For example, a diagnostic that flags duplicated declarations of a variable may include one RelatedInformation per existing declaration.
type SuggestedFix ¶
type SuggestedFix struct {
Message string
TextEdits []TextEdit
}
A SuggestedFix is a code change associated with a Diagnostic that a user can choose to apply to their code. Usually the SuggestedFix is meant to fix the issue flagged by the diagnostic.
The TextEdits must not overlap, nor contain edits for other packages. Edits need not be totally ordered, but the order determines how insertions at the same point will be applied.
type TextEdit ¶
type TextEdit struct {
Pos token.Pos
End token.Pos
NewText []byte
}
A TextEdit represents the replacement of the code between Pos and End with the new text. Each TextEdit should apply to a single file. End should not be earlier in the file than Pos.
Source Files ¶
Directories ¶
Package analysistest provides utilities for testing analyzers.
Package checker provides an analysis driver based on the golang.org/x/tools/go/packages representation of a set of packages and all their dependencies, as produced by packages.Load.
Package analysisflags defines helpers for processing flags (-help, -json, -fix, -diff, etc) common to unitchecker and {single,multi}checker.
Package internal/checker defines various implementation helpers for the singlechecker and multichecker packages, which provide the complete main function for an analysis driver executable based on go/packages.
Package multichecker defines the main function for an analysis driver with several analyzers.
passes
Package appends defines an Analyzer that detects if there is only one variable in append.
Package asmdecl defines an Analyzer that reports mismatches between assembly files and Go declarations.
Package assign defines an Analyzer that detects useless assignments.
Package atomic defines an Analyzer that checks for common mistakes using the sync/atomic package.
Package atomicalign defines an Analyzer that checks for non-64-bit-aligned arguments to sync/atomic functions.
Package bools defines an Analyzer that detects common mistakes involving boolean operators.
Package buildssa defines an Analyzer that constructs the SSA representation of an error-free package and returns the set of all functions within it.
Package buildtag defines an Analyzer that checks build tags.
Package cgocall defines an Analyzer that detects some violations of the cgo pointer passing rules.
Package composite defines an Analyzer that checks for unkeyed composite literals.
Package copylock defines an Analyzer that checks for locks erroneously passed by value.
Package ctrlflow is an analysis that provides a syntactic control-flow graph (CFG) for the body of a function.
Package deepequalerrors defines an Analyzer that checks for the use of reflect.DeepEqual with error values.
Package defers defines an Analyzer that checks for common mistakes in defer statements.
defers/cmd/defers command
The defers command runs the defers analyzer.
Package directive defines an Analyzer that checks known Go toolchain directives.
Package errorsas defines an Analyzer that checks that the second argument to errors.As is a pointer to a type implementing error.
Package fieldalignment defines an Analyzer that detects structs that would use less memory if their fields were sorted.
fieldalignment/cmd/fieldalignment command
Package findcall defines an Analyzer that serves as a trivial example and test of the Analysis API.
findcall/cmd/findcall command
The findcall command runs the findcall analyzer.
Package framepointer defines an Analyzer that reports assembly code that clobbers the frame pointer before saving it.
Package gofix defines an Analyzer that checks "//go:fix inline" directives.
Package hostport defines an analyzer for calls to net.Dial with addresses of the form "%s:%d" or "%s:%s", which work only with IPv4.
httpmux/cmd/httpmux command
The httpmux command runs the httpmux analyzer.
Package httpresponse defines an Analyzer that checks for mistakes using HTTP responses.
Package ifaceassert defines an Analyzer that flags impossible interface-interface type assertions.
ifaceassert/cmd/ifaceassert command
The ifaceassert command runs the ifaceassert analyzer.
Package inline defines an analyzer that inlines calls to functions and uses of constants marked with a "//go:fix inline" directive.
inline/cmd/inline command
The inline command applies the inliner to the specified packages of Go source code.
Package inspect defines an Analyzer that provides an AST inspector (golang.org/x/tools/go/ast/inspector.Inspector) for the syntax trees of a package.
Package gofixdirective searches for and validates go:fix directives.
Package loopclosure defines an Analyzer that checks for references to enclosing loop variables from within nested functions.
Package lostcancel defines an Analyzer that checks for failure to call a context cancellation function.
lostcancel/cmd/lostcancel command
The lostcancel command applies the golang.org/x/tools/go/analysis/passes/lostcancel analysis to the specified packages of Go source code.
Package modernize provides a suite of analyzers that suggest simplifications to Go code, using modern language and library features.
modernize/cmd/modernize command
The modernize command suggests (or, with -fix, applies) fixes that clarify Go code by using more modern features.
Package nilfunc defines an Analyzer that checks for useless comparisons against nil.
Package nilness inspects the control-flow graph of an SSA function and reports errors such as nil pointer dereferences and degenerate nil pointer comparisons.
nilness/cmd/nilness command
The nilness command applies the golang.org/x/tools/go/analysis/passes/nilness analysis to the specified packages of Go source code.
The pkgfact package is a demonstration and test of the package fact mechanism.
Package printf defines an Analyzer that checks consistency of Printf format strings and arguments.
Package reflectvaluecompare defines an Analyzer that checks for accidentally using == or reflect.DeepEqual to compare reflect.Value values.
reflectvaluecompare/cmd/reflectvaluecompare command
The reflectvaluecompare command applies the reflectvaluecompare checker to the specified packages of Go source code.
Package scannererr defines an analyzer for uses of bufio.Scanner in which the user has forgotten to check Scanner.Err.
Package shadow defines an Analyzer that checks for shadowed variables.
shadow/cmd/shadow command
The shadow command runs the shadow analyzer.
Package shift defines an Analyzer that checks for shifts that exceed the width of an integer.
Package sigchanyzer defines an Analyzer that detects misuse of unbuffered signal as argument to signal.Notify.
Package slog defines an Analyzer that checks for mismatched key-value pairs in log/slog calls.
Package sortslice defines an Analyzer that checks for calls to sort.Slice that do not use a slice type as first argument.
Package sqlrowserr defines an analyzer for uses of sql.Rows in which the user has forgotten to check Rows.Err.
Package stdmethods defines an Analyzer that checks for misspellings in the signatures of methods similar to well-known interfaces.
Package stdversion reports uses of standard library symbols that are "too new" for the Go version in force in the referring file.
Package stringintconv defines an Analyzer that flags type conversions from integers to strings.
stringintconv/cmd/stringintconv command
The stringintconv command runs the stringintconv analyzer.
Package structtag defines an Analyzer that checks struct field tags are well formed.
Package testinggoroutine defines an Analyzerfor detecting calls to Fatal from a test goroutine.
Package tests defines an Analyzer that checks for common mistaken usages of tests and examples.
Package timeformat defines an Analyzer that checks for the use of time.Format or time.Parse calls with a bad format.
The unmarshal package defines an Analyzer that checks for passing non-pointer or non-interface types to unmarshal and decode functions.
unmarshal/cmd/unmarshal command
The unmarshal command runs the unmarshal analyzer.
Package unreachable defines an Analyzer that checks for unreachable code.
Package unsafeptr defines an Analyzer that checks for invalid conversions of uintptr to unsafe.Pointer.
Package unusedresult defines an analyzer that checks for unused results of calls to certain pure functions.
unusedresult/cmd/unusedresult command
The unusedresult command applies the golang.org/x/tools/go/analysis/passes/unusedresult analysis to the specified packages of Go source code.
Package unusedwrite checks for unused writes to the elements of a struct or array object.
Package usesgenerics defines an Analyzer that checks for usage of generic features added in Go 1.18.
Package waitgroup defines an Analyzer that detects simple misuses of sync.WaitGroup.
Package singlechecker defines the main function for an analysis driver with only a single analysis.
suite
The fix package defines the suite of analyzers used by cmd/fix, the default analysis tool run by "go fix".
The vet package defines the suite of analyzers used by cmd/vet, the default analysis tool run by "go vet".
The unitchecker package defines the main function for an analysis driver that analyzes a single compilation unit during a build.
| Path | Synopsis |
|---|---|
| Package analysistest provides utilities for testing analyzers. | |
| Package checker provides an analysis driver based on the golang.org/x/tools/go/packages representation of a set of packages and all their dependencies, as produced by packages.Load. | |
| Package analysisflags defines helpers for processing flags (-help, -json, -fix, -diff, etc) common to unitchecker and {single,multi}checker. | |
| Package internal/checker defines various implementation helpers for the singlechecker and multichecker packages, which provide the complete main function for an analysis driver executable based on go/packages. | |
| Package multichecker defines the main function for an analysis driver with several analyzers. | |
| Package appends defines an Analyzer that detects if there is only one variable in append. | |
| Package asmdecl defines an Analyzer that reports mismatches between assembly files and Go declarations. | |
| Package assign defines an Analyzer that detects useless assignments. | |
| Package atomic defines an Analyzer that checks for common mistakes using the sync/atomic package. | |
| Package atomicalign defines an Analyzer that checks for non-64-bit-aligned arguments to sync/atomic functions. | |
| Package bools defines an Analyzer that detects common mistakes involving boolean operators. | |
| Package buildssa defines an Analyzer that constructs the SSA representation of an error-free package and returns the set of all functions within it. | |
| Package buildtag defines an Analyzer that checks build tags. | |
| Package cgocall defines an Analyzer that detects some violations of the cgo pointer passing rules. | |
| Package composite defines an Analyzer that checks for unkeyed composite literals. | |
| Package copylock defines an Analyzer that checks for locks erroneously passed by value. | |
| Package ctrlflow is an analysis that provides a syntactic control-flow graph (CFG) for the body of a function. | |
| Package deepequalerrors defines an Analyzer that checks for the use of reflect.DeepEqual with error values. | |
| Package defers defines an Analyzer that checks for common mistakes in defer statements. | |
| The defers command runs the defers analyzer. | |
| Package directive defines an Analyzer that checks known Go toolchain directives. | |
| Package errorsas defines an Analyzer that checks that the second argument to errors.As is a pointer to a type implementing error. | |
| Package fieldalignment defines an Analyzer that detects structs that would use less memory if their fields were sorted. | |
| Package findcall defines an Analyzer that serves as a trivial example and test of the Analysis API. | |
| The findcall command runs the findcall analyzer. | |
| Package framepointer defines an Analyzer that reports assembly code that clobbers the frame pointer before saving it. | |
| Package gofix defines an Analyzer that checks "//go:fix inline" directives. | |
| Package hostport defines an analyzer for calls to net.Dial with addresses of the form "%s:%d" or "%s:%s", which work only with IPv4. | |
| The httpmux command runs the httpmux analyzer. | |
| Package httpresponse defines an Analyzer that checks for mistakes using HTTP responses. | |
| Package ifaceassert defines an Analyzer that flags impossible interface-interface type assertions. | |
| The ifaceassert command runs the ifaceassert analyzer. | |
| Package inline defines an analyzer that inlines calls to functions and uses of constants marked with a "//go:fix inline" directive. | |
| The inline command applies the inliner to the specified packages of Go source code. | |
| Package inspect defines an Analyzer that provides an AST inspector (golang.org/x/tools/go/ast/inspector.Inspector) for the syntax trees of a package. | |
| Package gofixdirective searches for and validates go:fix directives. | |
| Package loopclosure defines an Analyzer that checks for references to enclosing loop variables from within nested functions. | |
| Package lostcancel defines an Analyzer that checks for failure to call a context cancellation function. | |
| The lostcancel command applies the golang.org/x/tools/go/analysis/passes/lostcancel analysis to the specified packages of Go source code. | |
| Package modernize provides a suite of analyzers that suggest simplifications to Go code, using modern language and library features. | |
| The modernize command suggests (or, with -fix, applies) fixes that clarify Go code by using more modern features. | |
| Package nilfunc defines an Analyzer that checks for useless comparisons against nil. | |
| Package nilness inspects the control-flow graph of an SSA function and reports errors such as nil pointer dereferences and degenerate nil pointer comparisons. | |
| The nilness command applies the golang.org/x/tools/go/analysis/passes/nilness analysis to the specified packages of Go source code. | |
| The pkgfact package is a demonstration and test of the package fact mechanism. | |
| Package printf defines an Analyzer that checks consistency of Printf format strings and arguments. | |
| Package reflectvaluecompare defines an Analyzer that checks for accidentally using == or reflect.DeepEqual to compare reflect.Value values. | |
| The reflectvaluecompare command applies the reflectvaluecompare checker to the specified packages of Go source code. | |
| Package scannererr defines an analyzer for uses of bufio.Scanner in which the user has forgotten to check Scanner.Err. | |
| Package shadow defines an Analyzer that checks for shadowed variables. | |
| The shadow command runs the shadow analyzer. | |
| Package shift defines an Analyzer that checks for shifts that exceed the width of an integer. | |
| Package sigchanyzer defines an Analyzer that detects misuse of unbuffered signal as argument to signal.Notify. | |
| Package slog defines an Analyzer that checks for mismatched key-value pairs in log/slog calls. | |
| Package sortslice defines an Analyzer that checks for calls to sort.Slice that do not use a slice type as first argument. | |
| Package sqlrowserr defines an analyzer for uses of sql.Rows in which the user has forgotten to check Rows.Err. | |
| Package stdmethods defines an Analyzer that checks for misspellings in the signatures of methods similar to well-known interfaces. | |
| Package stdversion reports uses of standard library symbols that are "too new" for the Go version in force in the referring file. | |
| Package stringintconv defines an Analyzer that flags type conversions from integers to strings. | |
| The stringintconv command runs the stringintconv analyzer. | |
| Package structtag defines an Analyzer that checks struct field tags are well formed. | |
| Package testinggoroutine defines an Analyzerfor detecting calls to Fatal from a test goroutine. | |
| Package tests defines an Analyzer that checks for common mistaken usages of tests and examples. | |
| Package timeformat defines an Analyzer that checks for the use of time.Format or time.Parse calls with a bad format. | |
| The unmarshal package defines an Analyzer that checks for passing non-pointer or non-interface types to unmarshal and decode functions. | |
| The unmarshal command runs the unmarshal analyzer. | |
| Package unreachable defines an Analyzer that checks for unreachable code. | |
| Package unsafeptr defines an Analyzer that checks for invalid conversions of uintptr to unsafe.Pointer. | |
| Package unusedresult defines an analyzer that checks for unused results of calls to certain pure functions. | |
| The unusedresult command applies the golang.org/x/tools/go/analysis/passes/unusedresult analysis to the specified packages of Go source code. | |
| Package unusedwrite checks for unused writes to the elements of a struct or array object. | |
| Package usesgenerics defines an Analyzer that checks for usage of generic features added in Go 1.18. | |
| Package waitgroup defines an Analyzer that detects simple misuses of sync.WaitGroup. | |
| Package singlechecker defines the main function for an analysis driver with only a single analysis. | |
| The fix package defines the suite of analyzers used by cmd/fix, the default analysis tool run by "go fix". | |
| The vet package defines the suite of analyzers used by cmd/vet, the default analysis tool run by "go vet". | |
| The unitchecker package defines the main function for an analysis driver that analyzes a single compilation unit during a build. |
Click to show internal directories.
Click to hide internal directories.
这条对你有帮助吗？