diff --git a/go/src/v.io/x/mojo/transcoder/from_mojom.go b/go/src/v.io/x/mojo/transcoder/from_mojom.go
index 7ee6faf..1e8ec0b 100644
--- a/go/src/v.io/x/mojo/transcoder/from_mojom.go
+++ b/go/src/v.io/x/mojo/transcoder/from_mojom.go
@@ -134,7 +134,7 @@
 		case err != nil:
 			return err
 		case ptr == 0 && isNullable:
-			return target.FromZero(vdl.OptionalType(vt))
+			return target.FromNil(vdl.OptionalType(vt))
 		case ptr == 0 && !isNullable:
 			return fmt.Errorf("invalid null struct pointer")
 		}
@@ -212,7 +212,7 @@
 		case err != nil:
 			return err
 		case ptr == 0 && isNullable:
-			return target.FromZero(vdl.OptionalType(vt))
+			return target.FromNil(vdl.OptionalType(vt))
 		case ptr == 0 && !isNullable:
 			return fmt.Errorf("invalid null struct pointer")
 		}
@@ -278,7 +278,7 @@
 			case err != nil:
 				return err
 			case ptr == 0 && isNullable:
-				return target.FromZero(vdl.OptionalType(vt))
+				return target.FromNil(vdl.OptionalType(vt))
 			case ptr == 0 && !isNullable:
 				return fmt.Errorf("invalid null struct pointer")
 			}
@@ -318,7 +318,7 @@
 		}
 		if size == 0 {
 			mtv.modec.SkipUnionValue()
-			return target.FromZero(vdl.OptionalType(vt))
+			return target.FromNil(vdl.OptionalType(vt))
 		}
 		if int(tag) >= vt.NumField() {
 			return fmt.Errorf("union tag out of bounds")
@@ -337,7 +337,7 @@
 			case err != nil:
 				return err
 			case ptr == 0 && isNullable:
-				return target.FromZero(vdl.OptionalType(fld.Type))
+				return target.FromNil(vdl.OptionalType(fld.Type))
 			case ptr == 0 && !isNullable:
 				return fmt.Errorf("invalid null union pointer")
 			}
