remove the ability to select a callgraph algorithm

We'll soon remove callgraph entirely, as it doesn't do all we need and
requires analysing entire programs all at once.

As a step in that direction, stop exposing callgraph options to the
user.

Author: mvdan

check/check.go

@@ -23,23 +23,21 @@ import (
 
 	"golang.org/x/tools/go/callgraph"
 	"golang.org/x/tools/go/callgraph/cha"
-	"golang.org/x/tools/go/callgraph/rta"
 	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/go/ssa"
 	"golang.org/x/tools/go/ssa/ssautil"
 )
 
 // UnusedParams returns a list of human-readable issues that point out unused
 // function parameters.
-func UnusedParams(tests bool, algo string, exported, debug bool, args ...string) ([]string, error) {
+func UnusedParams(tests bool, exported, debug bool, args ...string) ([]string, error) {
 	wd, err := os.Getwd()
 	if err != nil {
 		return nil, err
 	}
 	c := &Checker{
 		wd:       wd,
 		tests:    tests,
-		algo:     algo,
 		exported: exported,
 	}
 	if debug {
@@ -59,7 +57,6 @@ type Checker struct {
 	wd string
 
 	tests    bool
-	algo     string
 	exported bool
 	debugLog io.Writer
 
@@ -143,11 +140,6 @@ func (c *Checker) ProgramSSA(prog *ssa.Program) {
 	c.prog = prog
 }
 
-// CallgraphAlgorithm supplies Checker with the call graph construction algorithm.
-func (c *Checker) CallgraphAlgorithm(algo string) {
-	c.algo = algo
-}
-
 // CheckExportedFuncs sets whether to inspect exported functions
 func (c *Checker) CheckExportedFuncs(exported bool) {
 	c.exported = exported
@@ -213,23 +205,7 @@ func (c *Checker) Check() ([]Issue, error) {
 			})
 		}
 	}
-	switch c.algo {
-	case "cha":
-		c.graph = cha.CallGraph(c.prog)
-	case "rta":
-		mains, err := mainPackages(c.prog, wantPkg)
-		if err != nil {
-			return nil, err
-		}
-		var roots []*ssa.Function
-		for _, main := range mains {
-			roots = append(roots, main.Func("init"), main.Func("main"))
-		}
-		result := rta.Analyze(roots, true)
-		c.graph = result.CallGraph
-	default:
-		return nil, fmt.Errorf("unknown call graph construction algorithm: %q", c.algo)
-	}
+	c.graph = cha.CallGraph(c.prog)
 	c.graph.DeleteSyntheticNodes()
 
 	allFuncs := ssautil.AllFunctions(c.prog)
@@ -461,21 +437,6 @@ resLoop:
 	}
 }
 
-// mainPackages returns the subset of main packages within pkgSet.
-func mainPackages(prog *ssa.Program, pkgSet map[*types.Package]*packages.Package) ([]*ssa.Package, error) {
-	mains := make([]*ssa.Package, 0, len(pkgSet))
-	for tpkg := range pkgSet {
-		pkg := prog.Package(tpkg)
-		if tpkg.Name() == "main" && pkg.Func("main") != nil {
-			mains = append(mains, pkg)
-		}
-	}
-	if len(mains) == 0 {
-		return nil, fmt.Errorf("no main packages")
-	}
-	return mains, nil
-}
-
 // calledInReturn reports whether any of a function's inbound calls happened
 // directly as a return statement. That is, if function "foo" was used via
 // "return foo()". This means that the result parameters of the function cannot

main.go

@@ -17,8 +17,6 @@ import (
 var (
 	flagSet = flag.NewFlagSet("unparam", flag.ContinueOnError)
 
-	algo = flagSet.String("algo", "cha", `call graph construction algorithm (cha, rta).
-in general, use cha for libraries, and rta for programs with main packages.`)
 	tests    = flagSet.Bool("tests", true, "include tests")
 	exported = flagSet.Bool("exported", false, "inspect exported functions")
 	debug    = flagSet.Bool("debug", false, "debug prints")
@@ -44,7 +42,7 @@ func main1() int {
 		}
 		return 1
 	}
-	warns, err := check.UnusedParams(*tests, *algo, *exported, *debug, flagSet.Args()...)
+	warns, err := check.UnusedParams(*tests, *exported, *debug, flagSet.Args()...)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return 1