go/callgraph/static: avoid ssautil.AllFunctions

AllFunctions is complex mess. This change rewrites the static
algorithm to avoid it. It does reduce the number of
call graph nodes that are discovered (by something like 15%),
and the running time by a similar amount, but the principle
is slightly more defensible.

Also, document exactly what it does, and why it is the way
it is.

Updates golang/go#69231

Change-Id: I7e25237f0908315602ba0092083f247a140b9e22
Reviewed-on: https://go-review.googlesource.com/c/tools/+/609280
Reviewed-by: Zvonimir Pavlinovic <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: adonovan

go/callgraph/callgraph.go

@@ -32,11 +32,6 @@ language.
 */
 package callgraph // import "golang.org/x/tools/go/callgraph"
 
-// TODO(adonovan): add a function to eliminate wrappers from the
-// callgraph, preserving topology.
-// More generally, we could eliminate "uninteresting" nodes such as
-// nodes from packages we don't care about.
-
 // TODO(zpavlinovic): decide how callgraphs handle calls to and from generic function bodies.
 
 import (
@@ -52,11 +47,11 @@ import (
 // If the call graph is sound, such nodes indicate unreachable
 // functions.
 type Graph struct {
-	Root  *Node                   // the distinguished root node
+	Root  *Node                   // the distinguished root node (Root.Func may be nil)
 	Nodes map[*ssa.Function]*Node // all nodes by function
 }
 
-// New returns a new Graph with the specified root node.
+// New returns a new Graph with the specified (optional) root node.
 func New(root *ssa.Function) *Graph {
 	g := &Graph{Nodes: make(map[*ssa.Function]*Node)}
 	g.Root = g.CreateNode(root)

go/callgraph/static/static.go

@@ -4,32 +4,95 @@
 
 // Package static computes the call graph of a Go program containing
 // only static call edges.
-package static // import "golang.org/x/tools/go/callgraph/static"
-
-// TODO(zpavlinovic): update static for how it handles generic function bodies.
+package static
 
 import (
+	"go/types"
+
 	"golang.org/x/tools/go/callgraph"
 	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/ssa/ssautil"
 )
 
-// CallGraph computes the call graph of the specified program
-// considering only static calls.
+// CallGraph computes the static call graph of the specified program.
+//
+// The resulting graph includes:
+// - all package-level functions;
+// - all methods of package-level non-parameterized non-interface types;
+// - pointer wrappers (*C).F for source-level methods C.F;
+// - and all functions reachable from them following only static calls.
+//
+// It does not consider exportedness, nor treat main packages specially.
 func CallGraph(prog *ssa.Program) *callgraph.Graph {
-	cg := callgraph.New(nil) // TODO(adonovan) eliminate concept of rooted callgraph
-
-	// TODO(adonovan): opt: use only a single pass over the ssa.Program.
-	// TODO(adonovan): opt: this is slower than RTA (perhaps because
-	// the lower precision means so many edges are allocated)!
-	for f := range ssautil.AllFunctions(prog) {
-		fnode := cg.CreateNode(f)
-		for _, b := range f.Blocks {
-			for _, instr := range b.Instrs {
-				if site, ok := instr.(ssa.CallInstruction); ok {
-					if g := site.Common().StaticCallee(); g != nil {
-						gnode := cg.CreateNode(g)
-						callgraph.AddEdge(fnode, site, gnode)
+	cg := callgraph.New(nil)
+
+	// Recursively follow all static calls.
+	seen := make(map[int]bool) // node IDs already seen
+	var visit func(fnode *callgraph.Node)
+	visit = func(fnode *callgraph.Node) {
+		if !seen[fnode.ID] {
+			seen[fnode.ID] = true
+
+			for _, b := range fnode.Func.Blocks {
+				for _, instr := range b.Instrs {
+					if site, ok := instr.(ssa.CallInstruction); ok {
+						if g := site.Common().StaticCallee(); g != nil {
+							gnode := cg.CreateNode(g)
+							callgraph.AddEdge(fnode, site, gnode)
+							visit(gnode)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// If we were ever to redesign this function, we should allow
+	// the caller to provide the set of root functions and just
+	// perform the reachability step. This would allow them to
+	// work forwards from main entry points:
+	//
+	// rootNames := []string{"init", "main"}
+	// for _, main := range ssautil.MainPackages(prog.AllPackages()) {
+	// 	for _, rootName := range rootNames {
+	// 		visit(cg.CreateNode(main.Func(rootName)))
+	// 	}
+	// }
+	//
+	// or to control whether to include non-exported
+	// functions/methods, wrapper methods, and so on.
+	// Unfortunately that's not consistent with its historical
+	// behavior and existing tests.
+	//
+	// The logic below is a slight simplification and
+	// rationalization of ssautil.AllFunctions. (Having to include
+	// (*T).F wrapper methods is unfortunate--they are not source
+	// functions, and if they're reachable, they'll be in the
+	// graph--but the existing tests will break without it.)
+
+	methodsOf := func(T types.Type) {
+		if !types.IsInterface(T) {
+			mset := prog.MethodSets.MethodSet(T)
+			for i := 0; i < mset.Len(); i++ {
+				visit(cg.CreateNode(prog.MethodValue(mset.At(i))))
+			}
+		}
+	}
+
+	// Start from package-level symbols.
+	for _, pkg := range prog.AllPackages() {
+		for _, mem := range pkg.Members {
+			switch mem := mem.(type) {
+			case *ssa.Function:
+				// package-level function
+				visit(cg.CreateNode(mem))
+
+			case *ssa.Type:
+				// methods of package-level non-interface non-parameterized types
+				if !types.IsInterface(mem.Type()) {
+					if named, ok := mem.Type().(*types.Named); ok &&
+						named.TypeParams() == nil {
+						methodsOf(named)                   //  T
+						methodsOf(types.NewPointer(named)) // *T
 					}
 				}
 			}

go/callgraph/static/static_test.go

@@ -18,7 +18,7 @@ import (
 	"golang.org/x/tools/go/ssa/ssautil"
 )
 
-const input = `package P
+const input = `package main
 
 type C int
 func (C) f()
@@ -46,6 +46,9 @@ func g() {
 func h()
 
 var unknown bool
+
+func main() {
+}
 `
 
 const genericsInput = `package P