mirror of
https://github.com/golang/go
synced 2024-10-01 12:28:37 -06:00
b28839e4bd
Features: More robust: silently ignore type errors in modes that don't need SSA form: describe, referrers, implements, freevars, description. This makes the tool much more robust for everyday queries. Less configuration: don't require a scope argument for all queries. Only queries that do pointer analysis need it. For the rest, the initial position is enough for importQueryPackage to deduce the scope. It now works for queries in GoFiles, TestGoFiles, or XTestGoFiles. (It no longer works for ad-hoc main packages like $GOROOT/src/net/http/triv.go) More complete: "referrers" computes the scope automatically by scanning the import graph of the entire workspace, using gorename's refactor/importgraph package. This requires two passes at loading. Faster: simplified start-up logic avoids unnecessary package loading and SSA construction (a consequence of bad abstraction) in many cases. "callgraph": remove it. Unlike all the other commands it isn't related to the current selection, and we have golang.org/x/tools/cmdcallgraph now. Internals: Drop support for long-running clients (i.e., Pythia), since godoc -analysis supports all the same features except "pointsto", and precomputes all the results so latency is much lower. Get rid of various unhelpful abstractions introduced to support long-running clients. Expand out the set-up logic for each subcommand. This is simpler, easier to read, and gives us more control, at a small cost in duplication---the familiar story of abstractions. Discard PTA warnings. We weren't showing them (nor should we). Split tests into separate directories (so that importgraph works). Change-Id: I55d46b3ab33cdf7ac22436fcc2148fe04c901237 Reviewed-on: https://go-review.googlesource.com/8243 Reviewed-by: David Crawshaw <crawshaw@golang.org>
116 lines
2.8 KiB
Go
116 lines
2.8 KiB
Go
// Copyright 2013 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package oracle
|
|
|
|
import (
|
|
"fmt"
|
|
"go/token"
|
|
|
|
"golang.org/x/tools/go/callgraph"
|
|
"golang.org/x/tools/go/loader"
|
|
"golang.org/x/tools/go/ssa"
|
|
"golang.org/x/tools/oracle/serial"
|
|
)
|
|
|
|
// Callers reports the possible callers of the function
|
|
// immediately enclosing the specified source location.
|
|
//
|
|
func callers(conf *Query) error {
|
|
lconf := loader.Config{Build: conf.Build}
|
|
|
|
// Determine initial packages for PTA.
|
|
args, err := lconf.FromArgs(conf.Scope, true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(args) > 0 {
|
|
return fmt.Errorf("surplus arguments: %q", args)
|
|
}
|
|
|
|
// Load/parse/type-check the program.
|
|
lprog, err := lconf.Load()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
conf.Fset = lprog.Fset
|
|
|
|
qpos, err := parseQueryPos(lprog, conf.Pos, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
prog := ssa.Create(lprog, 0)
|
|
|
|
ptaConfig, err := setupPTA(prog, lprog, conf.PTALog, conf.Reflection)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
pkg := prog.Package(qpos.info.Pkg)
|
|
if pkg == nil {
|
|
return fmt.Errorf("no SSA package")
|
|
}
|
|
if !ssa.HasEnclosingFunction(pkg, qpos.path) {
|
|
return fmt.Errorf("this position is not inside a function")
|
|
}
|
|
|
|
// Defer SSA construction till after errors are reported.
|
|
prog.BuildAll()
|
|
|
|
target := ssa.EnclosingFunction(pkg, qpos.path)
|
|
if target == nil {
|
|
return fmt.Errorf("no SSA function built for this location (dead code?)")
|
|
}
|
|
|
|
// Run the pointer analysis, recording each
|
|
// call found to originate from target.
|
|
ptaConfig.BuildCallGraph = true
|
|
cg := ptrAnalysis(ptaConfig).CallGraph
|
|
cg.DeleteSyntheticNodes()
|
|
edges := cg.CreateNode(target).In
|
|
// TODO(adonovan): sort + dedup calls to ensure test determinism.
|
|
|
|
conf.result = &callersResult{
|
|
target: target,
|
|
callgraph: cg,
|
|
edges: edges,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type callersResult struct {
|
|
target *ssa.Function
|
|
callgraph *callgraph.Graph
|
|
edges []*callgraph.Edge
|
|
}
|
|
|
|
func (r *callersResult) display(printf printfFunc) {
|
|
root := r.callgraph.Root
|
|
if r.edges == nil {
|
|
printf(r.target, "%s is not reachable in this program.", r.target)
|
|
} else {
|
|
printf(r.target, "%s is called from these %d sites:", r.target, len(r.edges))
|
|
for _, edge := range r.edges {
|
|
if edge.Caller == root {
|
|
printf(r.target, "the root of the call graph")
|
|
} else {
|
|
printf(edge, "\t%s from %s", edge.Description(), edge.Caller.Func)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *callersResult) toSerial(res *serial.Result, fset *token.FileSet) {
|
|
var callers []serial.Caller
|
|
for _, edge := range r.edges {
|
|
callers = append(callers, serial.Caller{
|
|
Caller: edge.Caller.Func.String(),
|
|
Pos: fset.Position(edge.Pos()).String(),
|
|
Desc: edge.Description(),
|
|
})
|
|
}
|
|
res.Callers = callers
|
|
}
|