Package facts
import "cmd/vendor/golang.org/x/tools/go/analysis/internal/facts"
- Overview
- Index
Package facts defines a serializable set of analysis.Fact.
It provides a partial implementation of the Fact-related parts of the
analysis.Pass interface for use in analysis drivers such as "go vet"
and other build systems.
The serial format is unspecified and may change, so the same version
of this package must be used for reading and writing serialized facts.
The handling of facts in the analysis system parallels the handling
of type information in the compiler: during compilation of package P,
the compiler emits an export data file that describes the type of
every object (named thing) defined in package P, plus every object
indirectly reachable from one of those objects. Thus the downstream
compiler of package Q need only load one export data file per direct
import of Q, and it will learn everything about the API of package P
and everything it needs to know about the API of P's dependencies.
Similarly, analysis of package P emits a fact set containing facts
about all objects exported from P, plus additional facts about only
those objects of P's dependencies that are reachable from the API of
package P; the downstream analysis of Q need only load one fact set
per direct import of Q.
The notion of "exportedness" that matters here is that of the
compiler. According to the language spec, a method pkg.T.f is
unexported simply because its name starts with lowercase. But the
compiler must nonethless export f so that downstream compilations can
accurately ascertain whether pkg.T implements an interface pkg.I
defined as interface{f()}. Exported thus means "described in export
data".
In the call graph viewer below, each node
is a function belonging to this package
and its children are the functions it
calls—perhaps dynamically.
The root nodes are the entry points of the
package: functions that may be called from
outside the package.
There may be non-exported or anonymous
functions among them if they are called
dynamically from another package.
Click a node to visit that function's source code.
From there you can visit its callers by
clicking its declaring func
token.
Functions may be omitted if they were
determined to be unreachable in the
particular programs or tests that were
analyzed.
type Set struct {
}
A Set is a set of analysis.Facts.
Decode creates a Set of facts by reading from the imports of a given
package, and Encode writes out the set. Between these operation,
the Import and Export methods will query and update the set.
All of Set's methods except String are safe to call concurrently.
func Decode(pkg *types.Package, read func(packagePath string) ([]byte, error)) (*Set, error)
Decode decodes all the facts relevant to the analysis of package pkg.
The read function reads serialized fact data from an external source
for one of of pkg's direct imports. The empty file is a valid
encoding of an empty fact set.
It is the caller's responsibility to call gob.Register on all
necessary fact types.
func (s *Set) Encode() []byte
Encode encodes a set of facts to a memory buffer.
It may fail if one of the Facts could not be gob-encoded, but this is
a sign of a bug in an Analyzer.
func (s *Set) ExportObjectFact(obj types.Object, fact analysis.Fact)
ExportObjectFact implements analysis.Pass.ExportObjectFact.
func (s *Set) ExportPackageFact(fact analysis.Fact)
ExportPackageFact implements analysis.Pass.ExportPackageFact.
func (s *Set) ImportObjectFact(obj types.Object, ptr analysis.Fact) bool
ImportObjectFact implements analysis.Pass.ImportObjectFact.
func (s *Set) ImportPackageFact(pkg *types.Package, ptr analysis.Fact) bool
ImportPackageFact implements analysis.Pass.ImportPackageFact.
func (s *Set) String() string
String is provided only for debugging, and must not be called
concurrent with any Import/Export method.