// Copyright 2015 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.

// This file was auto-generated by the vanadium vdl tool.
// Package: testtypes

package testtypes

import (
	"fmt"
	"v.io/v23/vdl"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

type AnEnum int

const (
	AnEnumFirst AnEnum = iota
	AnEnumSecond
)

// AnEnumAll holds all labels for AnEnum.
var AnEnumAll = [...]AnEnum{AnEnumFirst, AnEnumSecond}

// AnEnumFromString creates a AnEnum from a string label.
func AnEnumFromString(label string) (x AnEnum, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *AnEnum) Set(label string) error {
	switch label {
	case "First", "first":
		*x = AnEnumFirst
		return nil
	case "Second", "second":
		*x = AnEnumSecond
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in testtypes.AnEnum", label)
}

// String returns the string label of x.
func (x AnEnum) String() string {
	switch x {
	case AnEnumFirst:
		return "First"
	case AnEnumSecond:
		return "Second"
	}
	return ""
}

func (AnEnum) __VDLReflect(struct {
	Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.AnEnum"`
	Enum struct{ First, Second string }
}) {
}

func (m *AnEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *AnEnum) MakeVDLTarget() vdl.Target {
	return &AnEnumTarget{Value: m}
}

type AnEnumTarget struct {
	Value *AnEnum
	vdl.TargetBase
}

func (t *AnEnumTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*AnEnum)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "First":
		*t.Value = 0
	case "Second":
		*t.Value = 1
	default:
		return fmt.Errorf("label %s not in enum AnEnum", src)
	}

	return nil
}

func (x AnEnum) VDLIsZero() bool {
	return x == AnEnumFirst
}

func (x AnEnum) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*AnEnum)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeString(x.String()); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *AnEnum) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	enum, err := dec.DecodeString()
	if err != nil {
		return err
	}
	if err := x.Set(enum); err != nil {
		return err
	}
	return dec.FinishValue()
}

type (
	// PodUnion represents any single field of the PodUnion union type.
	PodUnion interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the PodUnion union type.
		__VDLReflect(__PodUnionReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
		VDLIsZero() bool
		VDLWrite(vdl.Encoder) error
	}
	// PodUnionFInt8 represents field FInt8 of the PodUnion union type.
	PodUnionFInt8 struct{ Value int8 }
	// PodUnionFInt8Other represents field FInt8Other of the PodUnion union type.
	PodUnionFInt8Other struct{ Value int8 }
	// PodUnionFUint8 represents field FUint8 of the PodUnion union type.
	PodUnionFUint8 struct{ Value byte }
	// PodUnionFInt16 represents field FInt16 of the PodUnion union type.
	PodUnionFInt16 struct{ Value int16 }
	// PodUnionFUint16 represents field FUint16 of the PodUnion union type.
	PodUnionFUint16 struct{ Value uint16 }
	// PodUnionFint32 represents field Fint32 of the PodUnion union type.
	PodUnionFint32 struct{ Value int32 }
	// PodUnionFuint32 represents field Fuint32 of the PodUnion union type.
	PodUnionFuint32 struct{ Value uint32 }
	// PodUnionFInt64 represents field FInt64 of the PodUnion union type.
	PodUnionFInt64 struct{ Value int64 }
	// PodUnionFUint64 represents field FUint64 of the PodUnion union type.
	PodUnionFUint64 struct{ Value uint64 }
	// PodUnionFFloat represents field FFloat of the PodUnion union type.
	PodUnionFFloat struct{ Value float32 }
	// PodUnionFDouble represents field FDouble of the PodUnion union type.
	PodUnionFDouble struct{ Value float64 }
	// PodUnionFBool represents field FBool of the PodUnion union type.
	PodUnionFBool struct{ Value bool }
	// PodUnionFEnum represents field FEnum of the PodUnion union type.
	PodUnionFEnum struct{ Value AnEnum }
	// __PodUnionReflect describes the PodUnion union type.
	__PodUnionReflect struct {
		Name               string `vdl:"src/v.io/x/mojo/transcoder/testtypes.PodUnion"`
		Type               PodUnion
		UnionTargetFactory podUnionTargetFactory
		Union              struct {
			FInt8      PodUnionFInt8
			FInt8Other PodUnionFInt8Other
			FUint8     PodUnionFUint8
			FInt16     PodUnionFInt16
			FUint16    PodUnionFUint16
			Fint32     PodUnionFint32
			Fuint32    PodUnionFuint32
			FInt64     PodUnionFInt64
			FUint64    PodUnionFUint64
			FFloat     PodUnionFFloat
			FDouble    PodUnionFDouble
			FBool      PodUnionFBool
			FEnum      PodUnionFEnum
		}
	}
)

