*: golint, go tool vet, unsued, gosimple, staticcheck (#113)

* `git ls-files -- '*.go' | xargs gofmt -s -w`

* driver: unexport InternalOptions

This was an exported method that returned an internal type, so it's
unlikely that anyone depends on its presence.

* internal/binutils: remove newline in error string

golint reported: error strings should not be capitalized or end with
punctuation or a newline

* internal/driver: s/buildId/buildID/ per golint

* internal/elfexec: remove punctuation in error string

golint reported: error strings should not be capitalized or end with
punctuation or a newline

* internal/graph: correct comment

Found with golint.

* internal/graph: add method comment

golint reported: exported method Edge.WeightValue should have comment
or be unexported

* internal/report: remove newline in error string

golint reported: error strings should not be capitalized or end with
punctuation or a newline

* *: remove unused code

Found with honnef.co/go/tools/cmd/unused:

	internal/binutils/disasm_test.go:137:8: const objdump is unused (U1000)
	internal/driver/driver_test.go:353:6: type testProfile is unused (U1000)
	internal/graph/graph.go:838:6: func countEdges is unused (U1000)
	profile/proto.go:148:6: func encodeStringOpt is unused (U1000)

* *: simply code

Found with honnef.co/go/tools/cmd/gosimple:

	internal/driver/commands.go:471:24: should omit comparison to bool constant, can be simplified to !b (S1002)
	internal/driver/driver.go:163:5: should omit comparison to bool constant, can be simplified to !trim (S1002)
	internal/driver/driver.go:168:5: should omit comparison to bool constant, can be simplified to !focus (S1002)
	internal/driver/driver.go:172:5: should omit comparison to bool constant, can be simplified to !tagfocus (S1002)
	internal/driver/driver.go:176:5: should omit comparison to bool constant, can be simplified to !hide (S1002)
	internal/graph/dotgraph.go:213:34: should use make(map[string][]*Tag) instead (S1019)
	internal/report/report.go:1061:3: should replace loop with label = append(label, rpt.options.ProfileLabels...) (S1011)
	profile/proto.go:157:5: should omit comparison to bool constant, can be simplified to !x (S1002)

* *: correct mistakes

Found with honnef.co/go/tools/cmd/staticcheck:

	driver/driver.go:280:20: infinite recursive call (SA5007)
	internal/driver/driver_focus.go:54:11: this value of err is never used (SA4006)
	profile/proto.go:74:32: x | 0 always equals x (SA4016)

* Add linters to .travis.yml

.travis.yml

 go:
   - 1.7.x
   - 1.8.x
+
+before_install:
+  - go get -u github.com/golang/lint/golint honnef.co/go/tools/cmd/...
+
+script:
+  - gofmtdiff=$(gofmt -s -d .) && if [ -n "$gofmtdiff" ]; then printf 'gofmt -s found:\n%s\n' "$gofmtdiff" && exit 1; fi
+  - golintlint=$(golint ./...) && if [ -n "$golintlint" ]; then printf 'golint found:\n%s\n' "$golintlint" && exit 1; fi
+  - go tool vet -all .
+  - gosimple ./...
+  - staticcheck ./...
+  - unused ./...
+  - go test -v ./...
+  - go test -v -race ./...

driver/driver.go

 // manager. Then it generates a report formatted according to the
 // options selected through the flags package.
 func PProf(o *Options) error {
-	return internaldriver.PProf(o.InternalOptions())
+	return internaldriver.PProf(o.internalOptions())
 }
 
-func (o *Options) InternalOptions() *plugin.Options {
+func (o *Options) internalOptions() *plugin.Options {
 	var obj plugin.ObjTool
 	if o.Obj != nil {
 		obj = &internalObjTool{o.Obj}
 }
 
 func (s *internalSymbolizer) Symbolize(mode string, srcs plugin.MappingSources, prof *profile.Profile) error {
-	isrcs := plugin.MappingSources{}
+	isrcs := MappingSources{}
 	for m, s := range srcs {
 		isrcs[m] = s
 	}
-	return s.Symbolize(mode, isrcs, prof)
+	return s.Symbolizer.Symbolize(mode, isrcs, prof)
 }

internal/binutils/disasm_test.go

 
 func checkSymbol(got []*plugin.Sym, want []plugin.Sym) error {
 	if len(got) != len(want) {
-		return fmt.Errorf("unexpected number of symbols %d (want %d)\n", len(got), len(want))
+		return fmt.Errorf("unexpected number of symbols %d (want %d)", len(got), len(want))
 	}
 
 	for i, g := range got {
 		},
 	}
 
-	const objdump = "testdata/wrapper/objdump"
-
 	for _, tc := range testcases {
 		insts, err := disassemble([]byte(tc.asm))
 		if err != nil {

internal/driver/commands.go

 	case boolKind:
 		var b bool
 		if b, err = stringToBool(value); err == nil {
-			if v.group != "" && b == false {
+			if v.group != "" && !b {
 				err = fmt.Errorf("%q can only be set to true", name)
 			}
 		}

internal/driver/driver.go

 			v.set("nodecount", "80")
 		}
 	}
-	if trim == false {
+	if !trim {
 		v.set("nodecount", "0")
 		v.set("nodefraction", "0")
 		v.set("edgefraction", "0")
 	}
-	if focus == false {
+	if !focus {
 		v.set("focus", "")
 		v.set("ignore", "")
 	}
-	if tagfocus == false {
+	if !tagfocus {
 		v.set("tagfocus", "")
 		v.set("tagignore", "")
 	}
-	if hide == false {
+	if !hide {
 		v.set("hide", "")
 		v.set("show", "")
 	}

internal/driver/driver_focus.go

 	if prunefrom != nil {
 		prof.PruneFrom(prunefrom)
 	}
-	return nil
+	return err
 }
 
 func compileRegexOption(name, value string, err error) (*regexp.Regexp, error) {

internal/driver/driver_test.go

 	}
 }
 
-type testProfile struct {
-}
-
 const testStart = 0x1000
 const testOffset = 0x5000
 
 				Location: []*profile.Location{cpuL[0], cpuL[1], cpuL[2]},
 				Value:    []int64{1000, 1000},
 				Label: map[string][]string{
-					"key1": []string{"tag1"},
-					"key2": []string{"tag1"},
+					"key1": {"tag1"},
+					"key2": {"tag1"},
 				},
 			},
 			{
 				Location: []*profile.Location{cpuL[0], cpuL[3]},
 				Value:    []int64{100, 100},
 				Label: map[string][]string{
-					"key1": []string{"tag2"},
-					"key3": []string{"tag2"},
+					"key1": {"tag2"},
+					"key3": {"tag2"},
 				},
 			},
 			{
 				Location: []*profile.Location{cpuL[1], cpuL[4]},
 				Value:    []int64{10, 10},
 				Label: map[string][]string{
-					"key1": []string{"tag3"},
-					"key2": []string{"tag2"},
+					"key1": {"tag3"},
+					"key2": {"tag2"},
 				},
 			},
 			{
 				Location: []*profile.Location{cpuL[2]},
 				Value:    []int64{10, 10},
 				Label: map[string][]string{
-					"key1": []string{"tag4"},
-					"key2": []string{"tag1"},
+					"key1": {"tag4"},
+					"key2": {"tag1"},
 				},
 			},
 		},
 				Location: []*profile.Location{heapL[0], heapL[1], heapL[2]},
 				Value:    []int64{10, 1024000},
 				NumLabel: map[string][]int64{
-					"bytes": []int64{102400},
+					"bytes": {102400},
 				},
 			},
 			{
 				Location: []*profile.Location{heapL[0], heapL[3]},
 				Value:    []int64{20, 4096000},
 				NumLabel: map[string][]int64{
-					"bytes": []int64{204800},
+					"bytes": {204800},
 				},
 			},
 			{
 				Location: []*profile.Location{heapL[1], heapL[4]},
 				Value:    []int64{40, 65536000},
 				NumLabel: map[string][]int64{
-					"bytes": []int64{1638400},
+					"bytes": {1638400},
 				},
 			},
 			{
 				Location: []*profile.Location{heapL[2]},
 				Value:    []int64{80, 32768000},
 				NumLabel: map[string][]int64{
-					"bytes": []int64{409600},
+					"bytes": {409600},
 				},
 			},
 		},
 }
 
 type mockFile struct {
-	name, buildId string
+	name, buildID string
 	base          uint64
 }
 
 
 // BuildID returns the GNU build ID of the file, or an empty string.
 func (m *mockFile) BuildID() string {
-	return m.buildId
+	return m.buildID
 }
 
 // SourceLine reports the source line information for a given

internal/elfexec/elfexec.go

 				if buildID == nil {
 					buildID = note.Desc
 				} else {
-					return nil, fmt.Errorf("multiple build ids found, don't know which to use!")
+					return nil, fmt.Errorf("multiple build ids found, don't know which to use")
 				}
 			}
 		}

