code review 4353043: update go tree for reflect changes

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 238 matching lines @@
         p.doPrint(a, true, true)
         s := p.buf.String()
         p.free()
         return s
 }
 
 
 // Get the i'th arg of the struct value.
 // If the arg itself is an interface, return a value for
 // the thing inside the interface, not the interface itself.
-func getField(v *reflect.StructValue, i int) reflect.Value {
+func getField(v reflect.Value, i int) reflect.Value {
         val := v.Field(i)
-        if i, ok := val.(*reflect.InterfaceValue); ok {
+        if i := val; i.Kind() == reflect.Interface {
                 if inter := i.Interface(); inter != nil {
                         return reflect.NewValue(inter)
                 }
         }
         return val
 }
 
 // Convert ASCII to integer.  n is 0 (and got is false) if no number present.
 func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
         if start >= end {
                 return 0, false, end
         }
         for newi = start; newi < end && '0' <= s[newi] && s[newi] <= '9'; newi++ {
                 num = num*10 + int(s[newi]-'0')
                 isnum = true
         }
         return
-}
-
-// Reflection values like reflect.FuncValue implement this method. We use it for %p.
-type uintptrGetter interface {
-        Get() uintptr
 }
 
 func (p *pp) unknownType(v interface{}) {
         if v == nil {
                 p.buf.Write(nilAngleBytes)
                 return
         }
         p.buf.WriteByte('?')
         p.buf.WriteString(reflect.Typeof(v).String())
         p.buf.WriteByte('?')
@@ skipping 220 matching lines @@
                 p.fmt.fmt_sX(s)
         case 'q':
                 p.fmt.fmt_q(s)
         default:
                 p.badVerb(verb, value)
         }
 }
 
 func (p *pp) fmtPointer(field interface{}, value reflect.Value, verb int, goSyntax bool) {
         var u uintptr
-        switch value.(type) {
-        case *reflect.ChanValue, *reflect.FuncValue, *reflect.MapValue, *reflect.PtrValue, *reflect.SliceValue, *reflect.UnsafePointerValue:
-                u = value.(uintptrGetter).Get()
+        switch value.Kind() {
+        case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
+                u = value.Pointer()
         default:
                 p.badVerb(verb, field)
                 return
         }
         if goSyntax {
                 p.add('(')
                 p.buf.WriteString(reflect.Typeof(field).String())
                 p.add(')')
                 p.add('(')
                 if u == 0 {
@@ skipping 115 matching lines @@
                 return verb == 's' || verb == 'v'
         case []byte:
                 p.fmtBytes(f, verb, goSyntax, depth, field)
                 return verb == 's'
         }
 
         // Need to use reflection
         value := reflect.NewValue(field)
 
 BigSwitch:
-        switch f := value.(type) {
-        case *reflect.BoolValue:
-                p.fmtBool(f.Get(), verb, field)
-        case *reflect.IntValue:
-                p.fmtInt64(f.Get(), verb, field)
-        case *reflect.UintValue:
-                p.fmtUint64(uint64(f.Get()), verb, goSyntax, field)
-        case *reflect.FloatValue:
+        switch f := value; f.Kind() {
+        case reflect.Bool:
+                p.fmtBool(f.Bool(), verb, field)
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                p.fmtInt64(f.Int(), verb, field)
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                p.fmtUint64(uint64(f.Uint()), verb, goSyntax, field)
+        case reflect.Float32, reflect.Float64:
                 if f.Type().Size() == 4 {
-                        p.fmtFloat32(float32(f.Get()), verb, field)
+                        p.fmtFloat32(float32(f.Float()), verb, field)
                 } else {
-                        p.fmtFloat64(float64(f.Get()), verb, field)
+                        p.fmtFloat64(float64(f.Float()), verb, field)
                 }
-        case *reflect.ComplexValue:
+        case reflect.Complex64, reflect.Complex128:
                 if f.Type().Size() == 8 {
-                        p.fmtComplex64(complex64(f.Get()), verb, field)
+                        p.fmtComplex64(complex64(f.Complex()), verb, field)
                 } else {
-                        p.fmtComplex128(complex128(f.Get()), verb, field)
+                        p.fmtComplex128(complex128(f.Complex()), verb, field)
                 }
-        case *reflect.StringValue:
-                p.fmtString(f.Get(), verb, goSyntax, field)
-        case *reflect.MapValue:
+        case reflect.String:
+                p.fmtString(f.String(), verb, goSyntax, field)
+        case reflect.Map:
                 if goSyntax {
                         p.buf.WriteString(f.Type().String())
                         p.buf.WriteByte('{')
                 } else {
                         p.buf.Write(mapBytes)
                 }
-                keys := f.Keys()
+                keys := f.MapKeys()
                 for i, key := range keys {
                         if i > 0 {
                                 if goSyntax {
                                         p.buf.Write(commaSpaceBytes)
                                 } else {
                                         p.buf.WriteByte(' ')
                                 }
                         }
                         p.printField(key.Interface(), verb, plus, goSyntax, depth+1)
                         p.buf.WriteByte(':')
-                        p.printField(f.Elem(key).Interface(), verb, plus, goSyntax, depth+1)
+                        p.printField(f.MapIndex(key).Interface(), verb, plus, goSyntax, depth+1)
                 }
                 if goSyntax {
                         p.buf.WriteByte('}')
                 } else {
                         p.buf.WriteByte(']')
                 }
-        case *reflect.StructValue:
+        case reflect.Struct:
                 if goSyntax {
                         p.buf.WriteString(reflect.Typeof(field).String())
                 }
                 p.add('{')
                 v := f
-                t := v.Type().(*reflect.StructType)
+                t := v.Type()
                 for i := 0; i < v.NumField(); i++ {
                         if i > 0 {
                                 if goSyntax {
                                         p.buf.Write(commaSpaceBytes)
                                 } else {
                                         p.buf.WriteByte(' ')
                                 }
                         }
                         if plus || goSyntax {
                                 if f := t.Field(i); f.Name != "" {
                                         p.buf.WriteString(f.Name)
                                         p.buf.WriteByte(':')
                                 }
                         }
                         p.printField(getField(v, i).Interface(), verb, plus, goSyntax, depth+1)
                 }
                 p.buf.WriteByte('}')
-        case *reflect.InterfaceValue:
+        case reflect.Interface:
                 value := f.Elem()
-                if value == nil {
+                if !value.IsValid() {
                         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:
+        case reflect.Array, reflect.Slice:
                 // Byte slices are special.
-                if f.Type().(reflect.ArrayOrSliceType).Elem().Kind() == reflect.Uint8 {
+                if f.Type().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())
+                                bytes[i] = byte(f.Index(i).Uint())
                         }
                         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)
                                 } else {
                                         p.buf.WriteByte(' ')
                                 }
                         }
-                        p.printField(f.Elem(i).Interface(), verb, plus, goSyntax, depth+1)
+                        p.printField(f.Index(i).Interface(), verb, plus, goSyntax, depth+1)
                 }
                 if goSyntax {
                         p.buf.WriteByte('}')
                 } else {
                         p.buf.WriteByte(']')
                 }
-        case *reflect.PtrValue:
-                v := f.Get()
+        case reflect.Ptr:
+                v := f.Pointer()
                 // pointer to array or slice or struct?  ok at top level
                 // but not embedded (avoid loops)
                 if v != 0 && depth == 0 {
-                        switch a := f.Elem().(type) {
-                        case reflect.ArrayOrSliceValue:
+                        switch a := f.Elem(); a.Kind() {
+                        case reflect.Array, reflect.Slice:
                                 p.buf.WriteByte('&')
                                 p.printField(a.Interface(), verb, plus, goSyntax, depth+1)
                                 break BigSwitch
-                        case *reflect.StructValue:
+                        case reflect.Struct:
                                 p.buf.WriteByte('&')
                                 p.printField(a.Interface(), verb, plus, goSyntax, depth+1)
                                 break BigSwitch
                         }
                 }
                 if goSyntax {
                         p.buf.WriteByte('(')
                         p.buf.WriteString(reflect.Typeof(field).String())
                         p.buf.WriteByte(')')
                         p.buf.WriteByte('(')
                         if v == 0 {
                                 p.buf.Write(nilBytes)
                         } else {
                                 p.fmt0x64(uint64(v), true)
                         }
                         p.buf.WriteByte(')')
                         break
                 }
                 if v == 0 {
                         p.buf.Write(nilAngleBytes)
                         break
                 }
                 p.fmt0x64(uint64(v), true)
-        case *reflect.ChanValue, *reflect.FuncValue, *reflect.UnsafePointerValue:
+        case reflect.Chan, reflect.Func, reflect.UnsafePointer:
                 p.fmtPointer(field, value, verb, goSyntax)
         default:
                 p.unknownType(f)
         }
         return false
 }
 
 // intFromArg gets the fieldnumth element of a. On return, isInt reports whether the argument has type int.
 func intFromArg(a []interface{}, end, i, fieldnum int) (num int, isInt bool, newi, newfieldnum int) {
         newi, newfieldnum = end, fieldnum
@@ skipping 114 matching lines @@
                         if addspace || !isString && !prevString {
                                 p.buf.WriteByte(' ')
                         }
                 }
                 prevString = p.printField(field, 'v', false, false, 0)
         }
         if addnewline {
                 p.buf.WriteByte('\n')
         }
 }