update protocol library to new reflection API.

update golden files.

R=rsc
CC=dsymonds
http://codereview.appspot.com/1698044

compiler/testdata/test.pb.go.golden

@@ -3,9 +3,12 @@
 
 package my_test
 
-import "goprotobuf.googlecode.com/hg/proto"
+import proto "goprotobuf.googlecode.com/hg/proto"
 import imp "imp.pb"
 
+// Reference proto import to suppress error if it's not otherwise used.
+var _ = proto.GetString
+
 type HatType int32
 const (
 	HatType_FEDORA = 1
@@ -108,7 +111,7 @@ func (this *Reply) ExtensionMap() map[int32][]byte {
 }
 
 type Reply_Entry struct {
-	KeyThatNeeds_1234camel_CasIng	*int64	"PB(varint,1,req,name=key_that_needs_1234camel_CasIng)"
+	KeyThatNeeds_1234Camel_CasIng	*int64	"PB(varint,1,req,name=key_that_needs_1234camel_CasIng)"
 	Value	*int64	"PB(varint,2,opt,name=value,def=7)"
 	XMyFieldName_2	*int64	"PB(varint,3,opt,name=_my_field_name_2)"
 	XXX_unrecognized	[]byte

proto/properties.go

@@ -229,6 +229,7 @@ func (p *Properties) setEncAndDec(typ reflect.Type) {
 	case *reflect.PtrType:
 		switch t2 := t1.Elem().(type) {
 		default:
+		BadType:
 			fmt.Fprintf(os.Stderr, "proto: no encoder function for %T -> %T\n", t1, t2)
 			break
 		case *reflect.BoolType:
@@ -236,26 +237,36 @@ func (p *Properties) setEncAndDec(typ reflect.Type) {
 			p.dec = (*Buffer).dec_bool
 			p.alignof = unsafe.Alignof(vbool)
 			p.sizeof = unsafe.Sizeof(vbool)
-		case *reflect.Int32Type, *reflect.Uint32Type:
-			p.enc = (*Buffer).enc_int32
-			p.dec = (*Buffer).dec_int32
-			p.alignof = unsafe.Alignof(vint32)
-			p.sizeof = unsafe.Sizeof(vint32)
-		case *reflect.Int64Type, *reflect.Uint64Type:
-			p.enc = (*Buffer).enc_int64
-			p.dec = (*Buffer).dec_int64
-			p.alignof = unsafe.Alignof(vint64)
-			p.sizeof = unsafe.Sizeof(vint64)
-		case *reflect.Float32Type:
-			p.enc = (*Buffer).enc_int32 // can just treat them as bits
-			p.dec = (*Buffer).dec_int32
-			p.alignof = unsafe.Alignof(vfloat32)
-			p.sizeof = unsafe.Sizeof(vfloat32)
-		case *reflect.Float64Type:
-			p.enc = (*Buffer).enc_int64 // can just treat them as bits
-			p.dec = (*Buffer).dec_int64
-			p.alignof = unsafe.Alignof(vfloat64)
-			p.sizeof = unsafe.Sizeof(vfloat64)
+		case *reflect.IntType, *reflect.UintType:
+			switch t2.Bits() {
+			case 32:
+				p.enc = (*Buffer).enc_int32
+				p.dec = (*Buffer).dec_int32
+				p.alignof = unsafe.Alignof(vint32)
+				p.sizeof = unsafe.Sizeof(vint32)
+			case 64:
+				p.enc = (*Buffer).enc_int64
+				p.dec = (*Buffer).dec_int64
+				p.alignof = unsafe.Alignof(vint64)
+				p.sizeof = unsafe.Sizeof(vint64)
+			default:
+				goto BadType
+			}
+		case *reflect.FloatType:
+			switch t2.Bits() {
+			case 32:
+				p.enc = (*Buffer).enc_int32 // can just treat them as bits
+				p.dec = (*Buffer).dec_int32
+				p.alignof = unsafe.Alignof(vfloat32)
+				p.sizeof = unsafe.Sizeof(vfloat32)
+			case 64:
+				p.enc = (*Buffer).enc_int64 // can just treat them as bits
+				p.dec = (*Buffer).dec_int64
+				p.alignof = unsafe.Alignof(vfloat64)
+				p.sizeof = unsafe.Sizeof(vfloat64)
+			default:
+				goto BadType
+			}
 		case *reflect.StringType:
 			p.enc = (*Buffer).enc_string
 			p.dec = (*Buffer).dec_string
@@ -275,38 +286,51 @@ func (p *Properties) setEncAndDec(typ reflect.Type) {
 	case *reflect.SliceType:
 		switch t2 := t1.Elem().(type) {
 		default:
-			fmt.Fprintf(os.Stderr, "proto: no oenc for %T -> %T\n", t1, t2)
+		BadSliceType:
+			fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2)
 			break
-		case *reflect.Uint8Type:
-			p.enc = (*Buffer).enc_slice_byte
-			p.dec = (*Buffer).dec_slice_byte
-			p.alignof = unsafe.Alignof(vbyte)
-			p.sizeof = startSize * unsafe.Sizeof(vbyte)
 		case *reflect.BoolType:
 			p.enc = (*Buffer).enc_slice_bool
 			p.dec = (*Buffer).dec_slice_bool
 			p.alignof = unsafe.Alignof(vbool)
 			p.sizeof = startSize * unsafe.Sizeof(vbool)
-		case *reflect.Int32Type, *reflect.Uint32Type:
-			p.enc = (*Buffer).enc_slice_int32
-			p.dec = (*Buffer).dec_slice_int32
-			p.alignof = unsafe.Alignof(vint32)
-			p.sizeof = startSize * unsafe.Sizeof(vint32)
-		case *reflect.Int64Type, *reflect.Uint64Type:
-			p.enc = (*Buffer).enc_slice_int64
-			p.dec = (*Buffer).dec_slice_int64
-			p.alignof = unsafe.Alignof(vint64)
-			p.sizeof = startSize * unsafe.Sizeof(vint64)
-		case *reflect.Float32Type:
-			p.enc = (*Buffer).enc_slice_int32 // can just treat them as bits
-			p.dec = (*Buffer).dec_slice_int32
-			p.alignof = unsafe.Alignof(vfloat32)
-			p.sizeof = startSize * unsafe.Sizeof(vfloat32)
-		case *reflect.Float64Type:
-			p.enc = (*Buffer).enc_slice_int64 // can just treat them as bits
-			p.dec = (*Buffer).dec_slice_int64
-			p.alignof = unsafe.Alignof(vfloat64)
-			p.sizeof = startSize * unsafe.Sizeof(vfloat64)
+		case *reflect.IntType, *reflect.UintType:
+			switch t2.Bits() {
+			case 32:
+				p.enc = (*Buffer).enc_slice_int32
+				p.dec = (*Buffer).dec_slice_int32
+				p.alignof = unsafe.Alignof(vint32)
+				p.sizeof = startSize * unsafe.Sizeof(vint32)
+			case 64:
+				p.enc = (*Buffer).enc_slice_int64
+				p.dec = (*Buffer).dec_slice_int64
+				p.alignof = unsafe.Alignof(vint64)
+				p.sizeof = startSize * unsafe.Sizeof(vint64)
+			case 8:
+				if t2.Kind() == reflect.Uint8 {
+					p.enc = (*Buffer).enc_slice_byte
+					p.dec = (*Buffer).dec_slice_byte
+					p.alignof = unsafe.Alignof(vbyte)
+					p.sizeof = startSize * unsafe.Sizeof(vbyte)
+				}
+			default:
+				goto BadSliceType
+			}
+		case *reflect.FloatType:
+			switch t2.Bits() {
+			case 32:
+				p.enc = (*Buffer).enc_slice_int32 // can just treat them as bits
+				p.dec = (*Buffer).dec_slice_int32
+				p.alignof = unsafe.Alignof(vfloat32)
+				p.sizeof = startSize * unsafe.Sizeof(vfloat32)
+			case 64:
+				p.enc = (*Buffer).enc_slice_int64 // can just treat them as bits
+				p.dec = (*Buffer).dec_slice_int64
+				p.alignof = unsafe.Alignof(vfloat64)
+				p.sizeof = startSize * unsafe.Sizeof(vfloat64)
+			default:
+				goto BadSliceType
+			}
 		case *reflect.StringType:
 			p.enc = (*Buffer).enc_slice_string
 			p.dec = (*Buffer).dec_slice_string
@@ -315,7 +339,7 @@ func (p *Properties) setEncAndDec(typ reflect.Type) {
 		case *reflect.PtrType:
 			switch t3 := t2.Elem().(type) {
 			default:
-				fmt.Fprintf(os.Stderr, "proto: no oenc for %T -> %T -> %T\n", t1, t2, t3)
+				fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)
 				break
 			case *reflect.StructType:
 				p.stype = t2
@@ -329,11 +353,11 @@ func (p *Properties) setEncAndDec(typ reflect.Type) {
 				p.sizeof = startSize * unsafe.Sizeof(vslice)
 			}
 		case *reflect.SliceType:
-			switch t3 := t2.Elem().(type) {
+			switch t2.Elem().Kind() {
 			default:
-				fmt.Fprintf(os.Stderr, "proto: no oenc for %T -> %T -> %T\n", t1, t2, t3)
+				fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())
 				break
-			case *reflect.Uint8Type:
+			case reflect.Uint8:
 				p.enc = (*Buffer).enc_slice_slice_byte
 				p.dec = (*Buffer).dec_slice_slice_byte
 				p.alignof = unsafe.Alignof(vslice)

proto/testdata/test.pb.go

@@ -3,7 +3,10 @@
 
 package test_proto
 
-import "goprotobuf.googlecode.com/hg/proto"
+import proto "goprotobuf.googlecode.com/hg/proto"
+
+// Reference proto import to suppress error if it's not otherwise used.
+var _ = proto.GetString
 
 type FOO int32
 const (

proto/testdata/test.pb.go.golden

@@ -3,7 +3,10 @@
 
 package test_proto
 
-import "goprotobuf.googlecode.com/hg/proto"
+import proto "goprotobuf.googlecode.com/hg/proto"
+
+// Reference proto import to suppress error if it's not otherwise used.
+var _ = proto.GetString
 
 type FOO int32
 const (

proto/text.go

@@ -137,15 +137,15 @@ func writeStruct(w *textWriter, sv *reflect.StructValue) {
 }
 
 func tryWriteEnum(w *textWriter, enum string, v reflect.Value) bool {
-	val, ok := reflect.Indirect(v).(*reflect.Int32Value)
-	if !ok {
+	v = reflect.Indirect(v)
+	if v.Type().Kind() != reflect.Int32 {
 		return false
 	}
 	m, ok := enumNameMaps[enum]
 	if !ok {
 		return false
 	}
-	str, ok := m[val.Get()]
+	str, ok := m[int32(v.(*reflect.IntValue).Get())]
 	if !ok {
 		return false
 	}
@@ -161,10 +161,10 @@ func writeAny(w *textWriter, v reflect.Value) {
 	switch val := v.(type) {
 	case *reflect.SliceValue:
 		// Should only be a []byte; repeated fields are handled in writeStruct.
-		// TODO: Handle other cases cleaner.
+		// TODO: Handle other cases more cleanly.
 		bytes := make([]byte, val.Len())
 		for i := 0; i < val.Len(); i++ {
-			bytes[i] = val.Elem(i).(*reflect.Uint8Value).Get()
+			bytes[i] = byte(val.Elem(i).(*reflect.UintValue).Get())
 		}
 		// TODO: Should be strconv.QuoteC, which doesn't exist yet
 		fmt.Fprint(w, strconv.Quote(string(bytes)))

proto/text_parser.go

@@ -354,7 +354,7 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) *ParseError {
 	switch fv := v.(type) {
 	case *reflect.SliceValue:
 		at := v.Type().(*reflect.SliceType)
-		if _, ok := at.Elem().(*reflect.Uint8Type); ok {
+		if at.Elem().Kind() == reflect.Uint8 {
 			// Special case for []byte
 			if tok.value[0] != '"' {
 				// Deliberately written out here, as the error after
@@ -386,38 +386,36 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) *ParseError {
 			fv.Set(false)
 			return nil
 		}
-	case *reflect.Float32Value:
-		if f, err := strconv.Atof32(tok.value); err == nil {
+	case *reflect.FloatValue:
+		if f, err := strconv.AtofN(tok.value, fv.Type().Bits()); err == nil {
 			fv.Set(f)
 			return nil
 		}
-	case *reflect.Float64Value:
-		if f, err := strconv.Atof64(tok.value); err == nil {
-			fv.Set(f)
-			return nil
-		}
-	case *reflect.Int32Value:
-		if x, err := strconv.Atoi64(tok.value); err == nil && minInt32 <= x && x <= maxInt32 {
-			fv.Set(int32(x))
-			return nil
-		}
-		if len(props.Enum) == 0 {
-			break
-		}
-		m, ok := enumValueMaps[props.Enum]
-		if !ok {
-			break
-		}
-		x, ok := m[tok.value]
-		if !ok {
-			break
-		}
-		fv.Set(x)
-		return nil
-	case *reflect.Int64Value:
-		if x, err := strconv.Atoi64(tok.value); err == nil {
-			fv.Set(x)
+	case *reflect.IntValue:
+		switch fv.Type().Bits() {
+		case 32:
+			if x, err := strconv.Atoi64(tok.value); err == nil && minInt32 <= x && x <= maxInt32 {
+				fv.Set(x)
+				return nil
+			}
+			if len(props.Enum) == 0 {
+				break
+			}
+			m, ok := enumValueMaps[props.Enum]
+			if !ok {
+				break
+			}
+			x, ok := m[tok.value]
+			if !ok {
+				break
+			}
+			fv.Set(int64(x))
 			return nil
+		case 64:
+			if x, err := strconv.Atoi64(tok.value); err == nil {
+				fv.Set(x)
+				return nil
+			}
 		}
 	case *reflect.PtrValue:
 		// A basic field (indirected through pointer), or a repeated message/group
@@ -440,15 +438,18 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) *ParseError {
 			return p.error("expected '{' or '<', found %q", tok.value)
 		}
 		return p.readStruct(fv, terminator)
-	case *reflect.Uint32Value:
-		if x, err := strconv.Atoui64(tok.value); err == nil && x <= maxUint32 {
-			fv.Set(uint32(x))
-			return nil
-		}
-	case *reflect.Uint64Value:
-		if x, err := strconv.Atoui64(tok.value); err == nil {
-			fv.Set(x)
-			return nil
+	case *reflect.UintValue:
+		switch fv.Type().Bits() {
+		case 32:
+			if x, err := strconv.Atoui64(tok.value); err == nil && x <= maxUint32 {
+				fv.Set(uint64(x))
+				return nil
+			}
+		case 64:
+			if x, err := strconv.Atoui64(tok.value); err == nil {
+				fv.Set(x)
+				return nil
+			}
 		}
 	}
 	return p.error("invalid %v: %v", v.Type(), tok.value)