vdl/reflect_reader.go - release.go.v23 - Git at Google

 // Copyright 2016 The Vanadium 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 vdl

 import (
 	"errors"
 	"fmt"
 	"reflect"
 )

 var (
 	errReadMustReflect       = errors.New("vdl: read must be handled via reflection")
 	errReadIntoNilValue      = errors.New("vdl: read into nil value")
 	errReadReflectCantSet    = errors.New("vdl: read into unsettable reflect.Value")
 	errReadAnyAlreadyStarted = errors.New("vdl: read into any after StartValue called")
 	errReadAnyInterfaceOnly  = errors.New("vdl: read into any only supported for interfaces")
 )

 // Read uses dec to decode a value into v, calling VDLRead methods and fast
 // compiled readers when available, and using reflection otherwise.  This is
 // basically an all-purpose VDLRead implementation.
 func Read(dec Decoder, v interface{}) error {
 	if v == nil {
 		return errReadIntoNilValue
 	}
 	rv := reflect.ValueOf(v)
 	if rv.Kind() == reflect.Ptr && !rv.IsNil() {
 		// Fastpath check for non-reflect support.  Unfortunately we must use
 		// reflection to detect the case where v is a nil pointer, which returns an
 		// error in ReadReflect.
 		//
 		// TODO(toddw): If reflection is too slow, add the nil pointer check to all
 		// VDLRead methods, as well as other readNonReflect cases below.
 		if err := readNonReflect(dec, false, v); err != errReadMustReflect {
 			return err
 		}
 	}
 	return ReadReflect(dec, rv)
 }

 func readNonReflect(dec Decoder, calledStart bool, v interface{}) error {
 	switch x := v.(type) {
 	case Reader:
 		// Reader handles the case where x has a code-generated decoder, and
 		// special-cases such as vdl.Value and vom.RawBytes.
 		if calledStart {
 			dec.IgnoreNextStartValue()
 		}
 		return x.VDLRead(dec)
 	case **Type:
 		// Special-case type decoding, since we must assign the hash-consed pointer
 		// for correctness, rather than filling in a newly-created Type.
 		if !calledStart {
 			if err := dec.StartValue(TypeObjectType); err != nil {
 				return err
 			}
 		}
 		var err error
 		if *x, err = dec.DecodeTypeObject(); err != nil {
 			return err
 		}
 		return dec.FinishValue()

 		// Cases after this point are purely performance optimizations.
 		// TODO(toddw): Handle other common cases.
 	case *[]byte:
 		if !calledStart {
 			if err := dec.StartValue(ttByteList); err != nil {
 				return err
 			}
 		}
 		if err := dec.DecodeBytes(-1, x); err != nil {
 			return err
 		}
 		return dec.FinishValue()
 	}
 	return errReadMustReflect
 }

 var ttByteList = ListType(ByteType)

 // ReadReflect is like Read, but takes a reflect.Value argument.
 func ReadReflect(dec Decoder, rv reflect.Value) error {
 	if !rv.IsValid() {
 		return errReadIntoNilValue
 	}
 	if !rv.CanSet() && rv.Kind() == reflect.Ptr && !rv.IsNil() {
 		// Dereference the pointer a single time to make rv settable.
 		rv = rv.Elem()
 	}
 	if !rv.CanSet() {
 		return errReadReflectCantSet
 	}
 	tt, err := TypeFromReflect(rv.Type())
 	if err != nil {
 		return err
 	}
 	return readReflect(dec, false, rv, tt)
 }

 // readReflect uses dec to decode a value into rv, which has VDL type tt.  On
 // success we guarantee that StartValue / FinishValue has been called on dec.
 // If calledStart is true, StartValue has already been called.
 func readReflect(dec Decoder, calledStart bool, rv reflect.Value, tt *Type) error {
 	// Handle decoding into an any rv value first, since vom.RawBytes.VDLRead
 	// doesn't support IgnoreNextStartValue, and requires that StartValue hasn't
 	// been called yet.  Note that cases where the dec value is any but the rv
 	// value isn't any will pass through.
 	if tt == AnyType {
 		return readIntoAny(dec, calledStart, rv)
 	}
 	// Now start the decoder value, if we haven't already.
 	if !calledStart {
 		if err := dec.StartValue(tt); err != nil {
 			return err
 		}
 	}
 	// Handle nil decoded values next, to simplify the rest of the cases.  This
 	// handles cases where the dec value is either any(nil) or optional(nil).
 	if dec.IsNil() {
 		return readFromNil(dec, rv, tt)
 	}
 	// Now we know that the decoded value isn't nil.  Flatten pointers and check
 	// for fast non-reflect support.
 	rv = rvFlattenPointers(rv)
 	if err := readNonReflect(dec, true, rv.Addr().Interface()); err != errReadMustReflect {
 		return err
 	}
 	// Handle native types, which need the ToNative conversion.  Notice that rv is
 	// never a pointer here, so we don't support native pointer types.  In theory
 	// we could support native pointer types, but they're complicated and will
 	// probably slow everything down.
 	//
 	// TODO(toddw): Investigate support for native pointer types.
 	if ni := nativeInfoFromNative(rv.Type()); ni != nil {
 		rvWire := reflect.New(ni.WireType).Elem()
 		if err := readReflect(dec, true, rvWire, tt); err != nil {
 			return err
 		}
 		return ni.ToNative(rvWire, rv.Addr())
 		// NOTE: readReflect guarantees that FinishValue has already been called.
 	}
 	// Handle non-nil wire values.
 	if err := readNonNilValue(dec, rv, tt.NonOptional()); err != nil {
 		return err
 	}
 	return dec.FinishValue()
 }

 // readIntoAny uses dec to decode a value into rv, which has VDL type any.
 func readIntoAny(dec Decoder, calledStart bool, rv reflect.Value) error {
 	if calledStart {
 		// The existing code ensures that calledStart is always false here, since
 		// readReflect(dec, true, ...) is only called in situations where it's
 		// impossible to call readIntoAny.  E.g. it's called later in this function,
 		// which never calls it with another any type.  If we did, we'd have a vdl
 		// any(any), which isn't allowed.  This error tries to prevent future
 		// changes that will break this requirement.
 		//
 		// The requirement is mandated by vom.RawBytes.VDLRead, which doesn't handle
 		// IgnoreNextStartValue.
 		return errReadAnyAlreadyStarted
 	}
 	// Flatten pointers and check for fast non-reflect support, which handles
 	// vdl.Value and vom.RawBytes, and any other special-cases.
 	rv = rvFlattenPointers(rv)
 	if err := readNonReflect(dec, false, rv.Addr().Interface()); err != errReadMustReflect {
 		return err
 	}
 	// The only case left is to handle interfaces.  We allow decoding into
 	// all interfaces, including interface{}.
 	if rv.Kind() != reflect.Interface {
 		return errReadAnyInterfaceOnly
 	}
 	if err := dec.StartValue(AnyType); err != nil {
 		return err
 	}
 	// Handle decoding any(nil) by setting the rv interface to nil.  Note that the
 	// only case where dec.Type() is AnyType is when the value is any(nil).
 	if dec.Type() == AnyType {
 		if !rv.IsNil() {
 			rv.Set(reflect.Zero(rv.Type()))
 		}
 		return dec.FinishValue()
 	}
 	// Lookup the reflect type based on the decoder type, and create a new value
 	// to decode into.  If the dec value is optional, ensure that we lookup based
 	// on an optional type.  Note that if the dec value is nil, dec.Type() is
 	// already optional, so rtDecode will already be a pointer.
 	ttDecode := dec.Type()
 	if dec.IsOptional() && !dec.IsNil() {
 		ttDecode = OptionalType(ttDecode)
 	}
 	rtDecode := typeToReflectNew(ttDecode)
 	// Handle top-level "v.io/v23/vdl.WireError" types.  TypeToReflect will find
 	// vdl.WireError based on regular wire type registration, and will find the Go
 	// error interface based on regular native type registration, and these are
 	// fine for nested error types.
 	//
 	// But this is the case where we're decoding into a top-level Go interface,
 	// and we'll lose type information if the dec value is nil.  So instead we
 	// return the registered verror.E type.  Examples:
 	//
 	//   ttDecode  ->  rtDecode
 	//   -----------------------
 	//   WireError     verror.E
 	//   ?WireError    *verror.E
 	//   []WireError   []vdl.WireError (1)
 	//   []?WireError  []error
 	//
 	// TODO(toddw): The (1) case above is weird; we would like to return verror.E,
 	// but that's hard because the native conversion we've registered doesn't
 	// currently include the verror.E type:
 	//
 	//    ToNative(wire *vdl.WireError, native *error)
 	//    FromNative(wire **vdl.WireError, native error)
 	//
 	// We could make this more consistent by registering a pair of conversion
 	// functions instead:
 	//
 	//    ToNative(wire vdl.WireError, native *verror.E)
 	//    FromNative(wire *vdl.WireError, native verror.E)
 	//
 	//    ToNative(wire *verror.E, native *error)
 	//    FromNative(wire **verror.E, native error)
 	if ttDecode.NonOptional().Name() == ErrorType.Elem().Name() {
 		if ni, err := nativeInfoForError(); err == nil {
 			if ttDecode.Kind() == Optional {
 				rtDecode = reflect.PtrTo(ni.NativeType)
 			} else {
 				rtDecode = ni.NativeType
 			}
 		}
 	}
 	if rtDecode == nil {
 		return fmt.Errorf("vdl: %v not registered, either call vdl.Register, or use vdl.Value or vom.RawBytes instead", dec.Type())
 	}
 	if !rtDecode.Implements(rv.Type()) {
 		return fmt.Errorf("vdl: %v doesn't implement %v", rtDecode, rv.Type())
 	}
 	// Handle both nil and non-nil values by decoding into rvDecode, and setting
 	// rv.  Both nil and non-nil values are handled in the readReflect call.
 	rvDecode := reflect.New(rtDecode).Elem()
 	if err := readReflect(dec, true, rvDecode, ttDecode); err != nil {
 		return err
 	}
 	rv.Set(rvDecode)
 	// NOTE: readReflect guarantees that FinishValue has already been called.
 	return nil
 }

 // readFromNil uses dec to decode a nil value into rv, which has VDL type tt.
 // The value in dec might be either any(nil) or optional(nil).
 //
 // REQUIRES: dec.IsNil() && tt != AnyType
 func readFromNil(dec Decoder, rv reflect.Value, tt *Type) error {
 	if tt.Kind() != Optional {
 		return fmt.Errorf("vdl: can't decode nil into non-optional %v", tt)
 	}
 	// Flatten pointers until we have a single pointer left, or there were no
 	// pointers to begin with.
 	rt := rv.Type()
 	for rt.Kind() == reflect.Ptr && rt.Elem().Kind() == reflect.Ptr {
 		if rv.IsNil() {
 			rv.Set(reflect.New(rt.Elem()))
 		}
 		rv, rt = rv.Elem(), rt.Elem()
 	}
 	// Handle tricky cases where rv is a native type.
 	if handled, err := readFromNilNative(dec, rv, tt); handled {
 		return err
 	}
 	// Now handle the simple case: rv has one pointer left, and should be set to a
 	// nil pointer.
 	if rt.Kind() != reflect.Ptr {
 		return fmt.Errorf("vdl: can't decode nil into non-pointer %v optional %v", rt, tt)
 	}
 	if !rv.IsNil() {
 		rv.Set(reflect.Zero(rt))
 	}
 	return dec.FinishValue()
 }

 // readFromNilNative handles tricky cases where rv is a native type.  Returns
 // true if rv is a native type and was handled, otherwise returns false.
 //
 // REQUIRES: rv.Type() has at most one pointer.
 func readFromNilNative(dec Decoder, rv reflect.Value, tt *Type) (bool, error) {
 	var ni *nativeInfo
 	if rt := rv.Type(); rt.Kind() != reflect.Ptr {
 		// Handle the case where rv isn't a pointer; e.g. the Go error interface is
 		// a non-pointer native type, and is handled here.
 		ni = nativeInfoFromNative(rt)
 	} else {
 		// Handle the case where rv is a pointer, and the elem is a native type.
 		// E.g. *error is handled here.  Note that we don't support native pointer
 		// types; see comments at other calls to nativeInfoFromNative.
 		ni = nativeInfoFromNative(rt.Elem())
 		if ni != nil {
 			if rv.IsNil() {
 				rv.Set(reflect.New(rt.Elem()))
 			}
 			rv = rv.Elem()
 		}
 	}
 	if ni != nil {
 		// Handle the native type from either case above.  At this point, rv is the
 		// native type and isn't a nil pointer.
 		rvWire := reflect.New(ni.WireType).Elem()
 		if err := readReflect(dec, true, rvWire, tt); err != nil {
 			return true, err
 		}
 		return true, ni.ToNative(rvWire, rv.Addr())
 		// NOTE: readReflect guarantees that FinishValue has already been called.
 	}
 	return false, nil
 }

 // settable exists to avoid a call to reflect.Call() to invoke Set()
 // which results in an allocation
 type settable interface {
 	Set(string) error
 }

 func readNonNilValue(dec Decoder, rv reflect.Value, tt *Type) error {
 	// Handle named and unnamed []byte and [N]byte, where the element type is the
 	// unnamed byte type.  Cases like []MyByte fall through and are handled as
 	// regular lists, since we can't easily convert []MyByte to []byte.
 	switch {
 	case tt.Kind() == Array && tt.Elem() == ByteType:
 		bytes := rv.Slice(0, tt.Len()).Interface().([]byte)
 		return dec.DecodeBytes(tt.Len(), &bytes)
 	case tt.Kind() == List && tt.Elem() == ByteType:
 		var bytes []byte
 		if err := dec.DecodeBytes(-1, &bytes); err != nil {
 			return err
 		}
 		rv.Set(reflect.ValueOf(bytes))
 		return nil
 	}
 	// Handle regular non-nil values.
 	switch kind := tt.Kind(); kind {
 	case Bool:
 		val, err := dec.DecodeBool()
 		if err != nil {
 			return err
 		}
 		rv.SetBool(val)
 		return nil
 	case String:
 		val, err := dec.DecodeString()
 		if err != nil {
 			return err
 		}
 		rv.SetString(val)
 		return nil
 	case Enum:
 		val, err := dec.DecodeString()
 		if err != nil {
 			return err
 		}
 		return rv.Addr().Interface().(settable).Set(val)
 	case Byte, Uint16, Uint32, Uint64:
 		val, err := dec.DecodeUint(kind.BitLen())
 		if err != nil {
 			return err
 		}
 		rv.SetUint(val)
 		return nil
 	case Int8, Int16, Int32, Int64:
 		val, err := dec.DecodeInt(kind.BitLen())
 		if err != nil {
 			return err
 		}
 		rv.SetInt(val)
 		return nil
 	case Float32, Float64:
 		val, err := dec.DecodeFloat(kind.BitLen())
 		if err != nil {
 			return err
 		}
 		rv.SetFloat(val)
 		return nil
 	case Array:
 		return readArray(dec, rv, tt)
 	case List:
 		return readList(dec, rv, tt)
 	case Set:
 		return readSet(dec, rv, tt)
 	case Map:
 		return readMap(dec, rv, tt)
 	case Struct:
 		return readStruct(dec, rv, tt)
 	case Union:
 		return readUnion(dec, rv, tt)
 	}
 	// Note that Any was already handled via readAny, Optional was handled via
 	// readFromNil (or stripped off for non-nil values), and TypeObject was
 	// handled via the readNonReflect special-case.
 	return fmt.Errorf("vdl: Read unhandled type %v %v", rv.Type(), tt)
 }

 func readArray(dec Decoder, rv reflect.Value, tt *Type) error {
 	rt := rv.Type()
 	index := 0
 	for {
 		switch done, err := dec.NextEntry(); {
 		case err != nil:
 			return err
 		case done != (index >= rv.Len()):
 			return fmt.Errorf("array len mismatch, done:%v index:%d len:%d %v", done, index, rt.Len(), rt)
 		case done:
 			return nil
 		}
 		if err := readReflect(dec, false, rv.Index(index), tt.Elem()); err != nil {
 			return err
 		}
 		index++
 	}
 }

 func readList(dec Decoder, rv reflect.Value, tt *Type) error {
 	rt := rv.Type()
 	switch len := dec.LenHint(); {
 	case len > 0:
 		rv.Set(reflect.MakeSlice(rt, 0, len))
 	default:
 		rv.Set(reflect.Zero(rt))
 	}
 	for {
 		switch done, err := dec.NextEntry(); {
 		case err != nil:
 			return err
 		case done:
 			return nil
 		}
 		elem := reflect.New(rt.Elem()).Elem()
 		if err := readReflect(dec, false, elem, tt.Elem()); err != nil {
 			return err
 		}
 		rv.Set(reflect.Append(rv, elem))
 	}
 }

 var rvEmptyStruct = reflect.ValueOf(struct{}{})

 func readSet(dec Decoder, rv reflect.Value, tt *Type) error {
 	rt := rv.Type()
 	tmpSet, isNil := reflect.Zero(rt), true
 	for {
 		switch done, err := dec.NextEntry(); {
 		case err != nil:
 			return err
 		case done:
 			rv.Set(tmpSet)
 			return nil
 		}
 		key := reflect.New(rt.Key()).Elem()
 		if err := readReflect(dec, false, key, tt.Key()); err != nil {
 			return err
 		}
 		if isNil {
 			tmpSet, isNil = reflect.MakeMap(rt), false
 		}
 		tmpSet.SetMapIndex(key, rvEmptyStruct)
 	}
 }

 func readMap(dec Decoder, rv reflect.Value, tt *Type) error {
 	rt := rv.Type()
 	tmpMap, isNil := reflect.Zero(rt), true
 	for {
 		switch done, err := dec.NextEntry(); {
 		case err != nil:
 			return err
 		case done:
 			rv.Set(tmpMap)
 			return nil
 		}
 		key := reflect.New(rt.Key()).Elem()
 		if err := readReflect(dec, false, key, tt.Key()); err != nil {
 			return err
 		}
 		elem := reflect.New(rt.Elem()).Elem()
 		if err := readReflect(dec, false, elem, tt.Elem()); err != nil {
 			return err
 		}
 		if isNil {
 			tmpMap, isNil = reflect.MakeMap(rt), false
 		}
 		tmpMap.SetMapIndex(key, elem)
 	}
 }

 func readStruct(dec Decoder, rv reflect.Value, tt *Type) error {
 	rt := rv.Type()
 	// Reset to the zero struct, since fields may be missing.
 	//
 	// TODO(toddw): Avoid repeated zero-setting of nested structs.
 	rvZero, err := rvZeroValue(rt, tt)
 	if err != nil {
 		return err
 	}
 	rv.Set(rvZero)
 	for {
 		name, err := dec.NextField()
 		switch {
 		case err != nil:
 			return err
 		case name == "":
 			return nil
 		}
 		switch ttField, index := tt.FieldByName(name); {
 		case index != -1:
 			rvField := rv.FieldByName(name)
 			if err := readReflect(dec, false, rvField, ttField.Type); err != nil {
 				return err
 			}
 		default:
 			if err := dec.SkipValue(); err != nil {
 				return err
 			}
 		}
 	}
 }

 func readUnion(dec Decoder, rv reflect.Value, tt *Type) error {
 	rt := rv.Type()
 	name, err := dec.NextField()
 	switch {
 	case err != nil:
 		return err
 	case name == "":
 		return fmt.Errorf("missing field in union %v, from %v", rt, dec.Type())
 	}
 	ttField, index := tt.FieldByName(name)
 	if index == -1 {
 		return fmt.Errorf("field %q not in union %v, from %v", name, rt, dec.Type())
 	}
 	// We have a union interface.  Create a new field based on its rep type, fill
 	// in its value, and assign the field to the interface.
 	ri, _, err := deriveReflectInfo(rt)
 	if err != nil {
 		return err
 	}
 	rvField := reflect.New(ri.UnionFields[index].RepType).Elem()
 	if err := readReflect(dec, false, rvField.Field(0), ttField.Type); err != nil {
 		return err
 	}
 	rv.Set(rvField)
 	switch name, err := dec.NextField(); {
 	case err != nil:
 		return err
 	case name != "":
 		return fmt.Errorf("extra field %q in union %v, from %v", name, rt, dec.Type())
 	}
 	return nil
 }
	// Copyright 2016 The Vanadium 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 vdl

	import (
	"errors"
	"fmt"
	"reflect"
	)

	var (
	errReadMustReflect = errors.New("vdl: read must be handled via reflection")
	errReadIntoNilValue = errors.New("vdl: read into nil value")
	errReadReflectCantSet = errors.New("vdl: read into unsettable reflect.Value")
	errReadAnyAlreadyStarted = errors.New("vdl: read into any after StartValue called")
	errReadAnyInterfaceOnly = errors.New("vdl: read into any only supported for interfaces")
	)

	// Read uses dec to decode a value into v, calling VDLRead methods and fast
	// compiled readers when available, and using reflection otherwise. This is
	// basically an all-purpose VDLRead implementation.
	func Read(dec Decoder, v interface{}) error {
	if v == nil {
	return errReadIntoNilValue
	}
	rv := reflect.ValueOf(v)
	if rv.Kind() == reflect.Ptr && !rv.IsNil() {
	// Fastpath check for non-reflect support. Unfortunately we must use
	// reflection to detect the case where v is a nil pointer, which returns an
	// error in ReadReflect.
	//
	// TODO(toddw): If reflection is too slow, add the nil pointer check to all
	// VDLRead methods, as well as other readNonReflect cases below.
	if err := readNonReflect(dec, false, v); err != errReadMustReflect {
	return err
	}
	}
	return ReadReflect(dec, rv)
	}

	func readNonReflect(dec Decoder, calledStart bool, v interface{}) error {
	switch x := v.(type) {
	case Reader:
	// Reader handles the case where x has a code-generated decoder, and
	// special-cases such as vdl.Value and vom.RawBytes.
	if calledStart {
	dec.IgnoreNextStartValue()
	}
	return x.VDLRead(dec)
	case **Type:
	// Special-case type decoding, since we must assign the hash-consed pointer
	// for correctness, rather than filling in a newly-created Type.
	if !calledStart {
	if err := dec.StartValue(TypeObjectType); err != nil {
	return err
	}
	}
	var err error
	if *x, err = dec.DecodeTypeObject(); err != nil {
	return err
	}
	return dec.FinishValue()

	// Cases after this point are purely performance optimizations.
	// TODO(toddw): Handle other common cases.
	case *[]byte:
	if !calledStart {
	if err := dec.StartValue(ttByteList); err != nil {
	return err
	}
	}
	if err := dec.DecodeBytes(-1, x); err != nil {
	return err
	}
	return dec.FinishValue()
	}
	return errReadMustReflect
	}

	var ttByteList = ListType(ByteType)

	// ReadReflect is like Read, but takes a reflect.Value argument.
	func ReadReflect(dec Decoder, rv reflect.Value) error {
	if !rv.IsValid() {
	return errReadIntoNilValue
	}
	if !rv.CanSet() && rv.Kind() == reflect.Ptr && !rv.IsNil() {
	// Dereference the pointer a single time to make rv settable.
	rv = rv.Elem()
	}
	if !rv.CanSet() {
	return errReadReflectCantSet
	}
	tt, err := TypeFromReflect(rv.Type())
	if err != nil {
	return err
	}
	return readReflect(dec, false, rv, tt)
	}

	// readReflect uses dec to decode a value into rv, which has VDL type tt. On
	// success we guarantee that StartValue / FinishValue has been called on dec.
	// If calledStart is true, StartValue has already been called.
	func readReflect(dec Decoder, calledStart bool, rv reflect.Value, tt *Type) error {
	// Handle decoding into an any rv value first, since vom.RawBytes.VDLRead
	// doesn't support IgnoreNextStartValue, and requires that StartValue hasn't
	// been called yet. Note that cases where the dec value is any but the rv
	// value isn't any will pass through.
	if tt == AnyType {
	return readIntoAny(dec, calledStart, rv)
	}
	// Now start the decoder value, if we haven't already.
	if !calledStart {
	if err := dec.StartValue(tt); err != nil {
	return err
	}
	}
	// Handle nil decoded values next, to simplify the rest of the cases. This
	// handles cases where the dec value is either any(nil) or optional(nil).
	if dec.IsNil() {
	return readFromNil(dec, rv, tt)
	}
	// Now we know that the decoded value isn't nil. Flatten pointers and check
	// for fast non-reflect support.
	rv = rvFlattenPointers(rv)
	if err := readNonReflect(dec, true, rv.Addr().Interface()); err != errReadMustReflect {
	return err
	}
	// Handle native types, which need the ToNative conversion. Notice that rv is
	// never a pointer here, so we don't support native pointer types. In theory
	// we could support native pointer types, but they're complicated and will
	// probably slow everything down.
	//
	// TODO(toddw): Investigate support for native pointer types.
	if ni := nativeInfoFromNative(rv.Type()); ni != nil {
	rvWire := reflect.New(ni.WireType).Elem()
	if err := readReflect(dec, true, rvWire, tt); err != nil {
	return err
	}
	return ni.ToNative(rvWire, rv.Addr())
	// NOTE: readReflect guarantees that FinishValue has already been called.
	}
	// Handle non-nil wire values.
	if err := readNonNilValue(dec, rv, tt.NonOptional()); err != nil {
	return err
	}
	return dec.FinishValue()
	}

	// readIntoAny uses dec to decode a value into rv, which has VDL type any.
	func readIntoAny(dec Decoder, calledStart bool, rv reflect.Value) error {
	if calledStart {
	// The existing code ensures that calledStart is always false here, since
	// readReflect(dec, true, ...) is only called in situations where it's
	// impossible to call readIntoAny. E.g. it's called later in this function,
	// which never calls it with another any type. If we did, we'd have a vdl
	// any(any), which isn't allowed. This error tries to prevent future
	// changes that will break this requirement.
	//
	// The requirement is mandated by vom.RawBytes.VDLRead, which doesn't handle
	// IgnoreNextStartValue.
	return errReadAnyAlreadyStarted
	}
	// Flatten pointers and check for fast non-reflect support, which handles
	// vdl.Value and vom.RawBytes, and any other special-cases.
	rv = rvFlattenPointers(rv)
	if err := readNonReflect(dec, false, rv.Addr().Interface()); err != errReadMustReflect {
	return err
	}
	// The only case left is to handle interfaces. We allow decoding into
	// all interfaces, including interface{}.
	if rv.Kind() != reflect.Interface {
	return errReadAnyInterfaceOnly
	}
	if err := dec.StartValue(AnyType); err != nil {
	return err
	}
	// Handle decoding any(nil) by setting the rv interface to nil. Note that the
	// only case where dec.Type() is AnyType is when the value is any(nil).
	if dec.Type() == AnyType {
	if !rv.IsNil() {
	rv.Set(reflect.Zero(rv.Type()))
	}
	return dec.FinishValue()
	}
	// Lookup the reflect type based on the decoder type, and create a new value
	// to decode into. If the dec value is optional, ensure that we lookup based
	// on an optional type. Note that if the dec value is nil, dec.Type() is
	// already optional, so rtDecode will already be a pointer.
	ttDecode := dec.Type()
	if dec.IsOptional() && !dec.IsNil() {
	ttDecode = OptionalType(ttDecode)
	}
	rtDecode := typeToReflectNew(ttDecode)
	// Handle top-level "v.io/v23/vdl.WireError" types. TypeToReflect will find
	// vdl.WireError based on regular wire type registration, and will find the Go
	// error interface based on regular native type registration, and these are
	// fine for nested error types.
	//
	// But this is the case where we're decoding into a top-level Go interface,
	// and we'll lose type information if the dec value is nil. So instead we
	// return the registered verror.E type. Examples:
	//
	// ttDecode -> rtDecode
	// -----------------------
	// WireError verror.E
	// ?WireError *verror.E
	// []WireError []vdl.WireError (1)
	// []?WireError []error
	//
	// TODO(toddw): The (1) case above is weird; we would like to return verror.E,
	// but that's hard because the native conversion we've registered doesn't
	// currently include the verror.E type:
	//
	// ToNative(wire vdl.WireError, native error)
	// FromNative(wire **vdl.WireError, native error)
	//
	// We could make this more consistent by registering a pair of conversion
	// functions instead:
	//
	// ToNative(wire vdl.WireError, native *verror.E)
	// FromNative(wire *vdl.WireError, native verror.E)
	//
	// ToNative(wire verror.E, native error)
	// FromNative(wire **verror.E, native error)
	if ttDecode.NonOptional().Name() == ErrorType.Elem().Name() {
	if ni, err := nativeInfoForError(); err == nil {
	if ttDecode.Kind() == Optional {
	rtDecode = reflect.PtrTo(ni.NativeType)
	} else {
	rtDecode = ni.NativeType
	}
	}
	}
	if rtDecode == nil {
	return fmt.Errorf("vdl: %v not registered, either call vdl.Register, or use vdl.Value or vom.RawBytes instead", dec.Type())
	}
	if !rtDecode.Implements(rv.Type()) {
	return fmt.Errorf("vdl: %v doesn't implement %v", rtDecode, rv.Type())
	}
	// Handle both nil and non-nil values by decoding into rvDecode, and setting
	// rv. Both nil and non-nil values are handled in the readReflect call.
	rvDecode := reflect.New(rtDecode).Elem()
	if err := readReflect(dec, true, rvDecode, ttDecode); err != nil {
	return err
	}
	rv.Set(rvDecode)
	// NOTE: readReflect guarantees that FinishValue has already been called.
	return nil
	}

	// readFromNil uses dec to decode a nil value into rv, which has VDL type tt.
	// The value in dec might be either any(nil) or optional(nil).
	//
	// REQUIRES: dec.IsNil() && tt != AnyType
	func readFromNil(dec Decoder, rv reflect.Value, tt *Type) error {
	if tt.Kind() != Optional {
	return fmt.Errorf("vdl: can't decode nil into non-optional %v", tt)
	}
	// Flatten pointers until we have a single pointer left, or there were no
	// pointers to begin with.
	rt := rv.Type()
	for rt.Kind() == reflect.Ptr && rt.Elem().Kind() == reflect.Ptr {
	if rv.IsNil() {
	rv.Set(reflect.New(rt.Elem()))
	}
	rv, rt = rv.Elem(), rt.Elem()
	}
	// Handle tricky cases where rv is a native type.
	if handled, err := readFromNilNative(dec, rv, tt); handled {
	return err
	}
	// Now handle the simple case: rv has one pointer left, and should be set to a
	// nil pointer.
	if rt.Kind() != reflect.Ptr {
	return fmt.Errorf("vdl: can't decode nil into non-pointer %v optional %v", rt, tt)
	}
	if !rv.IsNil() {
	rv.Set(reflect.Zero(rt))
	}
	return dec.FinishValue()
	}

	// readFromNilNative handles tricky cases where rv is a native type. Returns
	// true if rv is a native type and was handled, otherwise returns false.
	//
	// REQUIRES: rv.Type() has at most one pointer.
	func readFromNilNative(dec Decoder, rv reflect.Value, tt *Type) (bool, error) {
	var ni *nativeInfo
	if rt := rv.Type(); rt.Kind() != reflect.Ptr {
	// Handle the case where rv isn't a pointer; e.g. the Go error interface is
	// a non-pointer native type, and is handled here.
	ni = nativeInfoFromNative(rt)
	} else {
	// Handle the case where rv is a pointer, and the elem is a native type.
	// E.g. *error is handled here. Note that we don't support native pointer
	// types; see comments at other calls to nativeInfoFromNative.
	ni = nativeInfoFromNative(rt.Elem())
	if ni != nil {
	if rv.IsNil() {
	rv.Set(reflect.New(rt.Elem()))
	}
	rv = rv.Elem()
	}
	}
	if ni != nil {
	// Handle the native type from either case above. At this point, rv is the
	// native type and isn't a nil pointer.
	rvWire := reflect.New(ni.WireType).Elem()
	if err := readReflect(dec, true, rvWire, tt); err != nil {
	return true, err
	}
	return true, ni.ToNative(rvWire, rv.Addr())
	// NOTE: readReflect guarantees that FinishValue has already been called.
	}
	return false, nil
	}

	// settable exists to avoid a call to reflect.Call() to invoke Set()
	// which results in an allocation
	type settable interface {
	Set(string) error
	}

	func readNonNilValue(dec Decoder, rv reflect.Value, tt *Type) error {
	// Handle named and unnamed []byte and [N]byte, where the element type is the
	// unnamed byte type. Cases like []MyByte fall through and are handled as
	// regular lists, since we can't easily convert []MyByte to []byte.
	switch {
	case tt.Kind() == Array && tt.Elem() == ByteType:
	bytes := rv.Slice(0, tt.Len()).Interface().([]byte)
	return dec.DecodeBytes(tt.Len(), &bytes)
	case tt.Kind() == List && tt.Elem() == ByteType:
	var bytes []byte
	if err := dec.DecodeBytes(-1, &bytes); err != nil {
	return err
	}
	rv.Set(reflect.ValueOf(bytes))
	return nil
	}
	// Handle regular non-nil values.
	switch kind := tt.Kind(); kind {
	case Bool:
	val, err := dec.DecodeBool()
	if err != nil {
	return err
	}
	rv.SetBool(val)
	return nil
	case String:
	val, err := dec.DecodeString()
	if err != nil {
	return err
	}
	rv.SetString(val)
	return nil
	case Enum:
	val, err := dec.DecodeString()
	if err != nil {
	return err
	}
	return rv.Addr().Interface().(settable).Set(val)
	case Byte, Uint16, Uint32, Uint64:
	val, err := dec.DecodeUint(kind.BitLen())
	if err != nil {
	return err
	}
	rv.SetUint(val)
	return nil
	case Int8, Int16, Int32, Int64:
	val, err := dec.DecodeInt(kind.BitLen())
	if err != nil {
	return err
	}
	rv.SetInt(val)
	return nil
	case Float32, Float64:
	val, err := dec.DecodeFloat(kind.BitLen())
	if err != nil {
	return err
	}
	rv.SetFloat(val)
	return nil
	case Array:
	return readArray(dec, rv, tt)
	case List:
	return readList(dec, rv, tt)
	case Set:
	return readSet(dec, rv, tt)
	case Map:
	return readMap(dec, rv, tt)
	case Struct:
	return readStruct(dec, rv, tt)
	case Union:
	return readUnion(dec, rv, tt)
	}
	// Note that Any was already handled via readAny, Optional was handled via
	// readFromNil (or stripped off for non-nil values), and TypeObject was
	// handled via the readNonReflect special-case.
	return fmt.Errorf("vdl: Read unhandled type %v %v", rv.Type(), tt)
	}

	func readArray(dec Decoder, rv reflect.Value, tt *Type) error {
	rt := rv.Type()
	index := 0
	for {
	switch done, err := dec.NextEntry(); {
	case err != nil:
	return err
	case done != (index >= rv.Len()):
	return fmt.Errorf("array len mismatch, done:%v index:%d len:%d %v", done, index, rt.Len(), rt)
	case done:
	return nil
	}
	if err := readReflect(dec, false, rv.Index(index), tt.Elem()); err != nil {
	return err
	}
	index++
	}
	}

	func readList(dec Decoder, rv reflect.Value, tt *Type) error {
	rt := rv.Type()
	switch len := dec.LenHint(); {
	case len > 0:
	rv.Set(reflect.MakeSlice(rt, 0, len))
	default:
	rv.Set(reflect.Zero(rt))
	}
	for {
	switch done, err := dec.NextEntry(); {
	case err != nil:
	return err
	case done:
	return nil
	}
	elem := reflect.New(rt.Elem()).Elem()
	if err := readReflect(dec, false, elem, tt.Elem()); err != nil {
	return err
	}
	rv.Set(reflect.Append(rv, elem))
	}
	}

	var rvEmptyStruct = reflect.ValueOf(struct{}{})

	func readSet(dec Decoder, rv reflect.Value, tt *Type) error {
	rt := rv.Type()
	tmpSet, isNil := reflect.Zero(rt), true
	for {
	switch done, err := dec.NextEntry(); {
	case err != nil:
	return err
	case done:
	rv.Set(tmpSet)
	return nil
	}
	key := reflect.New(rt.Key()).Elem()
	if err := readReflect(dec, false, key, tt.Key()); err != nil {
	return err
	}
	if isNil {
	tmpSet, isNil = reflect.MakeMap(rt), false
	}
	tmpSet.SetMapIndex(key, rvEmptyStruct)
	}
	}

	func readMap(dec Decoder, rv reflect.Value, tt *Type) error {
	rt := rv.Type()
	tmpMap, isNil := reflect.Zero(rt), true
	for {
	switch done, err := dec.NextEntry(); {
	case err != nil:
	return err
	case done:
	rv.Set(tmpMap)
	return nil
	}
	key := reflect.New(rt.Key()).Elem()
	if err := readReflect(dec, false, key, tt.Key()); err != nil {
	return err
	}
	elem := reflect.New(rt.Elem()).Elem()
	if err := readReflect(dec, false, elem, tt.Elem()); err != nil {
	return err
	}
	if isNil {
	tmpMap, isNil = reflect.MakeMap(rt), false
	}
	tmpMap.SetMapIndex(key, elem)
	}
	}

	func readStruct(dec Decoder, rv reflect.Value, tt *Type) error {
	rt := rv.Type()
	// Reset to the zero struct, since fields may be missing.
	//
	// TODO(toddw): Avoid repeated zero-setting of nested structs.
	rvZero, err := rvZeroValue(rt, tt)
	if err != nil {
	return err
	}
	rv.Set(rvZero)
	for {
	name, err := dec.NextField()
	switch {
	case err != nil:
	return err
	case name == "":
	return nil
	}
	switch ttField, index := tt.FieldByName(name); {
	case index != -1:
	rvField := rv.FieldByName(name)
	if err := readReflect(dec, false, rvField, ttField.Type); err != nil {
	return err
	}
	default:
	if err := dec.SkipValue(); err != nil {
	return err
	}
	}
	}
	}

	func readUnion(dec Decoder, rv reflect.Value, tt *Type) error {
	rt := rv.Type()
	name, err := dec.NextField()
	switch {
	case err != nil:
	return err
	case name == "":
	return fmt.Errorf("missing field in union %v, from %v", rt, dec.Type())
	}
	ttField, index := tt.FieldByName(name)
	if index == -1 {
	return fmt.Errorf("field %q not in union %v, from %v", name, rt, dec.Type())
	}
	// We have a union interface. Create a new field based on its rep type, fill
	// in its value, and assign the field to the interface.
	ri, _, err := deriveReflectInfo(rt)
	if err != nil {
	return err
	}
	rvField := reflect.New(ri.UnionFields[index].RepType).Elem()
	if err := readReflect(dec, false, rvField.Field(0), ttField.Type); err != nil {
	return err
	}
	rv.Set(rvField)
	switch name, err := dec.NextField(); {
	case err != nil:
	return err
	case name != "":
	return fmt.Errorf("extra field %q in union %v, from %v", name, rt, dec.Type())
	}
	return nil
	}