internal/graph/dotgraph.go

 	Total       int64                      // The total weight of the graph, used to compute percentages
 }
 
-// Compose creates and writes a in the DOT format to the writer, using
+// ComposeDot creates and writes a in the DOT format to the writer, using
 // the configurations given.
 func ComposeDot(w io.Writer, g *Graph, a *DotAttributes, c *DotConfig) {
 	builder := &builder{w, a, c}
 
 	// Populate two Tag slices, one for LabelTags and one for NumericTags.
 	var ts []*Tag
-	lnts := make(map[string][]*Tag, 0)
+	lnts := make(map[string][]*Tag)
 	for _, t := range node.LabelTags {
 		ts = append(ts, t)
 	}

internal/graph/dotgraph_test.go

 	}
 
 	tagWant := [][]*Tag{
-		[]*Tag{
+		{
 			makeTag("1B..2GB", "", 0, 2401, 2401),
 		},
-		[]*Tag{
+		{
 			makeTag("2GB", "", 0, 1000, 1000),
 			makeTag("1B..12MB", "", 0, 1401, 1401),
 		},
-		[]*Tag{
+		{
 			makeTag("2GB", "", 0, 1000, 1000),
 			makeTag("12MB", "", 0, 100, 100),
 			makeTag("1B..1MB", "", 0, 1301, 1301),
 		},
-		[]*Tag{
+		{
 			makeTag("2GB", "", 0, 1000, 1000),
 			makeTag("1MB", "", 0, 1000, 1000),
 			makeTag("2B..1kB", "", 0, 201, 201),

internal/graph/graph.go

 	Inline bool
 }
 
+// WeightValue returns the weight value for this edge, normalizing if a
+// divisor is available.
 func (e *Edge) WeightValue() int64 {
 	if e.WeightDiv == 0 {
 		return e.Weight
 	return count
 }
 
-// countEdges counts the number of edges below the specified cutoff.
-func countEdges(el EdgeMap, cutoff int64) int {
-	count := 0
-	for _, e := range el {
-		if e.Weight > cutoff {
-			count++
-		}
-	}
-	return count
-}
-
 // RemoveRedundantEdges removes residual edges if the destination can
 // be reached through another path. This is done to simplify the graph
 // while preserving connectivity.

internal/report/report.go

 
 	var label []string
 	if len(rpt.options.ProfileLabels) > 0 {
-		for _, l := range rpt.options.ProfileLabels {
-			label = append(label, l)
-		}
+		label = append(label, rpt.options.ProfileLabels...)
 	} else if fullHeaders || !rpt.options.CompactLabels {
 		label = ProfileLabels(rpt)
 	}

internal/report/source.go

 	}
 
 	if len(fileNodes) == 0 {
-		return fmt.Errorf("No source information for %s\n", o.Symbol.String())
+		return fmt.Errorf("No source information for %s", o.Symbol.String())
 	}
 
 	sourceFiles := make(graph.Nodes, 0, len(fileNodes))

internal/symbolizer/symbolizer_test.go

 }
 
 var mockAddresses = map[uint64][]plugin.Frame{
-	1000: []plugin.Frame{frame("fun11", "file11.src", 10)},
-	2000: []plugin.Frame{frame("fun21", "file21.src", 20), frame("fun22", "file22.src", 20)},
-	3000: []plugin.Frame{frame("fun31", "file31.src", 30), frame("fun32", "file32.src", 30), frame("fun33", "file33.src", 30)},
-	4000: []plugin.Frame{frame("fun41", "file41.src", 40), frame("fun42", "file42.src", 40), frame("fun43", "file43.src", 40), frame("fun44", "file44.src", 40)},
-	5000: []plugin.Frame{frame("fun51", "file51.src", 50), frame("fun52", "file52.src", 50), frame("fun53", "file53.src", 50), frame("fun54", "file54.src", 50), frame("fun55", "file55.src", 50)},
+	1000: {frame("fun11", "file11.src", 10)},
+	2000: {frame("fun21", "file21.src", 20), frame("fun22", "file22.src", 20)},
+	3000: {frame("fun31", "file31.src", 30), frame("fun32", "file32.src", 30), frame("fun33", "file33.src", 30)},
+	4000: {frame("fun41", "file41.src", 40), frame("fun42", "file42.src", 40), frame("fun43", "file43.src", 40), frame("fun44", "file44.src", 40)},
+	5000: {frame("fun51", "file51.src", 50), frame("fun52", "file52.src", 50), frame("fun53", "file53.src", 50), frame("fun54", "file54.src", 50), frame("fun55", "file55.src", 50)},
 }
 
 func frame(fname, file string, line int) plugin.Frame {

profile/legacy_java_profile.go

 			switch pType {
 			case "heap":
 				const javaHeapzSamplingRate = 524288 // 512K
-				s.NumLabel = map[string][]int64{"bytes": []int64{s.Value[1] / s.Value[0]}}
+				s.NumLabel = map[string][]int64{"bytes": {s.Value[1] / s.Value[0]}}
 				s.Value[0], s.Value[1] = scaleHeapSample(s.Value[0], s.Value[1], javaHeapzSamplingRate)
 			case "contention":
 				if period := p.Period; period != 0 {

profile/profile_test.go

 			Location: []*Location{cpuL[0]},
 			Value:    []int64{1000, 1000},
 			Label: map[string][]string{
-				"key1": []string{"tag1"},
-				"key2": []string{"tag1"},
+				"key1": {"tag1"},
+				"key2": {"tag1"},
 			},
 		},
 		{
 			Location: []*Location{cpuL[1], cpuL[0]},
 			Value:    []int64{100, 100},
 			Label: map[string][]string{
-				"key1": []string{"tag2"},
-				"key3": []string{"tag2"},
+				"key1": {"tag2"},
+				"key3": {"tag2"},
 			},
 		},
 		{
 			Location: []*Location{cpuL[2], cpuL[0]},
 			Value:    []int64{10, 10},
 			Label: map[string][]string{
-				"key1": []string{"tag3"},
-				"key2": []string{"tag2"},
+				"key1": {"tag3"},
+				"key2": {"tag2"},
 			},
 		},
 		{
 			Location: []*Location{cpuL[3], cpuL[0]},
 			Value:    []int64{10000, 10000},
 			Label: map[string][]string{
-				"key1": []string{"tag4"},
-				"key2": []string{"tag1"},
+				"key1": {"tag4"},
+				"key2": {"tag1"},
 			},
 		},
 		{
 			Location: []*Location{cpuL[4], cpuL[0]},
 			Value:    []int64{1, 1},
 			Label: map[string][]string{
-				"key1": []string{"tag4"},
-				"key2": []string{"tag1"},
+				"key1": {"tag4"},
+				"key2": {"tag1"},
 			},
 		},
 	},
 }
 
 var aggTests = map[string]aggTest{
-	"precise":         aggTest{true, true, true, true, 5},
-	"fileline":        aggTest{false, true, true, true, 4},
-	"inline_function": aggTest{false, true, false, true, 3},
-	"function":        aggTest{false, true, false, false, 2},
+	"precise":         {true, true, true, true, 5},
+	"fileline":        {false, true, true, true, 4},
+	"inline_function": {false, true, false, true, 3},
+	"function":        {false, true, false, false, 2},
 }
 
 type aggTest struct {

profile/proto.go

 
 func encodeUint64(b *buffer, tag int, x uint64) {
 	// append varint to b.data
-	encodeVarint(b, uint64(tag)<<3|0)
+	encodeVarint(b, uint64(tag)<<3)
 	encodeVarint(b, x)
 }
 
 	}
 }
 
-func encodeStringOpt(b *buffer, tag int, x string) {
-	if x == "" {
-		return
-	}
-	encodeString(b, tag, x)
-}
-
 func encodeBool(b *buffer, tag int, x bool) {
 	if x {
 		encodeUint64(b, tag, 1)
 }
 
 func encodeBoolOpt(b *buffer, tag int, x bool) {
-	if x == false {
-		return
+	if x {
+		encodeBool(b, tag, x)
 	}
-	encodeBool(b, tag, x)
 }
 
 func encodeMessage(b *buffer, tag int, m message) {

profile/proto_test.go

 		{
 			Location: []*Location{testL[0], testL[1], testL[2], testL[1], testL[1]},
 			Label: map[string][]string{
-				"key1": []string{"value1"},
-				"key2": []string{"value2"},
+				"key1": {"value1"},
+				"key2": {"value2"},
 			},
 			Value: []int64{10, 20},
 		},
 			Location: []*Location{testL[1], testL[2], testL[0], testL[1]},
 			Value:    []int64{30, 40},
 			Label: map[string][]string{
-				"key1": []string{"value1"},
-				"key2": []string{"value2"},
+				"key1": {"value1"},
+				"key2": {"value2"},
 			},
 			NumLabel: map[string][]int64{
-				"key1": []int64{1, 2},
-				"key2": []int64{3, 4},
+				"key1": {1, 2},
+				"key2": {3, 4},
 			},
 		},
 	},