cmd/deadcode: avoid ssautil.AllFunctions

This change causes deadcode to enumerate the "universe set"
of functions based on the source-level declarations, not
the ssautil.AllFunctions helper. The former set is accurate
(and also much cheaper to compute), whereas the latter is
a mess (as its doc comment attests).

In particular, it omits unexported methods of uninstantiated
types, which are of course unreachable. This makes for
some sense for whole-program analysis, but none at all
for a dead code tool that specifically wants to know
the useless functions.

The new logic is pleasantly simpler.

Also, a test.

Fixes golang/go#65915

Change-Id: I7a4a64fd3da18d089044530911cdb2e3b42d0db5
Reviewed-on: https://go-review.googlesource.com/c/tools/+/567156
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Robert Findley <[email protected]>

Author: adonovan

cmd/deadcode/deadcode.go

@@ -132,16 +132,6 @@ func main() {
 		log.Fatalf("packages contain errors")
 	}
 
-	// Gather names of generated files.
-	generated := make(map[string]bool)
-	packages.Visit(initial, nil, func(p *packages.Package) {
-		for _, file := range p.Syntax {
-			if isGenerated(file) {
-				generated[p.Fset.File(file.Pos()).Name()] = true
-			}
-		}
-	})
-
 	// If -filter is unset, use first module (if available).
 	if *filterFlag == "<module>" {
 		if mod := initial[0].Module; mod != nil && mod.Path != "" {
@@ -169,6 +159,32 @@ func main() {
 		roots = append(roots, main.Func("init"), main.Func("main"))
 	}
 
+	// Gather all source-level functions,
+	// as the user interface is expressed in terms of them.
+	//
+	// We ignore synthetic wrappers, and nested functions. Literal
+	// functions passed as arguments to other functions are of
+	// course address-taken and there exists a dynamic call of
+	// that signature, so when they are unreachable, it is
+	// invariably because the parent is unreachable.
+	var sourceFuncs []*ssa.Function
+	generated := make(map[string]bool)
+	packages.Visit(initial, nil, func(p *packages.Package) {
+		for _, file := range p.Syntax {
+			for _, decl := range file.Decls {
+				if decl, ok := decl.(*ast.FuncDecl); ok {
+					obj := p.TypesInfo.Defs[decl.Name].(*types.Func)
+					fn := prog.FuncValue(obj)
+					sourceFuncs = append(sourceFuncs, fn)
+				}
+			}
+
+			if isGenerated(file) {
+				generated[p.Fset.File(file.Pos()).Name()] = true
+			}
+		}
+	})
+
 	// Compute the reachabilty from main.
 	// (Build a call graph only for -whylive.)
 	res := rta.Analyze(roots, *whyLiveFlag != "")
@@ -195,10 +211,7 @@ func main() {
 	// is not dead, by showing a path to it from some root.
 	if *whyLiveFlag != "" {
 		targets := make(map[*ssa.Function]bool)
-		for fn := range ssautil.AllFunctions(prog) {
-			if fn.Synthetic != "" || fn.Object() == nil {
-				continue // not a source-level named function
-			}
+		for _, fn := range sourceFuncs {
 			if prettyName(fn, true) == *whyLiveFlag {
 				targets[fn] = true
 			}
@@ -263,26 +276,7 @@ func main() {
 
 	// Group unreachable functions by package path.
 	byPkgPath := make(map[string]map[*ssa.Function]bool)
-	for fn := range ssautil.AllFunctions(prog) {
-		if fn.Synthetic != "" {
-			continue // ignore synthetic wrappers etc
-		}
-
-		// Use generic, as instantiations may not have a Pkg.
-		if orig := fn.Origin(); orig != nil {
-			fn = orig
-		}
-
-		// Ignore unreachable nested functions.
-		// Literal functions passed as arguments to other
-		// functions are of course address-taken and there
-		// exists a dynamic call of that signature, so when
-		// they are unreachable, it is invariably because the
-		// parent is unreachable.
-		if fn.Parent() != nil {
-			continue
-		}
-
+	for _, fn := range sourceFuncs {
 		posn := prog.Fset.Position(fn.Pos())
 
 		if !reachablePosn[posn] {

cmd/deadcode/testdata/issue65915.txtar

@@ -0,0 +1,44 @@
+# Regression test for issue 65915: the enumeration of source-level
+# functions used the flawed ssautil.AllFunctions, causing it to
+# miss some unexported ones.
+
+ deadcode -filter= example.com
+
+ want "unreachable func: example.UnUsed"
+ want "unreachable func: example.unUsed"
+ want "unreachable func: PublicExample.UnUsed"
+ want "unreachable func: PublicExample.unUsed"
+
+-- go.mod --
+module example.com
+go 1.18
+
+-- main.go --
+package main
+
+type example struct{}
+
+func (e example) UnUsed() {}
+
+func (e example) Used() {}
+
+func (e example) unUsed() {}
+
+func (e example) used() {}
+
+type PublicExample struct{}
+
+func (p PublicExample) UnUsed() {}
+
+func (p PublicExample) Used() {}
+
+func (p PublicExample) unUsed() {}
+
+func (p PublicExample) used() {}
+
+func main() {
+	example{}.Used()
+	example{}.used()
+	PublicExample{}.Used()
+	PublicExample{}.used()
+}