func (x PodUnionFInt8) Index() int                     { return 0 }
func (x PodUnionFInt8) Interface() interface{}         { return x.Value }
func (x PodUnionFInt8) Name() string                   { return "FInt8" }
func (x PodUnionFInt8) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFInt8) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFInt8Other) Index() int                     { return 1 }
func (x PodUnionFInt8Other) Interface() interface{}         { return x.Value }
func (x PodUnionFInt8Other) Name() string                   { return "FInt8Other" }
func (x PodUnionFInt8Other) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFInt8Other) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8Other")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(1).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFInt8Other) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFUint8) Index() int                     { return 2 }
func (x PodUnionFUint8) Interface() interface{}         { return x.Value }
func (x PodUnionFUint8) Name() string                   { return "FUint8" }
func (x PodUnionFUint8) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFUint8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FUint8")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(2).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFUint8) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFInt16) Index() int                     { return 3 }
func (x PodUnionFInt16) Interface() interface{}         { return x.Value }
func (x PodUnionFInt16) Name() string                   { return "FInt16" }
func (x PodUnionFInt16) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFInt16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt16")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(3).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFInt16) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFUint16) Index() int                     { return 4 }
func (x PodUnionFUint16) Interface() interface{}         { return x.Value }
func (x PodUnionFUint16) Name() string                   { return "FUint16" }
func (x PodUnionFUint16) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFUint16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FUint16")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(4).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFUint16) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFint32) Index() int                     { return 5 }
func (x PodUnionFint32) Interface() interface{}         { return x.Value }
func (x PodUnionFint32) Name() string                   { return "Fint32" }
func (x PodUnionFint32) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFint32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Fint32")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(5).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFint32) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFuint32) Index() int                     { return 6 }
func (x PodUnionFuint32) Interface() interface{}         { return x.Value }
func (x PodUnionFuint32) Name() string                   { return "Fuint32" }
func (x PodUnionFuint32) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFuint32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Fuint32")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(6).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFuint32) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFInt64) Index() int                     { return 7 }
func (x PodUnionFInt64) Interface() interface{}         { return x.Value }
func (x PodUnionFInt64) Name() string                   { return "FInt64" }
func (x PodUnionFInt64) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFInt64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt64")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(7).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFInt64) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFUint64) Index() int                     { return 8 }
func (x PodUnionFUint64) Interface() interface{}         { return x.Value }
func (x PodUnionFUint64) Name() string                   { return "FUint64" }
func (x PodUnionFUint64) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFUint64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FUint64")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromUint(uint64(m.Value), tt.NonOptional().Field(8).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFUint64) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFFloat) Index() int                     { return 9 }
func (x PodUnionFFloat) Interface() interface{}         { return x.Value }
func (x PodUnionFFloat) Name() string                   { return "FFloat" }
func (x PodUnionFFloat) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFFloat) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FFloat")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromFloat(float64(m.Value), tt.NonOptional().Field(9).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFFloat) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFDouble) Index() int                     { return 10 }
func (x PodUnionFDouble) Interface() interface{}         { return x.Value }
func (x PodUnionFDouble) Name() string                   { return "FDouble" }
func (x PodUnionFDouble) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFDouble) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FDouble")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromFloat(float64(m.Value), tt.NonOptional().Field(10).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFDouble) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFBool) Index() int                     { return 11 }
func (x PodUnionFBool) Interface() interface{}         { return x.Value }
func (x PodUnionFBool) Name() string                   { return "FBool" }
func (x PodUnionFBool) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFBool) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FBool")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromBool(bool(m.Value), tt.NonOptional().Field(11).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFBool) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PodUnionFEnum) Index() int                     { return 12 }
func (x PodUnionFEnum) Interface() interface{}         { return x.Value }
func (x PodUnionFEnum) Name() string                   { return "FEnum" }
func (x PodUnionFEnum) __VDLReflect(__PodUnionReflect) {}

func (m PodUnionFEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FEnum")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(12).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PodUnionFEnum) MakeVDLTarget() vdl.Target {
	return nil
}

