all: simplify code using "gofmt -s -w"

Most changes are removing redundant declaration of type when direct
instantiating value of map or slice, e.g. []T{T{}} become []T{{}}.

Small changes are removing the high order of subslice if its value
is the length of slice itself, e.g. T[:len(T)] become T[:].

The following file is excluded due to incompatibility with go1.4,

- src/cmd/compile/internal/gc/ssa.go

Change-Id: Id3abb09401795ce1e6da591a89749cba8502fb26
Reviewed-on: https://go-review.googlesource.com/c/go/+/166437
Run-TryBot: Dave Cheney <dave@cheney.net>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

2 files changed, 45 insertions, 45 deletions

diff --git a/src/encoding/base32/base32_test.go b/src/encoding/base32/base32_test.go
index cbe635161a..eb14f1eb26 100644
--- a/src/encoding/base32/base32_test.go
+++ b/src/encoding/base32/base32_test.go
@@ -539,52 +539,52 @@ func TestBufferedDecodingSameError(t *testing.T) {
 		// NBSWY3DPO5XXE3DE == helloworld
 		// Test with "ZZ" as extra input
 		{"helloworld", [][]string{
-			[]string{"NBSW", "Y3DP", "O5XX", "E3DE", "ZZ"},
-			[]string{"NBSWY3DPO5XXE3DE", "ZZ"},
-			[]string{"NBSWY3DPO5XXE3DEZZ"},
-			[]string{"NBS", "WY3", "DPO", "5XX", "E3D", "EZZ"},
-			[]string{"NBSWY3DPO5XXE3", "DEZZ"},
+			{"NBSW", "Y3DP", "O5XX", "E3DE", "ZZ"},
+			{"NBSWY3DPO5XXE3DE", "ZZ"},
+			{"NBSWY3DPO5XXE3DEZZ"},
+			{"NBS", "WY3", "DPO", "5XX", "E3D", "EZZ"},
+			{"NBSWY3DPO5XXE3", "DEZZ"},
 		}, io.ErrUnexpectedEOF},
 
 		// Test with "ZZY" as extra input
 		{"helloworld", [][]string{
-			[]string{"NBSW", "Y3DP", "O5XX", "E3DE", "ZZY"},
-			[]string{"NBSWY3DPO5XXE3DE", "ZZY"},
-			[]string{"NBSWY3DPO5XXE3DEZZY"},
-			[]string{"NBS", "WY3", "DPO", "5XX", "E3D", "EZZY"},
-			[]string{"NBSWY3DPO5XXE3", "DEZZY"},
+			{"NBSW", "Y3DP", "O5XX", "E3DE", "ZZY"},
+			{"NBSWY3DPO5XXE3DE", "ZZY"},
+			{"NBSWY3DPO5XXE3DEZZY"},
+			{"NBS", "WY3", "DPO", "5XX", "E3D", "EZZY"},
+			{"NBSWY3DPO5XXE3", "DEZZY"},
 		}, io.ErrUnexpectedEOF},
 
 		// Normal case, this is valid input
 		{"helloworld", [][]string{
-			[]string{"NBSW", "Y3DP", "O5XX", "E3DE"},
-			[]string{"NBSWY3DPO5XXE3DE"},
-			[]string{"NBS", "WY3", "DPO", "5XX", "E3D", "E"},
-			[]string{"NBSWY3DPO5XXE3", "DE"},
+			{"NBSW", "Y3DP", "O5XX", "E3DE"},
+			{"NBSWY3DPO5XXE3DE"},
+			{"NBS", "WY3", "DPO", "5XX", "E3D", "E"},
+			{"NBSWY3DPO5XXE3", "DE"},
 		}, nil},
 
 		// MZXW6YTB = fooba
 		{"fooba", [][]string{
-			[]string{"MZXW6YTBZZ"},
-			[]string{"MZXW6YTBZ", "Z"},
-			[]string{"MZXW6YTB", "ZZ"},
-			[]string{"MZXW6YT", "BZZ"},
-			[]string{"MZXW6Y", "TBZZ"},
-			[]string{"MZXW6Y", "TB", "ZZ"},
-			[]string{"MZXW6", "YTBZZ"},
-			[]string{"MZXW6", "YTB", "ZZ"},
-			[]string{"MZXW6", "YT", "BZZ"},
+			{"MZXW6YTBZZ"},
+			{"MZXW6YTBZ", "Z"},
+			{"MZXW6YTB", "ZZ"},
+			{"MZXW6YT", "BZZ"},
+			{"MZXW6Y", "TBZZ"},
+			{"MZXW6Y", "TB", "ZZ"},
+			{"MZXW6", "YTBZZ"},
+			{"MZXW6", "YTB", "ZZ"},
+			{"MZXW6", "YT", "BZZ"},
 		}, io.ErrUnexpectedEOF},
 
 		// Normal case, this is valid input
 		{"fooba", [][]string{
-			[]string{"MZXW6YTB"},
-			[]string{"MZXW6YT", "B"},
-			[]string{"MZXW6Y", "TB"},
-			[]string{"MZXW6", "YTB"},
-			[]string{"MZXW6", "YT", "B"},
-			[]string{"MZXW", "6YTB"},
-			[]string{"MZXW", "6Y", "TB"},
+			{"MZXW6YTB"},
+			{"MZXW6YT", "B"},
+			{"MZXW6Y", "TB"},
+			{"MZXW6", "YTB"},
+			{"MZXW6", "YT", "B"},
+			{"MZXW", "6YTB"},
+			{"MZXW", "6Y", "TB"},
 		}, nil},
 	}
 
diff --git a/src/encoding/binary/example_test.go b/src/encoding/binary/example_test.go
index 6f892c2b8d..b994b897ce 100644
--- a/src/encoding/binary/example_test.go
+++ b/src/encoding/binary/example_test.go
@@ -132,12 +132,12 @@ func ExamplePutVarint() {
 
 func ExampleUvarint() {
 	inputs := [][]byte{
-		[]byte{0x01},
-		[]byte{0x02},
-		[]byte{0x7f},
-		[]byte{0x80, 0x01},
-		[]byte{0xff, 0x01},
-		[]byte{0x80, 0x02},
+		{0x01},
+		{0x02},
+		{0x7f},
+		{0x80, 0x01},
+		{0xff, 0x01},
+		{0x80, 0x02},
 	}
 	for _, b := range inputs {
 		x, n := binary.Uvarint(b)
@@ -157,15 +157,15 @@ func ExampleUvarint() {
 
 func ExampleVarint() {
 	inputs := [][]byte{
-		[]byte{0x81, 0x01},
-		[]byte{0x7f},
-		[]byte{0x03},
-		[]byte{0x01},
-		[]byte{0x00},
-		[]byte{0x02},
-		[]byte{0x04},
-		[]byte{0x7e},
-		[]byte{0x80, 0x01},
+		{0x81, 0x01},
+		{0x7f},
+		{0x03},
+		{0x01},
+		{0x00},
+		{0x02},
+		{0x04},
+		{0x7e},
+		{0x80, 0x01},
 	}
 	for _, b := range inputs {
 		x, n := binary.Varint(b)