code review 2000041: fmt/print: remove a TODO regarding printing renamed byt...

src/pkg/fmt/print.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package fmt
 
 import (
         "bytes"
         "io"
         "os"
@@ skipping 679 matching lines @@
                         if goSyntax {
                                 p.buf.WriteString(reflect.Typeof(field).String())
                                 p.buf.Write(nilParenBytes)
                         } else {
                                 p.buf.Write(nilAngleBytes)
                         }
                 } else {
                         return p.printField(value.Interface(), verb, plus, goSyntax, depth+1)
                 }
         case reflect.ArrayOrSliceValue:
+                // Byte slices are special.
+                if f.Type().(reflect.ArrayOrSliceType).Elem().Kind() == reflect.Uint8 {
+                        // We know it's a slice of bytes, but we also know it does not have static type
+                        // []byte, or it would have been caught above.  Therefore we cannot convert
+                        // it directly in the (slightly) obvious way: f.Interface().([]byte); it doesn't have
+                        // that type, and we can't write an expression of the right type and do a
+                        // conversion because we don't have a static way to write the right type.
+                        // So we build a slice by hand.  This is a rare case but it would be nice
+                        // if reflection could help a little more.
+                        bytes := make([]byte, f.Len())
+                        for i := range bytes {
+                                bytes[i] = byte(f.Elem(i).(*reflect.UintValue).Get())
+                        }
+                        p.fmtBytes(bytes, verb, goSyntax, depth, field)
+                        return verb == 's'
+                }
                 if goSyntax {
                         p.buf.WriteString(reflect.Typeof(field).String())
                         p.buf.WriteByte('{')
                 } else {
                         p.buf.WriteByte('[')
                 }
                 for i := 0; i < f.Len(); i++ {
                         if i > 0 {
                                 if goSyntax {
                                         p.buf.Write(commaSpaceBytes)
@@ skipping 87 matching lines @@
                 // do we have 20 (width)?
                 p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
                 // do we have .20 (precision)?
                 if i < end && format[i] == '.' {
                         p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i+1, end)
                 }
                 c, w = utf8.DecodeRuneInString(format[i:])
                 i += w
                 // percent is special - absorbs no operand
                 if c == '%' {
-                        p.buf.WriteByte('%') // TODO: should we bother with width & prec?
+                        p.buf.WriteByte('%') // We ignore width and prec.
                         continue
                 }
                 if fieldnum >= len(a) { // out of operands
                         p.buf.WriteByte('%')
                         p.add(c)
                         p.buf.Write(missingBytes)
                         continue
                 }
                 field := a[fieldnum]
                 fieldnum++
@@ skipping 31 matching lines @@
                         if addspace || !isString && !prevString {
                                 p.buf.WriteByte(' ')
                         }
                 }
                 prevString = p.printField(field, 'v', false, false, 0)
         }
         if addnewline {
                 p.buf.WriteByte('\n')
         }
 }