update tree for reflect changes

src/pkg/encoding/binary/binary.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 binary implements translation between
 // unsigned integer values and byte sequences
 // and the reading and writing of fixed-size values.
 package binary
 
 import (
@@ skipping 151 matching lines @@
         }
         buf := make([]byte, size)
         e := &encoder{order: order, buf: buf}
         e.value(v)
         _, err := w.Write(buf)
         return err
 }
 
 func TotalSize(v reflect.Value) int {
         if sv, ok := v.(*reflect.SliceValue); ok {
-                elem := sizeof(v.Type().(*reflect.SliceType).Elem())
+                elem := sizeof(v.Type().Elem())
                 if elem < 0 {
                         return -1
                 }
                 return sv.Len() * elem
         }
         return sizeof(v.Type())
 }
 
 func sizeof(v reflect.Type) int {
-        switch t := v.(type) {
-        case *reflect.ArrayType:
+        switch t := v; t.Kind() {
+        case reflect.Array:
                 n := sizeof(t.Elem())
                 if n < 0 {
                         return -1
                 }
                 return t.Len() * n
 
-        case *reflect.StructType:
+        case reflect.Struct:
                 sum := 0
                 for i, n := 0, t.NumField(); i < n; i++ {
                         s := sizeof(t.Field(i).Type)
                         if s < 0 {
                                 return -1
                         }
                         sum += s
                 }
                 return sum
 
-        case *reflect.UintType, *reflect.IntType, *reflect.FloatType, *reflect.ComplexType:
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
                 switch t := t.Kind(); t {
                 case reflect.Int, reflect.Uint, reflect.Uintptr:
                         return -1
                 }
                 return int(v.Size())
         }
         return -1
 }
 
 type decoder struct {
@@ skipping 189 matching lines @@
                         x := v.Get()
                         e.uint32(math.Float32bits(float32(real(x))))
                         e.uint32(math.Float32bits(float32(imag(x))))
                 case reflect.Complex128:
                         x := v.Get()
                         e.uint64(math.Float64bits(real(x)))
                         e.uint64(math.Float64bits(imag(x)))
                 }
         }
 }