type PodUnionTarget struct {
	Value     *PodUnion
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *PodUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*PodUnion)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *PodUnionTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "FInt8":
		val := int8(0)
		return nil, &vdl.Int8Target{Value: &val}, nil
	case "FInt8Other":
		val := int8(0)
		return nil, &vdl.Int8Target{Value: &val}, nil
	case "FUint8":
		val := byte(0)
		return nil, &vdl.ByteTarget{Value: &val}, nil
	case "FInt16":
		val := int16(0)
		return nil, &vdl.Int16Target{Value: &val}, nil
	case "FUint16":
		val := uint16(0)
		return nil, &vdl.Uint16Target{Value: &val}, nil
	case "Fint32":
		val := int32(0)
		return nil, &vdl.Int32Target{Value: &val}, nil
	case "Fuint32":
		val := uint32(0)
		return nil, &vdl.Uint32Target{Value: &val}, nil
	case "FInt64":
		val := int64(0)
		return nil, &vdl.Int64Target{Value: &val}, nil
	case "FUint64":
		val := uint64(0)
		return nil, &vdl.Uint64Target{Value: &val}, nil
	case "FFloat":
		val := float32(0)
		return nil, &vdl.Float32Target{Value: &val}, nil
	case "FDouble":
		val := float64(0)
		return nil, &vdl.Float64Target{Value: &val}, nil
	case "FBool":
		val := false
		return nil, &vdl.BoolTarget{Value: &val}, nil
	case "FEnum":
		val := AnEnumFirst
		return nil, &AnEnumTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union src/v.io/x/mojo/transcoder/testtypes.PodUnion", name)
	}
}
func (t *PodUnionTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "FInt8":
		*t.Value = PodUnionFInt8{*(fieldTarget.(*vdl.Int8Target)).Value}
	case "FInt8Other":
		*t.Value = PodUnionFInt8Other{*(fieldTarget.(*vdl.Int8Target)).Value}
	case "FUint8":
		*t.Value = PodUnionFUint8{*(fieldTarget.(*vdl.ByteTarget)).Value}
	case "FInt16":
		*t.Value = PodUnionFInt16{*(fieldTarget.(*vdl.Int16Target)).Value}
	case "FUint16":
		*t.Value = PodUnionFUint16{*(fieldTarget.(*vdl.Uint16Target)).Value}
	case "Fint32":
		*t.Value = PodUnionFint32{*(fieldTarget.(*vdl.Int32Target)).Value}
	case "Fuint32":
		*t.Value = PodUnionFuint32{*(fieldTarget.(*vdl.Uint32Target)).Value}
	case "FInt64":
		*t.Value = PodUnionFInt64{*(fieldTarget.(*vdl.Int64Target)).Value}
	case "FUint64":
		*t.Value = PodUnionFUint64{*(fieldTarget.(*vdl.Uint64Target)).Value}
	case "FFloat":
		*t.Value = PodUnionFFloat{*(fieldTarget.(*vdl.Float32Target)).Value}
	case "FDouble":
		*t.Value = PodUnionFDouble{*(fieldTarget.(*vdl.Float64Target)).Value}
	case "FBool":
		*t.Value = PodUnionFBool{*(fieldTarget.(*vdl.BoolTarget)).Value}
	case "FEnum":
		*t.Value = PodUnionFEnum{*(fieldTarget.(*AnEnumTarget)).Value}
	}
	return nil
}
func (t *PodUnionTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type podUnionTargetFactory struct{}

func (t podUnionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*PodUnion); ok {
		return &PodUnionTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *PodUnion", union)
}

func (x PodUnionFInt8) VDLIsZero() bool {
	return x.Value == 0
}

func (x PodUnionFInt8Other) VDLIsZero() bool {
	return false
}

func (x PodUnionFUint8) VDLIsZero() bool {
	return false
}

func (x PodUnionFInt16) VDLIsZero() bool {
	return false
}

func (x PodUnionFUint16) VDLIsZero() bool {
	return false
}

func (x PodUnionFint32) VDLIsZero() bool {
	return false
}

func (x PodUnionFuint32) VDLIsZero() bool {
	return false
}

func (x PodUnionFInt64) VDLIsZero() bool {
	return false
}

func (x PodUnionFUint64) VDLIsZero() bool {
	return false
}

func (x PodUnionFFloat) VDLIsZero() bool {
	return false
}

func (x PodUnionFDouble) VDLIsZero() bool {
	return false
}

func (x PodUnionFBool) VDLIsZero() bool {
	return false
}

func (x PodUnionFEnum) VDLIsZero() bool {
	return false
}

func (x PodUnionFInt8) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FInt8"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Int8Type); err != nil {
		return err
	}
	if err := enc.EncodeInt(int64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFInt8Other) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FInt8Other"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Int8Type); err != nil {
		return err
	}
	if err := enc.EncodeInt(int64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFUint8) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FUint8"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.ByteType); err != nil {
		return err
	}
	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFInt16) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FInt16"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Int16Type); err != nil {
		return err
	}
	if err := enc.EncodeInt(int64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFUint16) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FUint16"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Uint16Type); err != nil {
		return err
	}
	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFint32) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("Fint32"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Int32Type); err != nil {
		return err
	}
	if err := enc.EncodeInt(int64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFuint32) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("Fuint32"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Uint32Type); err != nil {
		return err
	}
	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFInt64) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FInt64"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Int64Type); err != nil {
		return err
	}
	if err := enc.EncodeInt(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFUint64) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FUint64"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Uint64Type); err != nil {
		return err
	}
	if err := enc.EncodeUint(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFFloat) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FFloat"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Float32Type); err != nil {
		return err
	}
	if err := enc.EncodeFloat(float64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFDouble) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FDouble"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Float64Type); err != nil {
		return err
	}
	if err := enc.EncodeFloat(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFBool) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FBool"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.BoolType); err != nil {
		return err
	}
	if err := enc.EncodeBool(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x PodUnionFEnum) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FEnum"); err != nil {
		return err
	}
	if err := x.Value.VDLWrite(enc); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func VDLReadPodUnion(dec vdl.Decoder, x *PodUnion) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "FInt8":
		var field PodUnionFInt8
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeInt(8)
		if err != nil {
			return err
		}
		field.Value = int8(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FInt8Other":
		var field PodUnionFInt8Other
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeInt(8)
		if err != nil {
			return err
		}
		field.Value = int8(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FUint8":
		var field PodUnionFUint8
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeUint(8)
		if err != nil {
			return err
		}
		field.Value = byte(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FInt16":
		var field PodUnionFInt16
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeInt(16)
		if err != nil {
			return err
		}
		field.Value = int16(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FUint16":
		var field PodUnionFUint16
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeUint(16)
		if err != nil {
			return err
		}
		field.Value = uint16(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "Fint32":
		var field PodUnionFint32
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeInt(32)
		if err != nil {
			return err
		}
		field.Value = int32(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "Fuint32":
		var field PodUnionFuint32
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeUint(32)
		if err != nil {
			return err
		}
		field.Value = uint32(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FInt64":
		var field PodUnionFInt64
		if err := dec.StartValue(); err != nil {
			return err
		}
		var err error
		if field.Value, err = dec.DecodeInt(64); err != nil {
			return err
		}
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FUint64":
		var field PodUnionFUint64
		if err := dec.StartValue(); err != nil {
			return err
		}
		var err error
		if field.Value, err = dec.DecodeUint(64); err != nil {
			return err
		}
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FFloat":
		var field PodUnionFFloat
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeFloat(32)
		if err != nil {
			return err
		}
		field.Value = float32(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FDouble":
		var field PodUnionFDouble
		if err := dec.StartValue(); err != nil {
			return err
		}
		var err error
		if field.Value, err = dec.DecodeFloat(64); err != nil {
			return err
		}
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FBool":
		var field PodUnionFBool
		if err := dec.StartValue(); err != nil {
			return err
		}
		var err error
		if field.Value, err = dec.DecodeBool(); err != nil {
			return err
		}
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FEnum":
		var field PodUnionFEnum
		if err := field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

type PodUnionWrapper struct {
	PodUnion PodUnion
}

func (PodUnionWrapper) __VDLReflect(struct {
	Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.PodUnionWrapper"`
}) {
}

func (m *PodUnionWrapper) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if field, ok := m.PodUnion.(PodUnionFInt8); ok {

		var5 := (field.Value == int8(0))
		var4 = var5
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("PodUnion"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("PodUnion")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			unionValue6 := m.PodUnion
			if unionValue6 == nil {
				unionValue6 = PodUnionFInt8{}
			}
			if err := unionValue6.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *PodUnionWrapper) MakeVDLTarget() vdl.Target {
	return &PodUnionWrapperTarget{Value: m}
}

type PodUnionWrapperTarget struct {
	Value          *PodUnionWrapper
	podUnionTarget PodUnionTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *PodUnionWrapperTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*PodUnionWrapper)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *PodUnionWrapperTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "PodUnion":
		t.podUnionTarget.Value = &t.Value.PodUnion
		target, err := &t.podUnionTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *PodUnionWrapperTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *PodUnionWrapperTarget) ZeroField(name string) error {
	switch name {
	case "PodUnion":
		t.Value.PodUnion = PodUnion(PodUnionFInt8{})
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *PodUnionWrapperTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x PodUnionWrapper) VDLIsZero() bool {
	if x.PodUnion != nil && !x.PodUnion.VDLIsZero() {
		return false
	}
	return true
}

func (x PodUnionWrapper) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*PodUnionWrapper)(nil)).Elem()); err != nil {
		return err
	}
	if x.PodUnion != nil && !x.PodUnion.VDLIsZero() {
		if err := enc.NextField("PodUnion"); err != nil {
			return err
		}
		if err := x.PodUnion.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *PodUnionWrapper) VDLRead(dec vdl.Decoder) error {
	*x = PodUnionWrapper{
		PodUnion: PodUnionFInt8{},
	}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "PodUnion":
			if err := VDLReadPodUnion(dec, &x.PodUnion); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type DummyStruct struct {
	FInt8 int8
}

func (DummyStruct) __VDLReflect(struct {
	Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.DummyStruct"`
}) {
}

func (m *DummyStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.FInt8 == int8(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("FInt8"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromInt(int64(m.FInt8), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *DummyStruct) MakeVDLTarget() vdl.Target {
	return &DummyStructTarget{Value: m}
}

type DummyStructTarget struct {
	Value       *DummyStruct
	fInt8Target vdl.Int8Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *DummyStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*DummyStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *DummyStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "FInt8":
		t.fInt8Target.Value = &t.Value.FInt8
		target, err := &t.fInt8Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *DummyStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *DummyStructTarget) ZeroField(name string) error {
	switch name {
	case "FInt8":
		t.Value.FInt8 = int8(0)
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *DummyStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x DummyStruct) VDLIsZero() bool {
	return x == DummyStruct{}
}

func (x DummyStruct) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*DummyStruct)(nil)).Elem()); err != nil {
		return err
	}
	if x.FInt8 != 0 {
		if err := enc.NextField("FInt8"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int8Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.FInt8)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *DummyStruct) VDLRead(dec vdl.Decoder) error {
	*x = DummyStruct{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "FInt8":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(8)
			if err != nil {
				return err
			}
			x.FInt8 = int8(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type (
	// ObjectUnion represents any single field of the ObjectUnion union type.
	ObjectUnion interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the ObjectUnion union type.
		__VDLReflect(__ObjectUnionReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
		VDLIsZero() bool
		VDLWrite(vdl.Encoder) error
	}
	// ObjectUnionFInt8 represents field FInt8 of the ObjectUnion union type.
	ObjectUnionFInt8 struct{ Value int8 }
	// ObjectUnionFString represents field FString of the ObjectUnion union type.
	ObjectUnionFString struct{ Value string }
	// ObjectUnionFDummy represents field FDummy of the ObjectUnion union type.
	ObjectUnionFDummy struct{ Value DummyStruct }
	// ObjectUnionFNullable represents field FNullable of the ObjectUnion union type.
	ObjectUnionFNullable struct{ Value *DummyStruct }
	// ObjectUnionFArrayInt8 represents field FArrayInt8 of the ObjectUnion union type.
	ObjectUnionFArrayInt8 struct{ Value []int8 }
	// ObjectUnionFMapInt8 represents field FMapInt8 of the ObjectUnion union type.
	ObjectUnionFMapInt8 struct{ Value map[string]int8 }
	// ObjectUnionFPodUnion represents field FPodUnion of the ObjectUnion union type.
	ObjectUnionFPodUnion struct{ Value PodUnion }
	// __ObjectUnionReflect describes the ObjectUnion union type.
	__ObjectUnionReflect struct {
		Name               string `vdl:"src/v.io/x/mojo/transcoder/testtypes.ObjectUnion"`
		Type               ObjectUnion
		UnionTargetFactory objectUnionTargetFactory
		Union              struct {
			FInt8      ObjectUnionFInt8
			FString    ObjectUnionFString
			FDummy     ObjectUnionFDummy
			FNullable  ObjectUnionFNullable
			FArrayInt8 ObjectUnionFArrayInt8
			FMapInt8   ObjectUnionFMapInt8
			FPodUnion  ObjectUnionFPodUnion
		}
	}
)

func (x ObjectUnionFInt8) Index() int                        { return 0 }
func (x ObjectUnionFInt8) Interface() interface{}            { return x.Value }
func (x ObjectUnionFInt8) Name() string                      { return "FInt8" }
func (x ObjectUnionFInt8) __VDLReflect(__ObjectUnionReflect) {}

func (m ObjectUnionFInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m ObjectUnionFInt8) MakeVDLTarget() vdl.Target {
	return nil
}

func (x ObjectUnionFString) Index() int                        { return 1 }
func (x ObjectUnionFString) Interface() interface{}            { return x.Value }
func (x ObjectUnionFString) Name() string                      { return "FString" }
func (x ObjectUnionFString) __VDLReflect(__ObjectUnionReflect) {}

func (m ObjectUnionFString) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FString")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(1).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m ObjectUnionFString) MakeVDLTarget() vdl.Target {
	return nil
}

func (x ObjectUnionFDummy) Index() int                        { return 2 }
func (x ObjectUnionFDummy) Interface() interface{}            { return x.Value }
func (x ObjectUnionFDummy) Name() string                      { return "FDummy" }
func (x ObjectUnionFDummy) __VDLReflect(__ObjectUnionReflect) {}

func (m ObjectUnionFDummy) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FDummy")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(2).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m ObjectUnionFDummy) MakeVDLTarget() vdl.Target {
	return nil
}

func (x ObjectUnionFNullable) Index() int                        { return 3 }
func (x ObjectUnionFNullable) Interface() interface{}            { return x.Value }
func (x ObjectUnionFNullable) Name() string                      { return "FNullable" }
func (x ObjectUnionFNullable) __VDLReflect(__ObjectUnionReflect) {}

func (m ObjectUnionFNullable) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FNullable")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(3).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m ObjectUnionFNullable) MakeVDLTarget() vdl.Target {
	return nil
}

func (x ObjectUnionFArrayInt8) Index() int                        { return 4 }
func (x ObjectUnionFArrayInt8) Interface() interface{}            { return x.Value }
func (x ObjectUnionFArrayInt8) Name() string                      { return "FArrayInt8" }
func (x ObjectUnionFArrayInt8) __VDLReflect(__ObjectUnionReflect) {}

func (m ObjectUnionFArrayInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FArrayInt8")
	if err != nil {
		return err
	}

	listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(4).Type, len(m.Value))
	if err != nil {
		return err
	}
	for i, elem6 := range m.Value {
		elemTarget5, err := listTarget4.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget5.FromInt(int64(elem6), tt.NonOptional().Field(4).Type.Elem()); err != nil {
			return err
		}
		if err := listTarget4.FinishElem(elemTarget5); err != nil {
			return err
		}
	}
	if err := fieldTarget3.FinishList(listTarget4); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m ObjectUnionFArrayInt8) MakeVDLTarget() vdl.Target {
	return nil
}

func (x ObjectUnionFMapInt8) Index() int                        { return 5 }
func (x ObjectUnionFMapInt8) Interface() interface{}            { return x.Value }
func (x ObjectUnionFMapInt8) Name() string                      { return "FMapInt8" }
func (x ObjectUnionFMapInt8) __VDLReflect(__ObjectUnionReflect) {}

func (m ObjectUnionFMapInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FMapInt8")
	if err != nil {
		return err
	}

	mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(5).Type, len(m.Value))
	if err != nil {
		return err
	}
	for key6, value8 := range m.Value {
		keyTarget5, err := mapTarget4.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget5.FromString(string(key6), tt.NonOptional().Field(5).Type.Key()); err != nil {
			return err
		}
		valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
		if err != nil {
			return err
		}
		if err := valueTarget7.FromInt(int64(value8), tt.NonOptional().Field(5).Type.Elem()); err != nil {
			return err
		}
		if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
			return err
		}
	}
	if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m ObjectUnionFMapInt8) MakeVDLTarget() vdl.Target {
	return nil
}

func (x ObjectUnionFPodUnion) Index() int                        { return 6 }
func (x ObjectUnionFPodUnion) Interface() interface{}            { return x.Value }
func (x ObjectUnionFPodUnion) Name() string                      { return "FPodUnion" }
func (x ObjectUnionFPodUnion) __VDLReflect(__ObjectUnionReflect) {}

func (m ObjectUnionFPodUnion) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FPodUnion")
	if err != nil {
		return err
	}

	unionValue4 := m.Value
	if unionValue4 == nil {
		unionValue4 = PodUnionFInt8{}
	}
	if err := unionValue4.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(6).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m ObjectUnionFPodUnion) MakeVDLTarget() vdl.Target {
	return nil
}

type ObjectUnionTarget struct {
	Value     *ObjectUnion
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ObjectUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*ObjectUnion)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *ObjectUnionTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "FInt8":
		val := int8(0)
		return nil, &vdl.Int8Target{Value: &val}, nil
	case "FString":
		val := ""
		return nil, &vdl.StringTarget{Value: &val}, nil
	case "FDummy":
		val := DummyStruct{}
		return nil, &DummyStructTarget{Value: &val}, nil
	case "FNullable":
		val := (*DummyStruct)(nil)
		return nil, &__VDLTarget1_optional{Value: &val}, nil
	case "FArrayInt8":
		val := []int8(nil)
		return nil, &__VDLTarget2_list{Value: &val}, nil
	case "FMapInt8":
		val := map[string]int8(nil)
		return nil, &__VDLTarget3_map{Value: &val}, nil
	case "FPodUnion":
		val := PodUnion(PodUnionFInt8{})
		return nil, &PodUnionTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union src/v.io/x/mojo/transcoder/testtypes.ObjectUnion", name)
	}
}
func (t *ObjectUnionTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "FInt8":
		*t.Value = ObjectUnionFInt8{*(fieldTarget.(*vdl.Int8Target)).Value}
	case "FString":
		*t.Value = ObjectUnionFString{*(fieldTarget.(*vdl.StringTarget)).Value}
	case "FDummy":
		*t.Value = ObjectUnionFDummy{*(fieldTarget.(*DummyStructTarget)).Value}
	case "FNullable":
		*t.Value = ObjectUnionFNullable{*(fieldTarget.(*__VDLTarget1_optional)).Value}
	case "FArrayInt8":
		*t.Value = ObjectUnionFArrayInt8{*(fieldTarget.(*__VDLTarget2_list)).Value}
	case "FMapInt8":
		*t.Value = ObjectUnionFMapInt8{*(fieldTarget.(*__VDLTarget3_map)).Value}
	case "FPodUnion":
		*t.Value = ObjectUnionFPodUnion{*(fieldTarget.(*PodUnionTarget)).Value}
	}
	return nil
}
func (t *ObjectUnionTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type objectUnionTargetFactory struct{}

func (t objectUnionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*ObjectUnion); ok {
		return &ObjectUnionTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *ObjectUnion", union)
}

// Optional DummyStruct
type __VDLTarget1_optional struct {
	Value      **DummyStruct
	elemTarget DummyStructTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *__VDLTarget1_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if *t.Value == nil {
		*t.Value = &DummyStruct{}
	}
	t.elemTarget.Value = *t.Value
	target, err := &t.elemTarget, error(nil)
	if err != nil {
		return nil, err
	}
	return target.StartFields(tt)
}
func (t *__VDLTarget1_optional) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *__VDLTarget1_optional) FromNil(tt *vdl.Type) error {
	*t.Value = (*DummyStruct)(nil)
	return nil
}

// []int8
type __VDLTarget2_list struct {
	Value      *[]int8
	elemTarget vdl.Int8Target
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget2_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]int8)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]int8, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget2_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget2_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget2_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

