Updated to current weekly.

decode.go

@@ -235,7 +235,7 @@ func (d *decoder) setter(tag string, out *reflect.Value, good *bool) (set func()
 		if tag != "!!null" || setter != nil {
 			if pv := (*out); pv.Kind() == reflect.Ptr {
 				if pv.IsNil() {
-					*out = reflect.Zero(pv.Type().Elem())
+					*out = reflect.New(pv.Type().Elem()).Elem()
 					pv.Set((*out).Addr())
 				} else {
 					*out = pv.Elem()
@@ -246,7 +246,7 @@ func (d *decoder) setter(tag string, out *reflect.Value, good *bool) (set func()
 		}
 		if setter != nil {
 			var arg interface{}
-			*out = reflect.NewValue(&arg).Elem()
+			*out = reflect.ValueOf(&arg).Elem()
 			return func() {
 				*good = setter.SetYAML(tag, arg)
 			}
@@ -315,7 +315,7 @@ func (d *decoder) scalar(n *node, out reflect.Value) (good bool) {
 		if resolved == nil {
 			out.Set(reflect.Zero(out.Type()))
 		} else {
-			out.Set(reflect.NewValue(resolved))
+			out.Set(reflect.ValueOf(resolved))
 		}
 		good = true
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
@@ -368,6 +368,13 @@ func (d *decoder) scalar(n *node, out reflect.Value) (good bool) {
 	return good
 }
 
+func settableValueOf(i interface{}) reflect.Value {
+	v := reflect.ValueOf(i)
+	sv := reflect.New(v.Type()).Elem()
+	sv.Set(v)
+	return sv
+}
+
 func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
 	if set := d.setter("!!seq", &out, &good); set != nil {
 		defer set()
@@ -375,7 +382,7 @@ func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
 	if out.Kind() == reflect.Interface {
 		// No type hints. Will have to use a generic sequence.
 		iface := out
-		out = reflect.NewValue(make([]interface{}, 0))
+		out = settableValueOf(make([]interface{}, 0))
 		iface.Set(out)
 	}
 
@@ -386,7 +393,7 @@ func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
 
 	l := len(n.children)
 	for i := 0; i < l; i++ {
-		e := reflect.Zero(et)
+		e := reflect.New(et).Elem()
 		if ok := d.unmarshal(n.children[i], e); ok {
 			out.Set(reflect.Append(out, e))
 		}
@@ -405,7 +412,7 @@ func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
 	if out.Kind() == reflect.Interface {
 		// No type hints. Will have to use a generic map.
 		iface := out
-		out = reflect.NewValue(make(map[interface{}]interface{}))
+		out = settableValueOf(make(map[interface{}]interface{}))
 		iface.Set(out)
 	}
 
@@ -418,9 +425,9 @@ func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
 
 	l := len(n.children)
 	for i := 0; i < l; i += 2 {
-		k := reflect.Zero(kt)
+		k := reflect.New(kt).Elem()
 		if d.unmarshal(n.children[i], k) {
-			e := reflect.Zero(et)
+			e := reflect.New(et).Elem()
 			if d.unmarshal(n.children[i+1], e) {
 				out.SetMapIndex(k, e)
 			}
@@ -434,7 +441,7 @@ func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
 	if err != nil {
 		panic(err)
 	}
-	name := reflect.NewValue("")
+	name := settableValueOf("")
 	fieldsMap := fields.Map
 	l := len(n.children)
 	for i := 0; i < l; i += 2 {

decode_test.go

@@ -134,14 +134,13 @@ var unmarshalTests = []struct {
 
 func (s *S) TestUnmarshal(c *C) {
 	for i, item := range unmarshalTests {
-		t := reflect.NewValue(item.value).Type()
+		t := reflect.ValueOf(item.value).Type()
 		var value interface{}
 		if t.Kind() == reflect.Map {
 			value = reflect.MakeMap(t).Interface()
 		} else {
-			pt := reflect.NewValue(item.value).Type()
-			pv := reflect.Zero(pt)
-			pv.Set(reflect.Zero(pt.Elem()).Addr())
+			pt := reflect.ValueOf(item.value).Type()
+			pv := reflect.New(pt.Elem())
 			value = pv.Interface()
 		}
 		err := goyaml.Unmarshal([]byte(item.data), value)
@@ -153,8 +152,7 @@ func (s *S) TestUnmarshal(c *C) {
 var unmarshalErrorTests = []struct {
 	data, error string
 }{
-	{"v: !!float 'error'",
-		"YAML error: Can't decode !!str 'error' as a !!float"},
+	{"v: !!float 'error'", "YAML error: Can't decode !!str 'error' as a !!float"},
 	{"v: [A,", "YAML error: line 1: did not find expected node content"},
 	{"v:\n- [A,", "YAML error: line 2: did not find expected node content"},
 	{"a: *b\n", "YAML error: Unknown anchor 'b' referenced"},

encode.go

@@ -90,7 +90,7 @@ func (e *encoder) marshal(tag string, in reflect.Value) {
 			e.nilv()
 			return
 		}
-		in = reflect.NewValue(value)
+		in = reflect.ValueOf(value)
 	}
 	switch in.Kind() {
 	case reflect.Interface:
@@ -146,7 +146,7 @@ func (e *encoder) structv(tag string, in reflect.Value) {
 			if info.Conditional && isZero(value) {
 				continue
 			}
-			e.marshal("", reflect.NewValue(info.Key))
+			e.marshal("", reflect.ValueOf(info.Key))
 			e.flow = info.Flow
 			e.marshal("", value)
 		}

goyaml.go

@@ -88,7 +88,7 @@ func Unmarshal(in []byte, out interface{}) (err os.Error) {
 	defer p.destroy()
 	node := p.parse()
 	if node != nil {
-		d.unmarshal(node, reflect.NewValue(out))
+		d.unmarshal(node, reflect.ValueOf(out))
 	}
 	return nil
 }
@@ -119,7 +119,7 @@ func Marshal(in interface{}) (out []byte, err os.Error) {
 	defer handleErr(&err)
 	e := newEncoder()
 	defer e.destroy()
-	e.marshal("", reflect.NewValue(in))
+	e.marshal("", reflect.ValueOf(in))
 	e.finish()
 	out = e.out
 	return