diff --git a/test/fortune/fortune.vdl.go b/test/fortune/fortune.vdl.go
index 292ee80..a414e83 100644
--- a/test/fortune/fortune.vdl.go
+++ b/test/fortune/fortune.vdl.go
@@ -35,188 +35,6 @@
 }) {
 }
 
-func (m *ComplexErrorParam) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
-	fieldsTarget1, err := t.StartFields(tt)
-	if err != nil {
-		return err
-	}
-	var4 := (m.Str == "")
-	if var4 {
-		if err := fieldsTarget1.ZeroField("Str"); err != nil && err != vdl.ErrFieldNoExist {
-			return err
-		}
-	} else {
-		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Str")
-		if err != vdl.ErrFieldNoExist {
-			if err != nil {
-				return err
-			}
-			if err := fieldTarget3.FromString(string(m.Str), tt.NonOptional().Field(0).Type); err != nil {
-				return err
-			}
-			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
-				return err
-			}
-		}
-	}
-	var7 := (m.Num == int32(0))
-	if var7 {
-		if err := fieldsTarget1.ZeroField("Num"); err != nil && err != vdl.ErrFieldNoExist {
-			return err
-		}
-	} else {
-		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Num")
-		if err != vdl.ErrFieldNoExist {
-			if err != nil {
-				return err
-			}
-			if err := fieldTarget6.FromInt(int64(m.Num), tt.NonOptional().Field(1).Type); err != nil {
-				return err
-			}
-			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
-				return err
-			}
-		}
-	}
-	var var10 bool
-	if len(m.List) == 0 {
-		var10 = true
-	}
-	if var10 {
-		if err := fieldsTarget1.ZeroField("List"); err != nil && err != vdl.ErrFieldNoExist {
-			return err
-		}
-	} else {
-		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("List")
-		if err != vdl.ErrFieldNoExist {
-			if err != nil {
-				return err
-			}
-
-			listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(2).Type, len(m.List))
-			if err != nil {
-				return err
-			}
-			for i, elem13 := range m.List {
-				elemTarget12, err := listTarget11.StartElem(i)
-				if err != nil {
-					return err
-				}
-				if err := elemTarget12.FromUint(uint64(elem13), tt.NonOptional().Field(2).Type.Elem()); err != nil {
-					return err
-				}
-				if err := listTarget11.FinishElem(elemTarget12); err != nil {
-					return err
-				}
-			}
-			if err := fieldTarget9.FinishList(listTarget11); 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 *ComplexErrorParam) MakeVDLTarget() vdl.Target {
-	return &ComplexErrorParamTarget{Value: m}
-}
-
-type ComplexErrorParamTarget struct {
-	Value      *ComplexErrorParam
-	strTarget  vdl.StringTarget
-	numTarget  vdl.Int32Target
-	listTarget __VDLTarget1_list
-	vdl.TargetBase
-	vdl.FieldsTargetBase
-}
-
-func (t *ComplexErrorParamTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
-
-	if ttWant := vdl.TypeOf((*ComplexErrorParam)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
-		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
-	}
-	return t, nil
-}
-func (t *ComplexErrorParamTarget) StartField(name string) (key, field vdl.Target, _ error) {
-	switch name {
-	case "Str":
-		t.strTarget.Value = &t.Value.Str
-		target, err := &t.strTarget, error(nil)
-		return nil, target, err
-	case "Num":
-		t.numTarget.Value = &t.Value.Num
-		target, err := &t.numTarget, error(nil)
-		return nil, target, err
-	case "List":
-		t.listTarget.Value = &t.Value.List
-		target, err := &t.listTarget, error(nil)
-		return nil, target, err
-	default:
-		return nil, nil, vdl.ErrFieldNoExist
-	}
-}
-func (t *ComplexErrorParamTarget) FinishField(_, _ vdl.Target) error {
-	return nil
-}
-func (t *ComplexErrorParamTarget) ZeroField(name string) error {
-	switch name {
-	case "Str":
-		t.Value.Str = ""
-		return nil
-	case "Num":
-		t.Value.Num = int32(0)
-		return nil
-	case "List":
-		t.Value.List = []uint32(nil)
-		return nil
-	default:
-		return vdl.ErrFieldNoExist
-	}
-}
-func (t *ComplexErrorParamTarget) FinishFields(_ vdl.FieldsTarget) error {
-
-	return nil
-}
-
-// []uint32
-type __VDLTarget1_list struct {
-	Value      *[]uint32
-	elemTarget vdl.Uint32Target
-	vdl.TargetBase
-	vdl.ListTargetBase
-}
-
-func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
-
-	if ttWant := vdl.TypeOf((*[]uint32)(nil)); !vdl.Compatible(tt, ttWant) {
-		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
-	}
-	if cap(*t.Value) < len {
-		*t.Value = make([]uint32, len)
-	} else {
-		*t.Value = (*t.Value)[:len]
-	}
-	return t, nil
-}
-func (t *__VDLTarget1_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 *__VDLTarget1_list) FinishElem(elem vdl.Target) error {
-	return nil
-}
-func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error {
-
-	return nil
-}
-
 func (x ComplexErrorParam) VDLIsZero() bool {
 	if x.Str != "" {
 		return false