// map[string]int8
type __VDLTarget3_map struct {
	Value      *map[string]int8
	currKey    string
	currElem   int8
	keyTarget  vdl.StringTarget
	elemTarget vdl.Int8Target
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget3_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[string]int8)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[string]int8)
	return t, nil
}
func (t *__VDLTarget3_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget3_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = int8(0)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget3_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget3_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

func (x ObjectUnionFInt8) VDLIsZero() bool {
	return x.Value == 0
}

func (x ObjectUnionFString) VDLIsZero() bool {
	return false
}

func (x ObjectUnionFDummy) VDLIsZero() bool {
	return false
}

func (x ObjectUnionFNullable) VDLIsZero() bool {
	return false
}

func (x ObjectUnionFArrayInt8) VDLIsZero() bool {
	return false
}

func (x ObjectUnionFMapInt8) VDLIsZero() bool {
	return false
}

func (x ObjectUnionFPodUnion) VDLIsZero() bool {
	return false
}

func (x ObjectUnionFInt8) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FInt8"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.Int8Type); err != nil {
		return err
	}
	if err := enc.EncodeInt(int64(x.Value)); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x ObjectUnionFString) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FString"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.StringType); err != nil {
		return err
	}
	if err := enc.EncodeString(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x ObjectUnionFDummy) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FDummy"); err != nil {
		return err
	}
	if err := x.Value.VDLWrite(enc); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x ObjectUnionFNullable) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FNullable"); err != nil {
		return err
	}
	if x.Value == nil {
		if err := enc.NilValue(vdl.TypeOf((**DummyStruct)(nil))); err != nil {
			return err
		}
	} else {
		enc.SetNextStartValueIsOptional()

		if err := x.Value.VDLWrite(enc); err != nil {
			return err
		}

	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x ObjectUnionFArrayInt8) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FArrayInt8"); err != nil {
		return err
	}
	if err := __VDLWriteAnon_list_1(enc, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x ObjectUnionFMapInt8) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FMapInt8"); err != nil {
		return err
	}
	if err := __VDLWriteAnon_map_2(enc, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x ObjectUnionFPodUnion) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("FPodUnion"); err != nil {
		return err
	}
	switch {
	case x.Value == nil:
		// Write the zero value of the union type.
		if err := vdl.ZeroValue(vdl.TypeOf((*PodUnion)(nil))).VDLWrite(enc); err != nil {
			return err
		}
	default:
		if err := x.Value.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_list_1(enc vdl.Encoder, x []int8) error {
	if err := enc.StartValue(vdl.TypeOf((*[]int8)(nil))); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for i := 0; i < len(x); i++ {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int8Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x[i])); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_map_2(enc vdl.Encoder, x map[string]int8) error {
	if err := enc.StartValue(vdl.TypeOf((*map[string]int8)(nil))); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int8Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(elem)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func VDLReadObjectUnion(dec vdl.Decoder, x *ObjectUnion) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "FInt8":
		var field ObjectUnionFInt8
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeInt(8)
		if err != nil {
			return err
		}
		field.Value = int8(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FString":
		var field ObjectUnionFString
		if err := dec.StartValue(); err != nil {
			return err
		}
		var err error
		if field.Value, err = dec.DecodeString(); err != nil {
			return err
		}
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "FDummy":
		var field ObjectUnionFDummy
		if err := field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "FNullable":
		var field ObjectUnionFNullable
		if err := dec.StartValue(); err != nil {
			return err
		}
		if dec.IsNil() {
			if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(field.Value), dec.Type()) {
				return fmt.Errorf("incompatible optional %T, from %v", field.Value, dec.Type())
			}
			field.Value = nil
			if err := dec.FinishValue(); err != nil {
				return err
			}
		} else {
			field.Value = new(DummyStruct)
			dec.IgnoreNextStartValue()
			if err := field.Value.VDLRead(dec); err != nil {
				return err
			}
		}
		*x = field
	case "FArrayInt8":
		var field ObjectUnionFArrayInt8
		if err := __VDLReadAnon_list_1(dec, &field.Value); err != nil {
			return err
		}
		*x = field
	case "FMapInt8":
		var field ObjectUnionFMapInt8
		if err := __VDLReadAnon_map_2(dec, &field.Value); err != nil {
			return err
		}
		*x = field
	case "FPodUnion":
		var field ObjectUnionFPodUnion
		if err := VDLReadPodUnion(dec, &field.Value); err != nil {
			return err
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]int8) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len > 0:
		*x = make([]int8, 0, len)
	default:
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem int8
		if err := dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeInt(8)
		if err != nil {
			return err
		}
		elem = int8(tmp)
		if err := dec.FinishValue(); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

func __VDLReadAnon_map_2(dec vdl.Decoder, x *map[string]int8) error {
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[string]int8
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]int8, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key string
		{
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem int8
		{
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(8)
			if err != nil {
				return err
			}
			elem = int8(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[string]int8)
		}
		tmpMap[key] = elem
	}
}

