[dev.power64] code review 160200044: build: merge default into dev.power64

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 (
         "errors"
         "io"
         "os"
@@ skipping 814 matching lines @@
         if value.CanInterface() {
                 p.arg = value.Interface()
         }
         if isString, handled := p.handleMethods(verb, plus, goSyntax, depth); handled {
                 return isString
         }
 
         return p.printReflectValue(value, verb, plus, goSyntax, depth)
 }
 
+var byteType = reflect.TypeOf(byte(0))
+
 // printReflectValue is the fallback for both printArg and printValue.
 // It uses reflect to print the value.
 func (p *pp) printReflectValue(value reflect.Value, verb rune, plus, goSyntax bool, depth int) (wasString bool) {
         oldValue := p.value
         p.value = value
 BigSwitch:
         switch f := value; f.Kind() {
         case reflect.Bool:
                 p.fmtBool(f.Bool(), verb)
         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
@@ skipping 73 matching lines @@
                         if goSyntax {
                                 p.buf.WriteString(f.Type().String())
                                 p.buf.Write(nilParenBytes)
                         } else {
                                 p.buf.Write(nilAngleBytes)
                         }
                 } else {
                         wasString = p.printValue(value, verb, plus, goSyntax, depth+1)
                 }
         case reflect.Array, reflect.Slice:
-                // Byte slices are special.
-                if typ := f.Type(); typ.Elem().Kind() == reflect.Uint8 {
+                // Byte slices are special:
+                // - Handle []byte (== []uint8) with fmtBytes.
+                // - Handle []T, where T is a named byte type, with fmtBytes only
+                //   for the s, q, an x verbs. For other verbs, T might be a
+                //   Stringer, so we use printValue to print each element.
+                if typ := f.Type(); typ.Elem().Kind() == reflect.Uint8 && (typ.Elem() == byteType || verb == 's' || verb == 'q' || verb == 'x') {
                         var bytes []byte
                         if f.Kind() == reflect.Slice {
                                 bytes = f.Bytes()
                         } else if f.CanAddr() {
                                 bytes = f.Slice(0, f.Len()).Bytes()
                         } else {
                                 // We have an array, but we cannot Slice() a non-addressable array,
                                 // 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())
@@ skipping 250 matching lines @@
                         if addspace || !isString && !prevString {
                                 p.buf.WriteByte(' ')
                         }
                 }
                 prevString = p.printArg(arg, 'v', false, false, 0)
         }
         if addnewline {
                 p.buf.WriteByte('\n')
         }
 }