Better rendering for implicit types.

render/render.go

 // Copyright 2015 The Chromium 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 render
 
 import (
         "bytes"
         "fmt"
         "reflect"
         "sort"
         "strconv"
 )
 
-var implicitTypeMap = map[reflect.Kind]string{
+var builtinTypeMap = map[reflect.Kind]string{
         reflect.Bool:       "bool",
-        reflect.String:     "string",
-        reflect.Int:        "int",
-        reflect.Int8:       "int8",
+        reflect.Complex128: "complex128",
+        reflect.Complex64:  "complex64",
+        reflect.Float32:    "float32",
+        reflect.Float64:    "float64",
         reflect.Int16:      "int16",
         reflect.Int32:      "int32",
         reflect.Int64:      "int64",
-        reflect.Uint:       "uint",
-        reflect.Uint8:      "uint8",
+        reflect.Int8:       "int8",
+        reflect.Int:        "int",
+        reflect.String:     "string",
         reflect.Uint16:     "uint16",
         reflect.Uint32:     "uint32",
         reflect.Uint64:     "uint64",
-        reflect.Float32:    "float32",
-        reflect.Float64:    "float64",
-        reflect.Complex64:  "complex64",
-        reflect.Complex128: "complex128",
+        reflect.Uint8:      "uint8",
+        reflect.Uint:       "uint",
+        reflect.Uintptr:    "uintptr",
 }
 
+var builtinTypeSet = map[string]struct{}{}
+
+func init() {
+        for _, v := range builtinTypeMap {
+                builtinTypeSet[v] = struct{}{}
+        }
+}
+
+var typeOfString = reflect.TypeOf("")
+var typeOfInt = reflect.TypeOf(int(1))
+var typeOfUint = reflect.TypeOf(uint(1))
+var typeOfFloat = reflect.TypeOf(10.1)
+
 // Render converts a structure to a string representation. Unline the "%#v"
 // format string, this resolves pointer types' contents in structs, maps, and
 // slices/arrays and prints their field values.
 func Render(v interface{}) string {
         buf := bytes.Buffer{}
         s := (*traverseState)(nil)
-        s.render(&buf, 0, reflect.ValueOf(v))
+        s.render(&buf, 0, reflect.ValueOf(v), false)
         return buf.String()
 }
 
 // renderPointer is called to render a pointer value.
 //
 // This is overridable so that the test suite can have deterministic pointer
 // values in its expectations.
 var renderPointer = func(buf *bytes.Buffer, p uintptr) {
         fmt.Fprintf(buf, "0x%016x", p)
 }
@@ skipping 14 matching lines @@
                 }
         }
 
         fs := &traverseState{
                 parent: s,
                 ptr:    ptr,
         }
         return fs
 }
 
-func (s *traverseState) render(buf *bytes.Buffer, ptrs int, v reflect.Value) {
+func (s *traverseState) render(buf *bytes.Buffer, ptrs int, v reflect.Value, implicit bool) {
         if v.Kind() == reflect.Invalid {
                 buf.WriteString("nil")
                 return
         }
         vt := v.Type()
 
         // If the type being rendered is a potentially recursive type (a type that
         // can contain itself as a member), we need to avoid recursion.
         //
         // If we've already seen this type before, mark that this is the case and
@@ skipping 14 matching lines @@
                         pe = v.Pointer()
                 }
 
         case reflect.Slice, reflect.Map:
                 pe = v.Pointer()
         }
         if pe != 0 {
                 s = s.forkFor(pe)
                 if s == nil {
                         buf.WriteString("<REC(")
-                        writeType(buf, ptrs, vt)
+                        if !implicit {
+                                writeType(buf, ptrs, vt)
+                        }
                         buf.WriteString(")>")
                         return
                 }
         }
 
