From 57331b79da3920ba579a07a20827ee4499cf1c7e Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Fri, 26 Aug 2016 23:39:50 +0000 Subject: [PATCH] Revert "cmd/compile: use printer in typefmt, Tconv" This reverts commit 8fb0893307b0d4ab4a115a6151ee8d344d3c1d74. Broke go/ast tests. Change-Id: I5c314cb29731d4bc3a0873af8ebfe376f5faba8a Reviewed-on: https://go-review.googlesource.com/27923 Reviewed-by: Matthew Dempsky --- src/cmd/compile/internal/gc/fmt.go | 133 +++++++++++++++-------------- 1 file changed, 67 insertions(+), 66 deletions(-) diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go index c76433dddf..5f4c85b44c 100644 --- a/src/cmd/compile/internal/gc/fmt.go +++ b/src/cmd/compile/internal/gc/fmt.go @@ -5,6 +5,7 @@ package gc import ( + "bytes" "cmd/internal/obj" "fmt" "strconv" @@ -529,21 +530,21 @@ var basicnames = []string{ TBLANK: "blank", } -func (p *printer) typefmt(t *Type, flag FmtFlag) *printer { +func typefmt(t *Type, flag FmtFlag) string { if t == nil { - return p.s("") + return "" } if t == bytetype || t == runetype { // in %-T mode collapse rune and byte with their originals. if fmtmode != FTypeId { - return p.s(sconv(t.Sym, FmtShort)) + return sconv(t.Sym, FmtShort) } t = Types[t.Etype] } if t == errortype { - return p.s("error") + return "error" } // Unless the 'l' flag was specified, if the type has a name, just print that name. @@ -552,21 +553,21 @@ func (p *printer) typefmt(t *Type, flag FmtFlag) *printer { case FTypeId: if flag&FmtShort != 0 { if t.Vargen != 0 { - p.f("%v·%d", sconv(t.Sym, FmtShort), t.Vargen) + return fmt.Sprintf("%v·%d", sconv(t.Sym, FmtShort), t.Vargen) } - return p.s(sconv(t.Sym, FmtShort)) + return sconv(t.Sym, FmtShort) } if flag&FmtUnsigned != 0 { - return p.s(sconv(t.Sym, FmtUnsigned)) + return sconv(t.Sym, FmtUnsigned) } if t.Sym.Pkg == localpkg && t.Vargen != 0 { - p.f("%v·%d", t.Sym, t.Vargen) + return fmt.Sprintf("%v·%d", t.Sym, t.Vargen) } } - return p.s(sconv(t.Sym, 0)) + return sconv(t.Sym, 0) } if int(t.Etype) < len(basicnames) && basicnames[t.Etype] != "" { @@ -574,100 +575,102 @@ func (p *printer) typefmt(t *Type, flag FmtFlag) *printer { if fmtmode == FErr && (t == idealbool || t == idealstring) { prefix = "untyped " } - return p.s(prefix + basicnames[t.Etype]) + return prefix + basicnames[t.Etype] } if fmtmode == FDbg { fmtmode = 0 - p.s(t.Etype.String()).s("-").typefmt(t, flag) + str := t.Etype.String() + "-" + typefmt(t, flag) fmtmode = FDbg - return p + return str } switch t.Etype { case TPTR32, TPTR64: if fmtmode == FTypeId && (flag&FmtShort != 0) { - return p.s("*" + Tconv(t.Elem(), FmtShort)) + return "*" + Tconv(t.Elem(), FmtShort) } - return p.s("*" + t.Elem().String()) + return "*" + t.Elem().String() case TARRAY: if t.isDDDArray() { - return p.s("[...]" + t.Elem().String()) + return "[...]" + t.Elem().String() } - p.f("[%d]%v", t.NumElem(), t.Elem()) + return fmt.Sprintf("[%d]%v", t.NumElem(), t.Elem()) case TSLICE: - return p.s("[]" + t.Elem().String()) + return "[]" + t.Elem().String() case TCHAN: switch t.ChanDir() { case Crecv: - return p.s("<-chan " + t.Elem().String()) + return "<-chan " + t.Elem().String() case Csend: - return p.s("chan<- " + t.Elem().String()) + return "chan<- " + t.Elem().String() } if t.Elem() != nil && t.Elem().IsChan() && t.Elem().Sym == nil && t.Elem().ChanDir() == Crecv { - return p.s("chan (" + t.Elem().String() + ")") + return "chan (" + t.Elem().String() + ")" } - return p.s("chan " + t.Elem().String()) + return "chan " + t.Elem().String() case TMAP: - return p.s("map[" + t.Key().String() + "]" + t.Val().String()) + return "map[" + t.Key().String() + "]" + t.Val().String() case TINTER: - p.s("interface {") + var buf bytes.Buffer + buf.WriteString("interface {") for i, f := range t.Fields().Slice() { if i != 0 { - p.s(";") + buf.WriteString(";") } - p.s(" ") + buf.WriteString(" ") switch { case f.Sym == nil: // Check first that a symbol is defined for this type. // Wrong interface definitions may have types lacking a symbol. break case exportname(f.Sym.Name): - p.s(sconv(f.Sym, FmtShort)) + buf.WriteString(sconv(f.Sym, FmtShort)) default: - p.s(sconv(f.Sym, FmtUnsigned)) + buf.WriteString(sconv(f.Sym, FmtUnsigned)) } - p.s(Tconv(f.Type, FmtShort)) + buf.WriteString(Tconv(f.Type, FmtShort)) } if t.NumFields() != 0 { - p.s(" ") + buf.WriteString(" ") } - p.s("}") - return p + buf.WriteString("}") + return buf.String() case TFUNC: + var buf bytes.Buffer if flag&FmtShort != 0 { // no leading func } else { if t.Recv() != nil { - p.s("method") - p.s(Tconv(t.Recvs(), 0)) - p.s(" ") + buf.WriteString("method") + buf.WriteString(Tconv(t.Recvs(), 0)) + buf.WriteString(" ") } - p.s("func") + buf.WriteString("func") } - p.s(Tconv(t.Params(), 0)) + buf.WriteString(Tconv(t.Params(), 0)) switch t.Results().NumFields() { case 0: // nothing to do case 1: - p.s(" ") - p.s(Tconv(t.Results().Field(0).Type, 0)) // struct->field->field's type + buf.WriteString(" ") + buf.WriteString(Tconv(t.Results().Field(0).Type, 0)) // struct->field->field's type default: - p.s(" ") - p.s(Tconv(t.Results(), 0)) + buf.WriteString(" ") + buf.WriteString(Tconv(t.Results(), 0)) } - return p + return buf.String() case TSTRUCT: if m := t.StructType().Map; m != nil { @@ -675,67 +678,68 @@ func (p *printer) typefmt(t *Type, flag FmtFlag) *printer { // Format the bucket struct for map[x]y as map.bucket[x]y. // This avoids a recursive print that generates very long names. if mt.Bucket == t { - return p.s("map.bucket[" + m.Key().String() + "]" + m.Val().String()) + return "map.bucket[" + m.Key().String() + "]" + m.Val().String() } if mt.Hmap == t { - return p.s("map.hdr[" + m.Key().String() + "]" + m.Val().String()) + return "map.hdr[" + m.Key().String() + "]" + m.Val().String() } if mt.Hiter == t { - return p.s("map.iter[" + m.Key().String() + "]" + m.Val().String()) + return "map.iter[" + m.Key().String() + "]" + m.Val().String() } Yyerror("unknown internal map type") } + var buf bytes.Buffer if t.IsFuncArgStruct() { - p.s("(") + buf.WriteString("(") var flag1 FmtFlag if fmtmode == FTypeId || fmtmode == FErr { // no argument names on function signature, and no "noescape"/"nosplit" tags flag1 = FmtShort } for i, f := range t.Fields().Slice() { if i != 0 { - p.s(", ") + buf.WriteString(", ") } - p.s(Fldconv(f, flag1)) + buf.WriteString(Fldconv(f, flag1)) } - p.s(")") + buf.WriteString(")") } else { - p.s("struct {") + buf.WriteString("struct {") for i, f := range t.Fields().Slice() { if i != 0 { - p.s(";") + buf.WriteString(";") } - p.s(" ") - p.s(Fldconv(f, FmtLong)) + buf.WriteString(" ") + buf.WriteString(Fldconv(f, FmtLong)) } if t.NumFields() != 0 { - p.s(" ") + buf.WriteString(" ") } - p.s("}") + buf.WriteString("}") } - return p + return buf.String() case TFORW: if t.Sym != nil { - return p.s("undefined " + t.Sym.String()) + return "undefined " + t.Sym.String() } - return p.s("undefined") + return "undefined" case TUNSAFEPTR: - return p.s("unsafe.Pointer") + return "unsafe.Pointer" case TDDDFIELD: - p.f("%v <%v> %v", t.Etype, t.Sym, t.DDDField()) + return fmt.Sprintf("%v <%v> %v", t.Etype, t.Sym, t.DDDField()) case Txxx: - return p.s("Txxx") + return "Txxx" } // Don't know how to handle - fall back to detailed prints. - return p.f("%v <%v> %v", t.Etype, t.Sym, t.Elem()) + return fmt.Sprintf("%v <%v> %v", t.Etype, t.Sym, t.Elem()) } // Statements which may be rendered with a simplestmt as init. @@ -1597,8 +1601,6 @@ func Fldconv(f *Field, flag FmtFlag) string { // 'h' omit 'func' and receiver from function types, short type names // 'u' package name, not prefix (FTypeId mode, sticky) func Tconv(t *Type, flag FmtFlag) string { - var p printer - if t == nil { return "" } @@ -1618,7 +1620,7 @@ func Tconv(t *Type, flag FmtFlag) string { flag |= FmtUnsigned } - p.typefmt(t, flag) + str := typefmt(t, flag) if fmtmode == FTypeId && (sf&FmtUnsigned != 0) { fmtpkgpfx-- @@ -1628,8 +1630,7 @@ func Tconv(t *Type, flag FmtFlag) string { fmtbody = sb fmtmode = sm t.Trecur-- - - return p.String() + return str } func (n *Node) String() string {