go/types: turn TestBenchmark into a normal benchmark

TestBenchmark doesn't use the -bench flag, so that it can format custom
output -- the number of checked lines per second. This is a barrier both
to discoverability, and to piping benchmark output into analysis tools
such as benchstat.

Using testing.B.ReportMetric and a bit of manual timing, we can achieve
similar results while conforming to normal benchmark output. Do this,
and rename the test func to BenchmarkCheck (for symmetry with
TestCheck).

Change-Id: Ie8f2259c1ca9e6986f0137287acf8eb2843f96b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/257958
Run-TryBot: Robert Findley <[email protected]>
TryBot-Result: Go Bot <[email protected]>
Trust: Robert Findley <[email protected]>
Reviewed-by: Robert Griesemer <[email protected]>

src/go/types/self_test.go

@@ -5,21 +5,18 @@
 package types_test
 
 import (
- "flag"
- "fmt"
  "go/ast"
  "go/importer"
  "go/parser"
  "go/token"
+ "path"
  "path/filepath"
  "testing"
  "time"
 
  . "go/types"
 )
 
-var benchmark = flag.Bool("b", false, "run benchmarks")
-
 func TestSelf(t *testing.T) {
  fset := token.NewFileSet()
  files, err := pkgFiles(fset, ".")
@@ -39,57 +36,70 @@ func TestSelf(t *testing.T) {
  }
 }
 
-func TestBenchmark(t *testing.T) {
- if !*benchmark {
- return
- }
-
- // We're not using testing's benchmarking mechanism directly
- // because we want custom output.
-
+func BenchmarkCheck(b *testing.B) {
  for _, p := range []string{
  "net/http",
  "go/parser",
  "go/constant",
  filepath.Join("go", "internal", "gcimporter"),
  } {
- path := filepath.Join("..", "..", p)
- runbench(t, path, false)
- runbench(t, path, true)
- fmt.Println()
+ b.Run(path.Base(p), func(b *testing.B) {
+ path := filepath.Join("..", "..", p)
+ for _, ignoreFuncBodies := range []bool{false, true} {
+ name := "funcbodies"
+ if ignoreFuncBodies {
+ name = "nofuncbodies"
+ }
+ b.Run(name, func(b *testing.B) {
+ b.Run("info", func(b *testing.B) {
+ runbench(b, path, ignoreFuncBodies, true)
+ })
+ b.Run("noinfo", func(b *testing.B) {
+ runbench(b, path, ignoreFuncBodies, false)
+ })
+ })
+ }
+ })
  }
 }
 
-func runbench(t *testing.T, path string, ignoreFuncBodies bool) {
+func runbench(b *testing.B, path string, ignoreFuncBodies, writeInfo bool) {
  fset := token.NewFileSet()
  files, err := pkgFiles(fset, path)
  if err != nil {
- t.Fatal(err)
+ b.Fatal(err)
  }
-
- b := testing.Benchmark(func(b *testing.B) {
- for i := 0; i < b.N; i++ {
- conf := Config{
- IgnoreFuncBodies: ignoreFuncBodies,
- Importer: importer.Default(),
- }
- if _, err := conf.Check(path, fset, files, nil); err != nil {
- t.Fatal(err)
- }
- }
- })
-
  // determine line count
  lines := 0
  fset.Iterate(func(f *token.File) bool {
  lines += f.LineCount()
  return true
  })
 
- d := time.Duration(b.NsPerOp())
- fmt.Printf("%s (ignoreFuncBodies = %v):\n", filepath.Base(path), ignoreFuncBodies)
- fmt.Printf("\t%s for %d lines (%.0f lines/s)\n", d, lines, float64(lines)/d.Seconds())
- fmt.Printf("\t%s\n", b.MemString())
+ b.ResetTimer()
+ start := time.Now()
+ for i := 0; i < b.N; i++ {
+ conf := Config{
+ IgnoreFuncBodies: ignoreFuncBodies,
+ Importer: importer.Default(),
+ }
+ var info *Info
+ if writeInfo {
+ info = &Info{
+ Types: make(map[ast.Expr]TypeAndValue),
+ Defs: make(map[*ast.Ident]Object),
+ Uses: make(map[*ast.Ident]Object),
+ Implicits: make(map[ast.Node]Object),
+ Selections: make(map[*ast.SelectorExpr]*Selection),
+ Scopes: make(map[ast.Node]*Scope),
+ }
+ }
+ if _, err := conf.Check(path, fset, files, info); err != nil {
+ b.Fatal(err)
+ }
+ }
+ b.StopTimer()
+ b.ReportMetric(float64(lines)*float64(b.N)/time.Since(start).Seconds(), "lines/s")
 }
 
 func pkgFiles(fset *token.FileSet, path string) ([]*ast.File, error) {