all: clean up lint issues, remove more dead code

accounts/abi/abi_test.go

@@ -67,10 +67,10 @@ func TestTypeCheck(t *testing.T) {
 		{"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
 		{"uint16[3]", []uint16{1, 2, 3}, ""},
 		{"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
-		{"address[]", []common.Address{common.Address{1}}, ""},
-		{"address[1]", []common.Address{common.Address{1}}, ""},
-		{"address[1]", [1]common.Address{common.Address{1}}, ""},
-		{"address[2]", [1]common.Address{common.Address{1}}, "abi: cannot use [1]array as type [2]array as argument"},
+		{"address[]", []common.Address{{1}}, ""},
+		{"address[1]", []common.Address{{1}}, ""},
+		{"address[1]", [1]common.Address{{1}}, ""},
+		{"address[2]", [1]common.Address{{1}}, "abi: cannot use [1]array as type [2]array as argument"},
 		{"bytes32", [32]byte{}, ""},
 		{"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
 		{"bytes32", common.Hash{1}, ""},
@@ -80,7 +80,7 @@ func TestTypeCheck(t *testing.T) {
 		{"bytes", [2]byte{0, 1}, ""},
 		{"bytes", common.Hash{1}, ""},
 		{"string", "hello world", ""},
-		{"bytes32[]", [][32]byte{[32]byte{}}, ""},
+		{"bytes32[]", [][32]byte{{}}, ""},
 		{"function", [24]byte{}, ""},
 	} {
 		typ, err := NewType(test.typ)
@@ -343,8 +343,8 @@ func TestPack(t *testing.T) {
 		{"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})},
 		{"bytes20", [20]byte{1}, pad([]byte{1}, 32, false)},
 		{"uint256[]", []*big.Int{big.NewInt(1), big.NewInt(2)}, formatSliceOutput([]byte{1}, []byte{2})},
-		{"address[]", []common.Address{common.Address{1}, common.Address{2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))},
-		{"bytes32[]", []common.Hash{common.Hash{1}, common.Hash{2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))},
+		{"address[]", []common.Address{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))},
+		{"bytes32[]", []common.Hash{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))},
 		{"function", [24]byte{1}, pad([]byte{1}, 32, false)},
 	} {
 		typ, err := NewType(test.typ)
@@ -458,12 +458,12 @@ func TestReader(t *testing.T) {
 	Uint256, _ := NewType("uint256")
 	exp := ABI{
 		Methods: map[string]Method{
-			"balance": Method{
+			"balance": {
 				"balance", true, nil, nil,
 			},
-			"send": Method{
+			"send": {
 				"send", false, []Argument{
-					Argument{"amount", Uint256, false},
+					{"amount", Uint256, false},
 				}, nil,
 			},
 		},
@@ -562,7 +562,7 @@ func TestTestSlice(t *testing.T) {
 
 func TestMethodSignature(t *testing.T) {
 	String, _ := NewType("string")
-	m := Method{"foo", false, []Argument{Argument{"bar", String, false}, Argument{"baz", String, false}}, nil}
+	m := Method{"foo", false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil}
 	exp := "foo(string,string)"
 	if m.Sig() != exp {
 		t.Error("signature mismatch", exp, "!=", m.Sig())
@@ -574,7 +574,7 @@ func TestMethodSignature(t *testing.T) {
 	}
 
 	uintt, _ := NewType("uint")
-	m = Method{"foo", false, []Argument{Argument{"bar", uintt, false}}, nil}
+	m = Method{"foo", false, []Argument{{"bar", uintt, false}}, nil}
 	exp = "foo(uint256)"
 	if m.Sig() != exp {
 		t.Error("signature mismatch", exp, "!=", m.Sig())
@@ -779,8 +779,8 @@ func TestBareEvents(t *testing.T) {
 		"balance": {false, nil},
 		"anon":    {true, nil},
 		"args": {false, []Argument{
-			Argument{Name: "arg0", Type: arg0, Indexed: false},
-			Argument{Name: "arg1", Type: arg1, Indexed: true},
+			{Name: "arg0", Type: arg0, Indexed: false},
+			{Name: "arg1", Type: arg1, Indexed: true},
 		}},
 	}
 

accounts/abi/bind/bind.go

@@ -147,21 +147,21 @@ func bindTypeGo(kind abi.Type) string {
 
 	switch {
 	case strings.HasPrefix(stringKind, "address"):
-		parts := regexp.MustCompile("address(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
 		return fmt.Sprintf("%scommon.Address", parts[1])
 
 	case strings.HasPrefix(stringKind, "bytes"):
-		parts := regexp.MustCompile("bytes([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`bytes([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 3 {
 			return stringKind
 		}
 		return fmt.Sprintf("%s[%s]byte", parts[2], parts[1])
 
 	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
-		parts := regexp.MustCompile("(u)?int([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 4 {
 			return stringKind
 		}
@@ -172,7 +172,7 @@ func bindTypeGo(kind abi.Type) string {
 		return fmt.Sprintf("%s*big.Int", parts[3])
 
 	case strings.HasPrefix(stringKind, "bool") || strings.HasPrefix(stringKind, "string"):
-		parts := regexp.MustCompile("([a-z]+)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`([a-z]+)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 3 {
 			return stringKind
 		}
@@ -191,7 +191,7 @@ func bindTypeJava(kind abi.Type) string {
 
 	switch {
 	case strings.HasPrefix(stringKind, "address"):
-		parts := regexp.MustCompile("address(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
@@ -201,7 +201,7 @@ func bindTypeJava(kind abi.Type) string {
 		return fmt.Sprintf("Addresses")
 
 	case strings.HasPrefix(stringKind, "bytes"):
-		parts := regexp.MustCompile("bytes([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`bytes([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 3 {
 			return stringKind
 		}
@@ -211,7 +211,7 @@ func bindTypeJava(kind abi.Type) string {
 		return "byte[]"
 
 	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
-		parts := regexp.MustCompile("(u)?int([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 4 {
 			return stringKind
 		}
@@ -230,7 +230,7 @@ func bindTypeJava(kind abi.Type) string {
 		return fmt.Sprintf("BigInts")
 
 	case strings.HasPrefix(stringKind, "bool"):
-		parts := regexp.MustCompile("bool(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`bool(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
@@ -240,7 +240,7 @@ func bindTypeJava(kind abi.Type) string {
 		return fmt.Sprintf("bool[]")
 
 	case strings.HasPrefix(stringKind, "string"):
-		parts := regexp.MustCompile("string(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`string(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
@@ -278,7 +278,7 @@ func namedTypeJava(javaKind string, solKind abi.Type) string {
 	case "bool[]":
 		return "Bools"
 	case "BigInt":
-		parts := regexp.MustCompile("(u)?int([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(solKind.String())
+		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(solKind.String())
 		if len(parts) != 4 {
 			return javaKind
 		}

accounts/abi/type.go

@@ -65,7 +65,7 @@ var (
 	//      string     int       uint       fixed
 	//      string32   int8      uint8      uint[]
 	//      address    int256    uint256    fixed128x128[2]
-	fullTypeRegex = regexp.MustCompile("([a-zA-Z0-9]+)(\\[([0-9]*)\\])?")
+	fullTypeRegex = regexp.MustCompile(`([a-zA-Z0-9]+)(\[([0-9]*)\])?`)
 	// typeRegex parses the abi sub types
 	typeRegex = regexp.MustCompile("([a-zA-Z]+)(([0-9]+)(x([0-9]+))?)?")
 )

build/ci.go

@@ -195,7 +195,7 @@ func doInstall(cmdline []string) {
 			if err != nil {
 				log.Fatal(err)
 			}
-			for name, _ := range pkgs {
+			for name := range pkgs {
 				if name == "main" {
 					gobuild := goToolArch(*arch, "build", buildFlags(env)...)
 					gobuild.Args = append(gobuild.Args, "-v")

cmd/ethtest/main.go

@@ -88,12 +88,7 @@ func runTestWithReader(test string, r io.Reader) error {
 	default:
 		err = fmt.Errorf("Invalid test type specified: %v", test)
 	}
-
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return err
 }
 
 func getFiles(path string) ([]string, error) {

cmd/geth/accountcmd_test.go

@@ -148,7 +148,7 @@ Passphrase: {{.InputLine "foobar"}}
 		"Unlocked account f466859ead1932d743d622cb74fc058882e8648a",
 	}
 	for _, m := range wantMessages {
-		if strings.Index(geth.stderrText(), m) == -1 {
+		if !strings.Contains(geth.stderrText(), m) {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}
@@ -193,7 +193,7 @@ Passphrase: {{.InputLine "foobar"}}
 		"Unlocked account 289d485d9771714cce91d3393d764e1311907acc",
 	}
 	for _, m := range wantMessages {
-		if strings.Index(geth.stderrText(), m) == -1 {
+		if !strings.Contains(geth.stderrText(), m) {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}
@@ -212,7 +212,7 @@ func TestUnlockFlagPasswordFile(t *testing.T) {
 		"Unlocked account 289d485d9771714cce91d3393d764e1311907acc",
 	}
 	for _, m := range wantMessages {
-		if strings.Index(geth.stderrText(), m) == -1 {
+		if !strings.Contains(geth.stderrText(), m) {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}
@@ -260,7 +260,7 @@ In order to avoid this warning, you need to remove the following duplicate key f
 		"Unlocked account f466859ead1932d743d622cb74fc058882e8648a",
 	}
 	for _, m := range wantMessages {
-		if strings.Index(geth.stderrText(), m) == -1 {
+		if !strings.Contains(geth.stderrText(), m) {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}

cmd/geth/main.go

@@ -168,7 +168,6 @@ func init() {
 	}
 
 	app.After = func(ctx *cli.Context) error {
-		logger.Flush()
 		debug.Exit()
 		console.Stdin.Close() // Resets terminal mode.
 		return nil

cmd/swarm/main.go

@@ -129,7 +129,7 @@ func init() {
 	app.HideVersion = true // we have a command to print the version
 	app.Copyright = "Copyright 2013-2016 The go-ethereum Authors"
 	app.Commands = []cli.Command{
-		cli.Command{
+		{
 			Action:    version,
 			Name:      "version",
 			Usage:     "Print version numbers",
@@ -138,7 +138,7 @@ func init() {
 The output of this command is supposed to be machine-readable.
 `,
 		},
-		cli.Command{
+		{
 			Action:    upload,
 			Name:      "up",
 			Usage:     "upload a file or directory to swarm using the HTTP API",
@@ -147,7 +147,7 @@ The output of this command is supposed to be machine-readable.
 "upload a file or directory to swarm using the HTTP API and prints the root hash",
 `,
 		},
-		cli.Command{
+		{
 			Action:    hash,
 			Name:      "hash",
 			Usage:     "print the swarm hash of a file or directory",

cmd/utils/cmd.go

@@ -67,7 +67,6 @@ func Fatalf(format string, args ...interface{}) {
 		}
 	}
 	fmt.Fprintf(w, "Fatal: "+format+"\n", args...)
-	logger.Flush()
 	os.Exit(1)
 }
 
@@ -95,7 +94,7 @@ func StartNode(stack *node.Node) {
 
 func FormatTransactionData(data string) []byte {
 	d := common.StringToByteFunc(data, func(s string) (ret []byte) {
-		slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
+		slice := regexp.MustCompile(`\n|\s`).Split(s, 1000000000)
 		for _, dataItem := range slice {
 			d := common.FormatData(dataItem)
 			ret = append(ret, d...)

common/big_test.go

@@ -27,7 +27,7 @@ func TestMisc(t *testing.T) {
 	c := []byte{1, 2, 3, 4}
 	z := BitTest(a, 1)
 
-	if z != true {
+	if !z {
 		t.Error("Expected true got", z)
 	}
 
@@ -79,11 +79,11 @@ func TestBigCopy(t *testing.T) {
 	z := BigToBytes(c, 16)
 	zbytes := []byte{232, 212, 165, 16, 0}
 
-	if bytes.Compare(y, ybytes) != 0 {
+	if !bytes.Equal(y, ybytes) {
 		t.Error("Got", ybytes)
 	}
 
-	if bytes.Compare(z, zbytes) != 0 {
+	if !bytes.Equal(z, zbytes) {
 		t.Error("Got", zbytes)
 	}
 }

common/bytes.go

@@ -143,7 +143,7 @@ func Hex2BytesFixed(str string, flen int) []byte {
 		return h
 	} else {
 		if len(h) > flen {
-			return h[len(h)-flen : len(h)]
+			return h[len(h)-flen:]
 		} else {
 			hh := make([]byte, flen)
 			copy(hh[flen-len(h):flen], h[:])

common/bytes_test.go

@@ -181,7 +181,7 @@ func TestFromHex(t *testing.T) {
 	input := "0x01"
 	expected := []byte{1}
 	result := FromHex(input)
-	if bytes.Compare(expected, result) != 0 {
+	if !bytes.Equal(expected, result) {
 		t.Errorf("Expected % x got % x", expected, result)
 	}
 }
@@ -190,7 +190,7 @@ func TestFromHexOddLength(t *testing.T) {
 	input := "0x1"
 	expected := []byte{1}
 	result := FromHex(input)
-	if bytes.Compare(expected, result) != 0 {
+	if !bytes.Equal(expected, result) {
 		t.Errorf("Expected % x got % x", expected, result)
 	}
 }

common/compiler/solidity.go

@@ -32,7 +32,7 @@ import (
 )
 
 var (
-	versionRegexp = regexp.MustCompile("[0-9]+\\.[0-9]+\\.[0-9]+")
+	versionRegexp = regexp.MustCompile(`[0-9]+\.[0-9]+\.[0-9]+`)
 	solcParams    = []string{
 		"--combined-json", "bin,abi,userdoc,devdoc",
 		"--add-std",  // include standard lib contracts

common/format.go

@@ -27,7 +27,7 @@ import (
 // the unnecessary precision off from the formatted textual representation.
 type PrettyDuration time.Duration
 
-var prettyDurationRe = regexp.MustCompile("\\.[0-9]+")
+var prettyDurationRe = regexp.MustCompile(`\.[0-9]+`)
 
 // String implements the Stringer interface, allowing pretty printing of duration
 // values rounded to three decimals.

common/math/dist_test.go

@@ -41,24 +41,24 @@ func TestSum(t *testing.T) {
 
 func TestDist(t *testing.T) {
 	var vectors = []Vector{
-		Vector{big.NewInt(1000), big.NewInt(1234)},
-		Vector{big.NewInt(500), big.NewInt(10023)},
-		Vector{big.NewInt(1034), big.NewInt(1987)},
-		Vector{big.NewInt(1034), big.NewInt(1987)},
-		Vector{big.NewInt(8983), big.NewInt(1977)},
-		Vector{big.NewInt(98382), big.NewInt(1887)},
-		Vector{big.NewInt(12398), big.NewInt(1287)},
-		Vector{big.NewInt(12398), big.NewInt(1487)},
-		Vector{big.NewInt(12398), big.NewInt(1987)},
-		Vector{big.NewInt(12398), big.NewInt(128)},
-		Vector{big.NewInt(12398), big.NewInt(1987)},
-		Vector{big.NewInt(1398), big.NewInt(187)},
-		Vector{big.NewInt(12328), big.NewInt(1927)},
-		Vector{big.NewInt(12398), big.NewInt(1987)},
-		Vector{big.NewInt(22398), big.NewInt(1287)},
-		Vector{big.NewInt(1370), big.NewInt(1981)},
-		Vector{big.NewInt(12398), big.NewInt(1957)},
-		Vector{big.NewInt(42198), big.NewInt(1987)},
+		{big.NewInt(1000), big.NewInt(1234)},
+		{big.NewInt(500), big.NewInt(10023)},
+		{big.NewInt(1034), big.NewInt(1987)},
+		{big.NewInt(1034), big.NewInt(1987)},
+		{big.NewInt(8983), big.NewInt(1977)},
+		{big.NewInt(98382), big.NewInt(1887)},
+		{big.NewInt(12398), big.NewInt(1287)},
+		{big.NewInt(12398), big.NewInt(1487)},
+		{big.NewInt(12398), big.NewInt(1987)},
+		{big.NewInt(12398), big.NewInt(128)},
+		{big.NewInt(12398), big.NewInt(1987)},
+		{big.NewInt(1398), big.NewInt(187)},
+		{big.NewInt(12328), big.NewInt(1927)},
+		{big.NewInt(12398), big.NewInt(1987)},
+		{big.NewInt(22398), big.NewInt(1287)},
+		{big.NewInt(1370), big.NewInt(1981)},
+		{big.NewInt(12398), big.NewInt(1957)},
+		{big.NewInt(42198), big.NewInt(1987)},
 	}
 
 	VectorsBy(GasSort).Sort(vectors)