languages/go
languages/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-05 18:36:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

gc: use gofmt spacing when printing map type

Browse source 
R=ken2
CC=golang-dev
https://golang.org/cl/5450071
This commit is contained in:
Russ Cox 2011-12-02 14:45:07 -05:00
parent dcf1d7bc0e
commit 434a6c85cb
6 changed files with 14 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/cmd/gc/fmt.c
View file

@ -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) {

4
src/pkg/encoding/xml/marshal_test.go
View file

@ -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,
},
}

8
src/pkg/fmt/fmt_test.go
View file

@ -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]`},

2
src/pkg/go/ast/print_test.go
View file

@ -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 }`},

6
src/pkg/reflect/all_test.go
View file

@ -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")

4
test/escape2.go
View file

@ -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"