type ObjectUnionWrapper struct {
	ObjectUnion ObjectUnion
}

func (ObjectUnionWrapper) __VDLReflect(struct {
	Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.ObjectUnionWrapper"`
}) {
}

func (m *ObjectUnionWrapper) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if field, ok := m.ObjectUnion.(ObjectUnionFInt8); ok {

		var5 := (field.Value == int8(0))
		var4 = var5
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("ObjectUnion"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ObjectUnion")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			unionValue6 := m.ObjectUnion
			if unionValue6 == nil {
				unionValue6 = ObjectUnionFInt8{}
			}
			if err := unionValue6.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ObjectUnionWrapper) MakeVDLTarget() vdl.Target {
	return &ObjectUnionWrapperTarget{Value: m}
}

type ObjectUnionWrapperTarget struct {
	Value             *ObjectUnionWrapper
	objectUnionTarget ObjectUnionTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ObjectUnionWrapperTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*ObjectUnionWrapper)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ObjectUnionWrapperTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "ObjectUnion":
		t.objectUnionTarget.Value = &t.Value.ObjectUnion
		target, err := &t.objectUnionTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *ObjectUnionWrapperTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ObjectUnionWrapperTarget) ZeroField(name string) error {
	switch name {
	case "ObjectUnion":
		t.Value.ObjectUnion = ObjectUnion(ObjectUnionFInt8{})
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *ObjectUnionWrapperTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x ObjectUnionWrapper) VDLIsZero() bool {
	if x.ObjectUnion != nil && !x.ObjectUnion.VDLIsZero() {
		return false
	}
	return true
}

func (x ObjectUnionWrapper) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ObjectUnionWrapper)(nil)).Elem()); err != nil {
		return err
	}
	if x.ObjectUnion != nil && !x.ObjectUnion.VDLIsZero() {
		if err := enc.NextField("ObjectUnion"); err != nil {
			return err
		}
		if err := x.ObjectUnion.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *ObjectUnionWrapper) VDLRead(dec vdl.Decoder) error {
	*x = ObjectUnionWrapper{
		ObjectUnion: ObjectUnionFInt8{},
	}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "ObjectUnion":
			if err := VDLReadObjectUnion(dec, &x.ObjectUnion); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type Rect struct {
	X      int32
	Y      int32
	Width  int32
	Height int32
}

func (Rect) __VDLReflect(struct {
	Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.Rect"`
}) {
}

func (m *Rect) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.X == int32(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("X"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("X")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromInt(int64(m.X), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Y == int32(0))
	if var7 {
		if err := fieldsTarget1.ZeroField("Y"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Y")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromInt(int64(m.Y), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.Width == int32(0))
	if var10 {
		if err := fieldsTarget1.ZeroField("Width"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Width")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromInt(int64(m.Width), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var13 := (m.Height == int32(0))
	if var13 {
		if err := fieldsTarget1.ZeroField("Height"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Height")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget12.FromInt(int64(m.Height), tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rect) MakeVDLTarget() vdl.Target {
	return &RectTarget{Value: m}
}

type RectTarget struct {
	Value        *Rect
	xTarget      vdl.Int32Target
	yTarget      vdl.Int32Target
	widthTarget  vdl.Int32Target
	heightTarget vdl.Int32Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *RectTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Rect)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *RectTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "X":
		t.xTarget.Value = &t.Value.X
		target, err := &t.xTarget, error(nil)
		return nil, target, err
	case "Y":
		t.yTarget.Value = &t.Value.Y
		target, err := &t.yTarget, error(nil)
		return nil, target, err
	case "Width":
		t.widthTarget.Value = &t.Value.Width
		target, err := &t.widthTarget, error(nil)
		return nil, target, err
	case "Height":
		t.heightTarget.Value = &t.Value.Height
		target, err := &t.heightTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *RectTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *RectTarget) ZeroField(name string) error {
	switch name {
	case "X":
		t.Value.X = int32(0)
		return nil
	case "Y":
		t.Value.Y = int32(0)
		return nil
	case "Width":
		t.Value.Width = int32(0)
		return nil
	case "Height":
		t.Value.Height = int32(0)
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *RectTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x Rect) VDLIsZero() bool {
	return x == Rect{}
}

func (x Rect) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Rect)(nil)).Elem()); err != nil {
		return err
	}
	if x.X != 0 {
		if err := enc.NextField("X"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int32Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.X)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Y != 0 {
		if err := enc.NextField("Y"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int32Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.Y)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Width != 0 {
		if err := enc.NextField("Width"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int32Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.Width)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.Height != 0 {
		if err := enc.NextField("Height"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int32Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.Height)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Rect) VDLRead(dec vdl.Decoder) error {
	*x = Rect{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "X":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.X = int32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Y":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.Y = int32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Width":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.Width = int32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "Height":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.Height = int32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type MultiVersionStruct struct {
	FInt32  int32
	FRect   Rect
	FString string
	FArray  []int8
	FBool   bool
	FInt16  int16
}

func (MultiVersionStruct) __VDLReflect(struct {
	Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.MultiVersionStruct"`
}) {
}

func (m *MultiVersionStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.FInt32 == int32(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("FInt32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromInt(int64(m.FInt32), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.FRect == Rect{})
	if var7 {
		if err := fieldsTarget1.ZeroField("FRect"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FRect")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.FRect.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.FString == "")
	if var10 {
		if err := fieldsTarget1.ZeroField("FString"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("FString")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromString(string(m.FString), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var var13 bool
	if len(m.FArray) == 0 {
		var13 = true
	}
	if var13 {
		if err := fieldsTarget1.ZeroField("FArray"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("FArray")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget14, err := fieldTarget12.StartList(tt.NonOptional().Field(3).Type, len(m.FArray))
			if err != nil {
				return err
			}
			for i, elem16 := range m.FArray {
				elemTarget15, err := listTarget14.StartElem(i)
				if err != nil {
					return err
				}
				if err := elemTarget15.FromInt(int64(elem16), tt.NonOptional().Field(3).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget14.FinishElem(elemTarget15); err != nil {
					return err
				}
			}
			if err := fieldTarget12.FinishList(listTarget14); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	var19 := (m.FBool == false)
	if var19 {
		if err := fieldsTarget1.ZeroField("FBool"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("FBool")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget18.FromBool(bool(m.FBool), tt.NonOptional().Field(4).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
				return err
			}
		}
	}
	var22 := (m.FInt16 == int16(0))
	if var22 {
		if err := fieldsTarget1.ZeroField("FInt16"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("FInt16")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget21.FromInt(int64(m.FInt16), tt.NonOptional().Field(5).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MultiVersionStruct) MakeVDLTarget() vdl.Target {
	return &MultiVersionStructTarget{Value: m}
}

type MultiVersionStructTarget struct {
	Value         *MultiVersionStruct
	fInt32Target  vdl.Int32Target
	fRectTarget   RectTarget
	fStringTarget vdl.StringTarget
	fArrayTarget  __VDLTarget2_list
	fBoolTarget   vdl.BoolTarget
	fInt16Target  vdl.Int16Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *MultiVersionStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*MultiVersionStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *MultiVersionStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "FInt32":
		t.fInt32Target.Value = &t.Value.FInt32
		target, err := &t.fInt32Target, error(nil)
		return nil, target, err
	case "FRect":
		t.fRectTarget.Value = &t.Value.FRect
		target, err := &t.fRectTarget, error(nil)
		return nil, target, err
	case "FString":
		t.fStringTarget.Value = &t.Value.FString
		target, err := &t.fStringTarget, error(nil)
		return nil, target, err
	case "FArray":
		t.fArrayTarget.Value = &t.Value.FArray
		target, err := &t.fArrayTarget, error(nil)
		return nil, target, err
	case "FBool":
		t.fBoolTarget.Value = &t.Value.FBool
		target, err := &t.fBoolTarget, error(nil)
		return nil, target, err
	case "FInt16":
		t.fInt16Target.Value = &t.Value.FInt16
		target, err := &t.fInt16Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *MultiVersionStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *MultiVersionStructTarget) ZeroField(name string) error {
	switch name {
	case "FInt32":
		t.Value.FInt32 = int32(0)
		return nil
	case "FRect":
		t.Value.FRect = Rect{}
		return nil
	case "FString":
		t.Value.FString = ""
		return nil
	case "FArray":
		t.Value.FArray = []int8(nil)
		return nil
	case "FBool":
		t.Value.FBool = false
		return nil
	case "FInt16":
		t.Value.FInt16 = int16(0)
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *MultiVersionStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x MultiVersionStruct) VDLIsZero() bool {
	if x.FInt32 != 0 {
		return false
	}
	if x.FRect != (Rect{}) {
		return false
	}
	if x.FString != "" {
		return false
	}
	if len(x.FArray) != 0 {
		return false
	}
	if x.FBool {
		return false
	}
	if x.FInt16 != 0 {
		return false
	}
	return true
}

func (x MultiVersionStruct) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*MultiVersionStruct)(nil)).Elem()); err != nil {
		return err
	}
	if x.FInt32 != 0 {
		if err := enc.NextField("FInt32"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int32Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.FInt32)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.FRect != (Rect{}) {
		if err := enc.NextField("FRect"); err != nil {
			return err
		}
		if err := x.FRect.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.FString != "" {
		if err := enc.NextField("FString"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.FString); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if len(x.FArray) != 0 {
		if err := enc.NextField("FArray"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_list_1(enc, x.FArray); err != nil {
			return err
		}
	}
	if x.FBool {
		if err := enc.NextField("FBool"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.BoolType); err != nil {
			return err
		}
		if err := enc.EncodeBool(x.FBool); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.FInt16 != 0 {
		if err := enc.NextField("FInt16"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int16Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.FInt16)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *MultiVersionStruct) VDLRead(dec vdl.Decoder) error {
	*x = MultiVersionStruct{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "FInt32":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.FInt32 = int32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "FRect":
			if err := x.FRect.VDLRead(dec); err != nil {
				return err
			}
		case "FString":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.FString, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "FArray":
			if err := __VDLReadAnon_list_1(dec, &x.FArray); err != nil {
				return err
			}
		case "FBool":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.FBool, err = dec.DecodeBool(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "FInt16":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(16)
			if err != nil {
				return err
			}
			x.FInt16 = int16(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type MultiVersionStructV3 struct {
	FInt32  int32
	FRect   Rect
	FString string
}

func (MultiVersionStructV3) __VDLReflect(struct {
	Name string `vdl:"src/v.io/x/mojo/transcoder/testtypes.MultiVersionStructV3"`
}) {
}

func (m *MultiVersionStructV3) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.FInt32 == int32(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("FInt32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromInt(int64(m.FInt32), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.FRect == Rect{})
	if var7 {
		if err := fieldsTarget1.ZeroField("FRect"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FRect")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.FRect.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.FString == "")
	if var10 {
		if err := fieldsTarget1.ZeroField("FString"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("FString")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromString(string(m.FString), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MultiVersionStructV3) MakeVDLTarget() vdl.Target {
	return &MultiVersionStructV3Target{Value: m}
}

type MultiVersionStructV3Target struct {
	Value         *MultiVersionStructV3
	fInt32Target  vdl.Int32Target
	fRectTarget   RectTarget
	fStringTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *MultiVersionStructV3Target) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*MultiVersionStructV3)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *MultiVersionStructV3Target) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "FInt32":
		t.fInt32Target.Value = &t.Value.FInt32
		target, err := &t.fInt32Target, error(nil)
		return nil, target, err
	case "FRect":
		t.fRectTarget.Value = &t.Value.FRect
		target, err := &t.fRectTarget, error(nil)
		return nil, target, err
	case "FString":
		t.fStringTarget.Value = &t.Value.FString
		target, err := &t.fStringTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, vdl.ErrFieldNoExist
	}
}
func (t *MultiVersionStructV3Target) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *MultiVersionStructV3Target) ZeroField(name string) error {
	switch name {
	case "FInt32":
		t.Value.FInt32 = int32(0)
		return nil
	case "FRect":
		t.Value.FRect = Rect{}
		return nil
	case "FString":
		t.Value.FString = ""
		return nil
	default:
		return vdl.ErrFieldNoExist
	}
}
func (t *MultiVersionStructV3Target) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x MultiVersionStructV3) VDLIsZero() bool {
	return x == MultiVersionStructV3{}
}

func (x MultiVersionStructV3) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*MultiVersionStructV3)(nil)).Elem()); err != nil {
		return err
	}
	if x.FInt32 != 0 {
		if err := enc.NextField("FInt32"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.Int32Type); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.FInt32)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if x.FRect != (Rect{}) {
		if err := enc.NextField("FRect"); err != nil {
			return err
		}
		if err := x.FRect.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.FString != "" {
		if err := enc.NextField("FString"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.StringType); err != nil {
			return err
		}
		if err := enc.EncodeString(x.FString); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *MultiVersionStructV3) VDLRead(dec vdl.Decoder) error {
	*x = MultiVersionStructV3{}
	if err := dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "FInt32":
			if err := dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.FInt32 = int32(tmp)
			if err := dec.FinishValue(); err != nil {
				return err
			}
		case "FRect":
			if err := x.FRect.VDLRead(dec); err != nil {
				return err
			}
		case "FString":
			if err := dec.StartValue(); err != nil {
				return err
			}
			var err error
			if x.FString, err = dec.DecodeString(); err != nil {
				return err
			}
			if err := dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

var __VDLInitCalled bool

// __VDLInit performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = __VDLInit()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func __VDLInit() struct{} {
	if __VDLInitCalled {
		return struct{}{}
	}
	__VDLInitCalled = true

	// Register types.
	vdl.Register((*AnEnum)(nil))
	vdl.Register((*PodUnion)(nil))
	vdl.Register((*PodUnionWrapper)(nil))
	vdl.Register((*DummyStruct)(nil))
	vdl.Register((*ObjectUnion)(nil))
	vdl.Register((*ObjectUnionWrapper)(nil))
	vdl.Register((*Rect)(nil))
	vdl.Register((*MultiVersionStruct)(nil))
	vdl.Register((*MultiVersionStructV3)(nil))

	return struct{}{}
}