update tree for reflect changes

src/pkg/net/dnsmsg.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.
 
 // DNS packet assembly.  See RFC 1035.
 //
 // This is intended to support name resolution during net.Dial.
 // It doesn't have to be blazing fast.
 //
 // Rather than write the usual handful of routines to pack and
@@ skipping 362 matching lines @@
                 off1 = off
         }
         return s, off1, true
 }
 
 // TODO(rsc): Move into generic library?
 // Pack a reflect.StructValue into msg.  Struct members can only be uint16, uint32, string,
 // and other (often anonymous) structs.
 func packStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int, ok bool) {
         for i := 0; i < val.NumField(); i++ {
-                f := val.Type().(*reflect.StructType).Field(i)
+                f := val.Type().Field(i)
                 switch fv := val.Field(i).(type) {
                 default:
                 BadType:
                         fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
                         return len(msg), false
                 case *reflect.StructValue:
                         off, ok = packStructValue(fv, msg, off)
                 case *reflect.UintValue:
                         i := fv.Get()
                         switch fv.Type().Kind() {
@@ skipping 50 matching lines @@
 func packStruct(any interface{}, msg []byte, off int) (off1 int, ok bool) {
         off, ok = packStructValue(structValue(any), msg, off)
         return off, ok
 }
 
 // TODO(rsc): Move into generic library?
 // Unpack a reflect.StructValue from msg.
 // Same restrictions as packStructValue.
 func unpackStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int, ok bool) {
         for i := 0; i < val.NumField(); i++ {
-                f := val.Type().(*reflect.StructType).Field(i)
+                f := val.Type().Field(i)
                 switch fv := val.Field(i).(type) {
                 default:
                 BadType:
                         fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
                         return len(msg), false
                 case *reflect.StructValue:
                         off, ok = unpackStructValue(fv, msg, off)
                 case *reflect.UintValue:
                         switch fv.Type().Kind() {
                         default:
@@ skipping 51 matching lines @@
 // Generic struct printer.
 // Doesn't care about the string tag "domain-name",
 // but does look for an "ipv4" tag on uint32 variables,
 // printing them as IP addresses.
 func printStructValue(val *reflect.StructValue) string {
         s := "{"
         for i := 0; i < val.NumField(); i++ {
                 if i > 0 {
                         s += ", "
                 }
-                f := val.Type().(*reflect.StructType).Field(i)
+                f := val.Type().Field(i)
                 if !f.Anonymous {
                         s += f.Name + "="
                 }
                 fval := val.Field(i)
                 if fv, ok := fval.(*reflect.StructValue); ok {
                         s += printStructValue(fv)
                 } else if fv, ok := fval.(*reflect.UintValue); ok && f.Tag == "ipv4" {
                         i := fv.Get()
                         s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
                 } else {
@@ skipping 197 matching lines @@
                 }
         }
         if len(dns.extra) > 0 {
                 s += "-- Extra\n"
                 for i := 0; i < len(dns.extra); i++ {
                         s += printStruct(dns.extra[i]) + "\n"
                 }
         }
         return s
 }