+        isAnon := func(t reflect.Type) bool {
+                if t.Name() != "" {
+                        if _, ok := builtinTypeSet[t.Name()]; !ok {
+                                return false
+                        }
+                }
+                return t.Kind() != reflect.Interface
+        }
+
         switch vk {
         case reflect.Struct:
-                writeType(buf, ptrs, vt)
+                if !implicit {
+                        writeType(buf, ptrs, vt)
+                }
+                structAnon := vt.Name() == ""
                 buf.WriteRune('{')
                 for i := 0; i < vt.NumField(); i++ {
                         if i > 0 {
                                 buf.WriteString(", ")
                         }
-                        buf.WriteString(vt.Field(i).Name)
-                        buf.WriteRune(':')
+                        anon := structAnon && isAnon(vt.Field(i).Type)
 
-                        s.render(buf, 0, v.Field(i))
+                        if !anon {
+                                buf.WriteString(vt.Field(i).Name)
+                                buf.WriteRune(':')
+                        }
+
+                        s.render(buf, 0, v.Field(i), anon)
                 }
                 buf.WriteRune('}')
 
         case reflect.Slice:
                 if v.IsNil() {
-                        writeType(buf, ptrs, vt)
-                        buf.WriteString("(nil)")
+                        if !implicit {
+                                writeType(buf, ptrs, vt)
+                                buf.WriteString("(nil)")
+                        } else {
+                                buf.WriteString("nil")
+                        }
                         return
                 }
                 fallthrough
 
         case reflect.Array:
-                writeType(buf, ptrs, vt)
+                if !implicit {
+                        writeType(buf, ptrs, vt)
+                }
+                anon := vt.Name() == "" && isAnon(vt.Elem())
                 buf.WriteString("{")
                 for i := 0; i < v.Len(); i++ {
                         if i > 0 {
                                 buf.WriteString(", ")
                         }
 
-                        s.render(buf, 0, v.Index(i))
+                        s.render(buf, 0, v.Index(i), anon)
                 }
                 buf.WriteRune('}')
 
         case reflect.Map:
-                writeType(buf, ptrs, vt)
+                if !implicit {
+                        writeType(buf, ptrs, vt)
+                }
                 if v.IsNil() {
                         buf.WriteString("(nil)")
                 } else {
                         buf.WriteString("{")
 
                         mkeys := v.MapKeys()
                         tryAndSortMapKeys(vt, mkeys)
 
+                        kt := vt.Key()
+                        keyAnon := typeOfString.ConvertibleTo(kt) || typeOfInt.ConvertibleTo(kt) || typeOfUint.ConvertibleTo(kt) || typeOfFloat.ConvertibleTo(kt)
+                        valAnon := vt.Name() == "" && isAnon(vt.Elem())
                         for i, mk := range mkeys {
                                 if i > 0 {
                                         buf.WriteString(", ")
                                 }
 
-                                s.render(buf, 0, mk)
+                                s.render(buf, 0, mk, keyAnon)
                                 buf.WriteString(":")
-                                s.render(buf, 0, v.MapIndex(mk))
+                                s.render(buf, 0, v.MapIndex(mk), valAnon)
                         }
                         buf.WriteRune('}')
                 }
 
         case reflect.Ptr:
                 ptrs++
                 fallthrough
         case reflect.Interface:
                 if v.IsNil() {
                         writeType(buf, ptrs, v.Type())
-                        buf.WriteRune('(')
-                        fmt.Fprint(buf, "nil")
-                        buf.WriteRune(')')
+                        buf.WriteString("(nil)")
                 } else {
-                        s.render(buf, ptrs, v.Elem())
+                        s.render(buf, ptrs, v.Elem(), false)
                 }
 
         case reflect.Chan, reflect.Func, reflect.UnsafePointer:
                 writeType(buf, ptrs, vt)
                 buf.WriteRune('(')
                 renderPointer(buf, v.Pointer())
                 buf.WriteRune(')')
 
         default:
                 tstr := vt.String()
-                implicit := ptrs == 0 && implicitTypeMap[vk] == tstr
+                implicit = implicit || (ptrs == 0 && builtinTypeMap[vk] == tstr)
                 if !implicit {
                         writeType(buf, ptrs, vt)
                         buf.WriteRune('(')
                 }
 
                 switch vk {
                 case reflect.String:
                         fmt.Fprintf(buf, "%q", v.String())
                 case reflect.Bool:
                         fmt.Fprintf(buf, "%v", v.Bool())
 
                 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                         fmt.Fprintf(buf, "%d", v.Int())
 
-                case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
                         fmt.Fprintf(buf, "%d", v.Uint())
 
                 case reflect.Float32, reflect.Float64:
                         fmt.Fprintf(buf, "%g", v.Float())
 
                 case reflect.Complex64, reflect.Complex128:
                         fmt.Fprintf(buf, "%g", v.Complex())
                 }
 
                 if !implicit {
@@ skipping 98 matching lines @@
         // Try our stock sortable values.
         switch mt.Key().Kind() {
         case reflect.String, reflect.Int:
                 vs := &sortableValueSlice{
                         kind:     mt.Key().Kind(),
                         elements: k,
                 }
                 sort.Sort(vs)
         }
 }