diff --git a/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go b/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go
index 77225a3..83fb2a3 100644
--- a/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go
+++ b/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go
@@ -34,84 +34,80 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Street")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.Street == "")
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	var4 := (m.Street == "")
+	if var4 {
+		if err := fieldsTarget1.ZeroField("Street"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Street")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 			if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
-			return err
-		}
-	}
-	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("City")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var7 := (m.City == "")
-		if var7 {
-			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var7 := (m.City == "")
+	if var7 {
+		if err := fieldsTarget1.ZeroField("City"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("City")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 			if err := fieldTarget6.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
-			return err
-		}
-	}
-	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("State")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var10 := (m.State == "")
-		if var10 {
-			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var10 := (m.State == "")
+	if var10 {
+		if err := fieldsTarget1.ZeroField("State"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("State")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 			if err := fieldTarget9.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
-			return err
-		}
-	}
-	keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Zip")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var13 := (m.Zip == "")
-		if var13 {
-			if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var13 := (m.Zip == "")
+	if var13 {
+		if err := fieldsTarget1.ZeroField("Zip"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Zip")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 			if err := fieldTarget12.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
-			return err
+			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -166,14 +162,28 @@
 func (t *AddressInfoTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
+func (t *AddressInfoTarget) ZeroField(name string) error {
+	switch name {
+	case "Street":
+		t.Value.Street = ""
+		return nil
+	case "City":
+		t.Value.City = ""
+		return nil
+	case "State":
+		t.Value.State = ""
+		return nil
+	case "Zip":
+		t.Value.Zip = ""
+		return nil
+	default:
+		return fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/internal.AddressInfo", name)
+	}
+}
 func (t *AddressInfoTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *AddressInfoTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = AddressInfo{}
-	return nil
-}
 
 type CreditAgency int
 
@@ -262,10 +272,6 @@
 
 	return nil
 }
-func (t *CreditAgencyTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = CreditAgencyEquifax
-	return nil
-}
 
 type ExperianRating int
 
@@ -346,10 +352,6 @@
 
 	return nil
 }
-func (t *ExperianRatingTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = ExperianRatingGood
-	return nil
-}
 
 type EquifaxCreditReport struct {
 	Rating byte
@@ -365,24 +367,23 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.Rating == byte(0))
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	var4 := (m.Rating == byte(0))
+	if var4 {
+		if err := fieldsTarget1.ZeroField("Rating"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 			if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
-			return err
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -422,14 +423,19 @@
 func (t *EquifaxCreditReportTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
+func (t *EquifaxCreditReportTarget) ZeroField(name string) error {
+	switch name {
+	case "Rating":
+		t.Value.Rating = byte(0)
+		return nil
+	default:
+		return fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/internal.EquifaxCreditReport", name)
+	}
+}
 func (t *EquifaxCreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *EquifaxCreditReportTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = EquifaxCreditReport{}
-	return nil
-}
 
 type ExperianCreditReport struct {
 	Rating ExperianRating
@@ -445,25 +451,24 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.Rating == ExperianRatingGood)
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	var4 := (m.Rating == ExperianRatingGood)
+	if var4 {
+		if err := fieldsTarget1.ZeroField("Rating"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 
 			if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
-			return err
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -503,14 +508,19 @@
 func (t *ExperianCreditReportTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
+func (t *ExperianCreditReportTarget) ZeroField(name string) error {
+	switch name {
+	case "Rating":
+		t.Value.Rating = ExperianRatingGood
+		return nil
+	default:
+		return fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/internal.ExperianCreditReport", name)
+	}
+}
 func (t *ExperianCreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *ExperianCreditReportTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = ExperianCreditReport{}
-	return nil
-}
 
 type TransUnionCreditReport struct {
 	Rating int16
@@ -526,24 +536,23 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.Rating == int16(0))
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	var4 := (m.Rating == int16(0))
+	if var4 {
+		if err := fieldsTarget1.ZeroField("Rating"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 			if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
-			return err
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -583,14 +592,19 @@
 func (t *TransUnionCreditReportTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
+func (t *TransUnionCreditReportTarget) ZeroField(name string) error {
+	switch name {
+	case "Rating":
+		t.Value.Rating = int16(0)
+		return nil
+	default:
+		return fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/internal.TransUnionCreditReport", name)
+	}
+}
 func (t *TransUnionCreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *TransUnionCreditReportTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = TransUnionCreditReport{}
-	return nil
-}
 
 type (
 	// AgencyReport represents any single field of the AgencyReport union type.
@@ -766,10 +780,6 @@
 
 	return nil
 }
-func (t *AgencyReportTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = AgencyReport(AgencyReportEquifaxReport{})
-	return nil
-}
 
 type agencyReportTargetFactory struct{}
 
@@ -795,44 +805,42 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Agency")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.Agency == CreditAgencyEquifax)
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	var4 := (m.Agency == CreditAgencyEquifax)
+	if var4 {
+		if err := fieldsTarget1.ZeroField("Agency"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Agency")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 
 			if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
-			return err
-		}
-	}
-	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Report")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var var7 bool
-		if field, ok := m.Report.(AgencyReportEquifaxReport); ok {
-
-			var8 := (field.Value == EquifaxCreditReport{})
-			var7 = var8
-		}
-		if var7 {
-			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var var7 bool
+	if field, ok := m.Report.(AgencyReportEquifaxReport); ok {
+
+		var8 := (field.Value == EquifaxCreditReport{})
+		var7 = var8
+	}
+	if var7 {
+		if err := fieldsTarget1.ZeroField("Report"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Report")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 
 			unionValue9 := m.Report
 			if unionValue9 == nil {
@@ -841,9 +849,9 @@
 			if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
-			return err
+			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -888,16 +896,22 @@
 func (t *CreditReportTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
+func (t *CreditReportTarget) ZeroField(name string) error {
+	switch name {
+	case "Agency":
+		t.Value.Agency = CreditAgencyEquifax
+		return nil
+	case "Report":
+		t.Value.Report = AgencyReport(AgencyReportEquifaxReport{})
+		return nil
+	default:
+		return fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/internal.CreditReport", name)
+	}
+}
 func (t *CreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *CreditReportTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = CreditReport{
-		Report: AgencyReportEquifaxReport{},
-	}
-	return nil
-}
 
 type Customer struct {
 	Name    string
@@ -917,108 +931,103 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.Name == "")
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	var4 := (m.Name == "")
+	if var4 {
+		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 			if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
-			return err
-		}
-	}
-	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Id")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var7 := (m.Id == int64(0))
-		if var7 {
-			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var7 := (m.Id == int64(0))
+	if var7 {
+		if err := fieldsTarget1.ZeroField("Id"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Id")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 			if err := fieldTarget6.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
-			return err
-		}
-	}
-	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Active")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var10 := (m.Active == false)
-		if var10 {
-			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var10 := (m.Active == false)
+	if var10 {
+		if err := fieldsTarget1.ZeroField("Active"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Active")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 			if err := fieldTarget9.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
-			return err
-		}
-	}
-	keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Address")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var13 := (m.Address == AddressInfo{})
-		if var13 {
-			if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var13 := (m.Address == AddressInfo{})
+	if var13 {
+		if err := fieldsTarget1.ZeroField("Address"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Address")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 
 			if err := m.Address.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
-			return err
-		}
-	}
-	keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Credit")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var16 := (m.Credit == CreditReport{
-			Report: AgencyReportEquifaxReport{},
-		})
-		if var16 {
-			if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	var16 := (m.Credit == CreditReport{
+		Report: AgencyReportEquifaxReport{},
+	})
+	if var16 {
+		if err := fieldsTarget1.ZeroField("Credit"); err != nil && err != vdl.ErrFieldNoExist {
+			return err
+		}
+	} else {
+		keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Credit")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
+				return err
+			}
 
 			if err := m.Credit.FillVDLTarget(fieldTarget15, tt.NonOptional().Field(4).Type); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
-			return err
+			if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -1078,18 +1087,33 @@
 func (t *CustomerTarget) FinishField(_, _ vdl.Target) error {
 	return nil
 }
+func (t *CustomerTarget) ZeroField(name string) error {
+	switch name {
+	case "Name":
+		t.Value.Name = ""
+		return nil
+	case "Id":
+		t.Value.Id = int64(0)
+		return nil
+	case "Active":
+		t.Value.Active = false
+		return nil
+	case "Address":
+		t.Value.Address = AddressInfo{}
+		return nil
+	case "Credit":
+		t.Value.Credit = CreditReport{
+			Report: AgencyReportEquifaxReport{},
+		}
+		return nil
+	default:
+		return fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/internal.Customer", name)
+	}
+}
 func (t *CustomerTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *CustomerTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = Customer{
-		Credit: CreditReport{
-			Report: AgencyReportEquifaxReport{},
-		},
-	}
-	return nil
-}
 
 var __VDLInitCalled bool
 
diff --git a/go/src/v.io/x/mojo/transcoder/target.go b/go/src/v.io/x/mojo/transcoder/target.go
index 1d45b19..23b4066 100644
--- a/go/src/v.io/x/mojo/transcoder/target.go
+++ b/go/src/v.io/x/mojo/transcoder/target.go
@@ -93,7 +93,13 @@
 	panic("UNIMPLEMENTED")
 
 }
-func (t target) FromZero(tt *vdl.Type) error {
+func (t target) FromNil(tt *vdl.Type) error {
+	if tt.Kind() == vdl.Optional || tt.Kind() == vdl.Any {
+		return t.fromZero(tt)
+	}
+	return fmt.Errorf("FromNil called on non-nillable type")
+}
+func (t target) fromZero(tt *vdl.Type) error {
 	if tt.IsBytes() {
 		return t.FromBytes(nil, tt)
 	}
@@ -139,7 +145,7 @@
 			if err != nil {
 				return err
 			}
-			if err := targ.FromZero(tt.Elem()); err != nil {
+			if err := targ.(target).fromZero(tt.Elem()); err != nil {
 				return err
 			}
 			if err := lt.FinishElem(targ); err != nil {
@@ -170,7 +176,7 @@
 			if err != nil {
 				return err
 			}
-			if err := ft.FromZero(fld.Type); err != nil {
+			if err := ft.(target).fromZero(fld.Type); err != nil {
 				return err
 			}
 			if err := st.FinishField(kt, ft); err != nil {
@@ -188,7 +194,7 @@
 		if err != nil {
 			return err
 		}
-		if err := ft.FromZero(fld.Type); err != nil {
+		if err := ft.(target).fromZero(fld.Type); err != nil {
 			return err
 		}
 		if err := st.FinishField(kt, ft); err != nil {
diff --git a/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go b/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go
index 3836112..fae9534 100644
--- a/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go
+++ b/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go
@@ -96,10 +96,6 @@
 
 	return nil
 }
-func (t *AnEnumTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = AnEnumFirst
-	return nil
-}
 
 type (
 	// PodUnion represents any single field of the PodUnion union type.
@@ -663,10 +659,6 @@
 
 	return nil
 }
-func (t *PodUnionTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = PodUnion(PodUnionFInt8{})
-	return nil
-}
 
 type podUnionTargetFactory struct{}
 
@@ -691,23 +683,22 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("PodUnion")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
+	var var4 bool
+	if field, ok := m.PodUnion.(PodUnionFInt8); ok {
+
+		var5 := (field.Value == int8(0))
+		var4 = var5
 	}
-	if err != vdl.ErrFieldNoExist {
-
-		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
 		}
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("PodUnion")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 
 			unionValue6 := m.PodUnion
 			if unionValue6 == nil {
@@ -716,9 +707,9 @@
 			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 := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -758,16 +749,19 @@
 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 fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/testtypes.PodUnionWrapper", name)
+	}
+}
 func (t *PodUnionWrapperTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *PodUnionWrapperTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = PodUnionWrapper{
-		PodUnion: PodUnionFInt8{},
-	}
-	return nil
-}
 
 type DummyStruct struct {
 	FInt8 int8
@@ -783,24 +777,23 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt8")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.FInt8 == int8(0))
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	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
 			}
-		} else {
 			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 := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -840,14 +833,19 @@
 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 fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/testtypes.DummyStruct", name)
+	}
+}
 func (t *DummyStructTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *DummyStructTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = DummyStruct{}
-	return nil
-}
 
 type (
 	// ObjectUnion represents any single field of the ObjectUnion union type.
@@ -1224,10 +1222,6 @@
 
 	return nil
 }
-func (t *ObjectUnionTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = ObjectUnion(ObjectUnionFInt8{})
-	return nil
-}
 
 type objectUnionTargetFactory struct{}
 
@@ -1262,7 +1256,7 @@
 
 	return nil
 }
-func (t *__VDLTarget1_optional) FromZero(tt *vdl.Type) error {
+func (t *__VDLTarget1_optional) FromNil(tt *vdl.Type) error {
 	*t.Value = (*DummyStruct)(nil)
 	return nil
 }
@@ -1299,10 +1293,6 @@
 
 	return nil
 }
-func (t *__VDLTarget2_list) FromZero(tt *vdl.Type) error {
-	*t.Value = []int8(nil)
-	return nil
-}
 
 // map[string]int8
 type __VDLTarget3_map struct {
@@ -1346,10 +1336,6 @@
 
 	return nil
 }
-func (t *__VDLTarget3_map) FromZero(tt *vdl.Type) error {
-	*t.Value = map[string]int8(nil)
-	return nil
-}
 
 type ObjectUnionWrapper struct {
 	ObjectUnion ObjectUnion
@@ -1365,23 +1351,22 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ObjectUnion")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
+	var var4 bool
+	if field, ok := m.ObjectUnion.(ObjectUnionFInt8); ok {
+
+		var5 := (field.Value == int8(0))
+		var4 = var5
 	}
-	if err != vdl.ErrFieldNoExist {
-
-		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
 		}
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	} else {
+		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ObjectUnion")
+		if err != vdl.ErrFieldNoExist {
+			if err != nil {
 				return err
 			}
-		} else {
 
 			unionValue6 := m.ObjectUnion
 			if unionValue6 == nil {
@@ -1390,9 +1375,9 @@
 			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 := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -1432,16 +1417,19 @@
 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 fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/testtypes.ObjectUnionWrapper", name)
+	}
+}
 func (t *ObjectUnionWrapperTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *ObjectUnionWrapperTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = ObjectUnionWrapper{
-		ObjectUnion: ObjectUnionFInt8{},
-	}
-	return nil
-}
 
 type Rect struct {
 	X      int32
@@ -1460,84 +1448,80 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("X")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.X == int32(0))
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	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
 			}
-		} else {
 			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
-		}
-	}
-	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Y")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var7 := (m.Y == int32(0))
-		if var7 {
-			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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
-		}
-	}
-	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Width")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var10 := (m.Width == int32(0))
-		if var10 {
-			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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
-		}
-	}
-	keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Height")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var13 := (m.Height == int32(0))
-		if var13 {
-			if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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 := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -1592,14 +1576,28 @@
 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 fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/testtypes.Rect", name)
+	}
+}
 func (t *RectTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *RectTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = Rect{}
-	return nil
-}
 
 type MultiVersionStruct struct {
 	FInt32  int32
@@ -1620,82 +1618,78 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt32")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.FInt32 == int32(0))
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	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
 			}
-		} else {
 			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
-		}
-	}
-	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FRect")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var7 := (m.FRect == Rect{})
-		if var7 {
-			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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
-		}
-	}
-	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("FString")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var10 := (m.FString == "")
-		if var10 {
-			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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
-		}
-	}
-	keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("FArray")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var var13 bool
-		if len(m.FArray) == 0 {
-			var13 = true
-		}
-		if var13 {
-			if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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 {
@@ -1716,49 +1710,47 @@
 			if err := fieldTarget12.FinishList(listTarget14); err != nil {
 				return err
 			}
-		}
-		if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
-			return err
-		}
-	}
-	keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("FBool")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var19 := (m.FBool == false)
-		if var19 {
-			if err := fieldTarget18.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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
-		}
-	}
-	keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("FInt16")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var22 := (m.FInt16 == int16(0))
-		if var22 {
-			if err := fieldTarget21.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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 := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -1823,14 +1815,34 @@
 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 fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/testtypes.MultiVersionStruct", name)
+	}
+}
 func (t *MultiVersionStructTarget) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *MultiVersionStructTarget) FromZero(tt *vdl.Type) error {
-	*t.Value = MultiVersionStruct{}
-	return nil
-}
 
 type MultiVersionStructV3 struct {
 	FInt32  int32
@@ -1848,65 +1860,62 @@
 	if err != nil {
 		return err
 	}
-	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("FInt32")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var4 := (m.FInt32 == int32(0))
-		if var4 {
-			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+	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
 			}
-		} else {
 			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
-		}
-	}
-	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FRect")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var7 := (m.FRect == Rect{})
-		if var7 {
-			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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
-		}
-	}
-	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("FString")
-	if err != vdl.ErrFieldNoExist && err != nil {
-		return err
-	}
-	if err != vdl.ErrFieldNoExist {
-
-		var10 := (m.FString == "")
-		if var10 {
-			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
 				return err
 			}
-		} else {
+		}
+	}
+	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 := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
+				return err
+			}
 		}
 	}
 	if err := t.FinishFields(fieldsTarget1); err != nil {
@@ -1956,14 +1965,25 @@
 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 fmt.Errorf("field %s not in struct src/v.io/x/mojo/transcoder/testtypes.MultiVersionStructV3", name)
+	}
+}
 func (t *MultiVersionStructV3Target) FinishFields(_ vdl.FieldsTarget) error {
 
 	return nil
 }
-func (t *MultiVersionStructV3Target) FromZero(tt *vdl.Type) error {
-	*t.Value = MultiVersionStructV3{}
-	return nil
-}
 
 var __VDLInitCalled bool
 
diff --git a/go/src/v.io/x/mojo/transcoder/to_mojom.go b/go/src/v.io/x/mojo/transcoder/to_mojom.go
index 73196de..677d9de 100644
--- a/go/src/v.io/x/mojo/transcoder/to_mojom.go
+++ b/go/src/v.io/x/mojo/transcoder/to_mojom.go
@@ -59,29 +59,6 @@
 func (vtm *targetToMojomTranscoder) FromTypeObject(src *vdl.Type) error {
 	panic("cannot encode top level type object")
 }
-func (vtm *targetToMojomTranscoder) FromZero(tt *vdl.Type) error {
-	if tt.Kind() == vdl.Struct {
-		st, err := vtm.StartFields(tt)
-		if err != nil {
-			return err
-		}
-		for i := 0; i < tt.NumField(); i++ {
-			fld := tt.Field(i)
-			kt, ft, err := st.StartField(fld.Name)
-			if err != nil {
-				return err
-			}
-			if err := ft.FromZero(fld.Type); err != nil {
-				return err
-			}
-			if err := st.FinishField(kt, ft); err != nil {
-				return err
-			}
-		}
-		return vtm.FinishFields(st)
-	}
-	panic("UNIMPLEMENTED")
-}
 
 func (vtm *targetToMojomTranscoder) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
 	panic("UNIMPLEMENTED")
@@ -117,3 +94,7 @@
 func (vtm *targetToMojomTranscoder) FinishFields(x vdl.FieldsTarget) error {
 	return nil
 }
+
+func (vtm *targetToMojomTranscoder) FromNil(tt *vdl.Type) error {
+	panic("UNIMPLEMENTED")
+}
diff --git a/go/src/v.io/x/mojo/transcoder/typed_targets.go b/go/src/v.io/x/mojo/transcoder/typed_targets.go
index 6d209f3..8813e1b 100644
--- a/go/src/v.io/x/mojo/transcoder/typed_targets.go
+++ b/go/src/v.io/x/mojo/transcoder/typed_targets.go
@@ -32,6 +32,20 @@
 func (fieldsTarget) FinishField(key, field vdl.Target) error {
 	return nil
 }
+func (fe fieldsTarget) ZeroField(name string) error {
+	key, field, err := fe.StartField(name)
+	if err != nil {
+		return err
+	}
+	fld, index := fe.vdlType.FieldByName(name)
+	if index < 0 {
+		return vdl.ErrFieldNoExist
+	}
+	if err := field.(target).fromZero(fld.Type); err != nil {
+		return err
+	}
+	return fe.FinishField(key, field)
+}
 
 type unionFieldsTarget struct {
 	vdlType *vdl.Type
@@ -62,6 +76,20 @@
 func (unionFieldsTarget) FinishField(key, field vdl.Target) error {
 	return nil
 }
+func (ufe unionFieldsTarget) ZeroField(name string) error {
+	key, field, err := ufe.StartField(name)
+	if err != nil {
+		return err
+	}
+	fld, index := ufe.vdlType.FieldByName(name)
+	if index < 0 {
+		return vdl.ErrFieldNoExist
+	}
+	if err := field.(target).fromZero(fld.Type); err != nil {
+		return err
+	}
+	return ufe.FinishField(key, field)
+}
 
 // doubles as set target
 type listTarget struct {