gc: use gofmt spacing when printing map type

R=ken2
CC=golang-dev
https://golang.org/cl/5450071

diff --git a/src/cmd/gc/fmt.c b/src/cmd/gc/fmt.c
index 453cbc6856166d48a58f47ba3c4999509ad1bfa6..b32aaaab202306382d3c35799dc759e6c644b9c1 100644 (file)
--- a/src/cmd/gc/fmt.c
+++ b/src/cmd/gc/fmt.c
@@ -610,7 +610,7 @@ typefmt(Fmt *fp, Type *t)
                return fmtprint(fp, "chan %T", t->type);
 
        case TMAP:
-               return fmtprint(fp, "map[%T] %T", t->down, t->type);
+               return fmtprint(fp, "map[%T]%T", t->down, t->type);
 
        case TINTER:
                fmtstrcpy(fp, "interface {");
@@ -1067,7 +1067,7 @@ exprfmt(Fmt *f, Node *n, int prec)
                return fmtprint(f, "(%N)", n->left);
 
        case OTMAP:
-               return fmtprint(f, "map[%N] %N", n->left, n->right);
+               return fmtprint(f, "map[%N]%N", n->left, n->right);
 
        case OTCHAN:
                switch(n->etype) {

diff --git a/src/pkg/encoding/xml/marshal_test.go b/src/pkg/encoding/xml/marshal_test.go
index 20bb93b38188e1ecb208582d8bb3852a1b673eea..804076580155a77dd22ea07bcf028905a2be4ac4 100644 (file)
--- a/src/pkg/encoding/xml/marshal_test.go
+++ b/src/pkg/encoding/xml/marshal_test.go
@@ -326,12 +326,12 @@ var marshalErrorTests = []struct {
                        "question": "What do you get when you multiply six by nine?",
                        "answer":   "42",
                },
-               Err:  "xml: unsupported type: map[string] string",
+               Err:  "xml: unsupported type: map[string]string",
                Kind: reflect.Map,
        },
        {
                Value: map[*Ship]bool{nil: false},
-               Err:   "xml: unsupported type: map[*xml.Ship] bool",
+               Err:   "xml: unsupported type: map[*xml.Ship]bool",
                Kind:  reflect.Map,
        },
 }

diff --git a/src/pkg/fmt/fmt_test.go b/src/pkg/fmt/fmt_test.go
index 00aac798cb0fbc845b90daf7eb75525daaa6499e..f937a454ed377b5c8c4f355a67526365ded64563 100644 (file)
--- a/src/pkg/fmt/fmt_test.go
+++ b/src/pkg/fmt/fmt_test.go
@@ -361,8 +361,8 @@ var fmttests = []struct {
        {"%#v", make(chan int), "(chan int)(0xPTR)"},
        {"%#v", uint64(1<<64 - 1), "0xffffffffffffffff"},
        {"%#v", 1000000000, "1000000000"},
-       {"%#v", map[string]int{"a": 1}, `map[string] int{"a":1}`},
-       {"%#v", map[string]B{"a": {1, 2}}, `map[string] fmt_test.B{"a":fmt_test.B{I:1, j:2}}`},
+       {"%#v", map[string]int{"a": 1}, `map[string]int{"a":1}`},
+       {"%#v", map[string]B{"a": {1, 2}}, `map[string]fmt_test.B{"a":fmt_test.B{I:1, j:2}}`},
        {"%#v", []string{"a", "b"}, `[]string{"a", "b"}`},
        {"%#v", SI{}, `fmt_test.SI{I:interface {}(nil)}`},
        {"%#v", []int(nil), `[]int(nil)`},
@@ -371,8 +371,8 @@ var fmttests = []struct {
        {"%#v", &array, `&[5]int{1, 2, 3, 4, 5}`},
        {"%#v", iarray, `[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
        {"%#v", &iarray, `&[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
-       {"%#v", map[int]byte(nil), `map[int] uint8(nil)`},
-       {"%#v", map[int]byte{}, `map[int] uint8{}`},
+       {"%#v", map[int]byte(nil), `map[int]uint8(nil)`},
+       {"%#v", map[int]byte{}, `map[int]uint8{}`},
 
        // slices with other formats
        {"%#x", []int{1, 2, 15}, `[0x1 0x2 0xf]`},

diff --git a/src/pkg/go/ast/print_test.go b/src/pkg/go/ast/print_test.go
index c3153ed6f725abfc96c19b806962e43b0eb1ccf4..89d5af1541e23c7906a92050a329bab5f4302d13 100644 (file)
--- a/src/pkg/go/ast/print_test.go
+++ b/src/pkg/go/ast/print_test.go
@@ -24,7 +24,7 @@ var tests = []struct {
 
        // maps
        {map[string]int{"a": 1},
-               `0  map[string] int (len = 1) {
+               `0  map[string]int (len = 1) {
                1  .  "a": 1
                2  }`},
 

diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go
index b35373c1afff313a580ab86a567614c77acec6af..a9e5d1cade4dfec83625798db6cd93a7a344b305 100644 (file)
--- a/src/pkg/reflect/all_test.go
+++ b/src/pkg/reflect/all_test.go
@@ -64,7 +64,7 @@ var typeTests = []pair{
        {struct{ x (**integer) }{}, "**reflect_test.integer"},
        {struct{ x ([32]int32) }{}, "[32]int32"},
        {struct{ x ([]int8) }{}, "[]int8"},
-       {struct{ x (map[string]int32) }{}, "map[string] int32"},
+       {struct{ x (map[string]int32) }{}, "map[string]int32"},
        {struct{ x (chan<- string) }{}, "chan<- string"},
        {struct {
                x struct {
@@ -180,7 +180,7 @@ var valueTests = []pair{
        {new(**int8), "**int8(0)"},
        {new([5]int32), "[5]int32{0, 0, 0, 0, 0}"},
        {new(**integer), "**reflect_test.integer(0)"},
-       {new(map[string]int32), "map[string] int32{<can't iterate on maps>}"},
+       {new(map[string]int32), "map[string]int32{<can't iterate on maps>}"},
        {new(chan<- string), "chan<- string"},
        {new(func(a int8, b int32)), "func(int8, int32)(0)"},
        {new(struct {
@@ -419,7 +419,7 @@ func TestAll(t *testing.T) {
        testType(t, 8, typ.Elem(), "int32")
 
        typ = TypeOf((map[string]*int32)(nil))
-       testType(t, 9, typ, "map[string] *int32")
+       testType(t, 9, typ, "map[string]*int32")
        mtyp := typ
        testType(t, 10, mtyp.Key(), "string")
        testType(t, 11, mtyp.Elem(), "*int32")

diff --git a/test/escape2.go b/test/escape2.go
index 3f7d6e3a161dbeaf94417a691cf00f4bf83a6f30..13ebe271d8aae4895beca33a71f8709cea540458 100644 (file)
--- a/test/escape2.go
+++ b/test/escape2.go
@@ -614,11 +614,11 @@ func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r"
 }
 
 func foo90(x *int) map[*int]*int { // ERROR "leaking param: x"
-       return map[*int]*int{nil: x} // ERROR "map\[\*int\] \*int literal escapes to heap"
+       return map[*int]*int{nil: x} // ERROR "map\[\*int\]\*int literal escapes to heap"
 }
 
 func foo91(x *int) map[*int]*int { // ERROR "leaking param: x"
-       return map[*int]*int{x: nil} // ERROR "map\[\*int\] \*int literal escapes to heap"
+       return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int literal escapes to heap"
 }
 
 func foo92(x *int) [2]*int { // ERROR "leaking param: x"