vendor: update all dependencies

vendor/cloud.google.com/go/datastore/save.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"reflect"
 	"time"
+	"unicode/utf8"
 
 	timepb "github.com/golang/protobuf/ptypes/timestamp"
 	pb "google.golang.org/genproto/googleapis/datastore/v1"
@@ -57,8 +58,15 @@ func saveStructProperty(props *[]Property, name string, opts saveOpts, v reflect
 		return nil
 	}
 
-	// Check if v implements PropertyLoadSaver.
-	pls, isPLS := v.Interface().(PropertyLoadSaver)
+	// First check if field type implements PLS. If so, use PLS to
+	// save.
+	ok, err := plsFieldSave(props, p, name, opts, v)
+	if err != nil {
+		return err
+	}
+	if ok {
+		return nil
+	}
 
 	switch x := v.Interface().(type) {
 	case *Key, time.Time, GeoPoint:
@@ -89,19 +97,12 @@ func saveStructProperty(props *[]Property, name string, opts saveOpts, v reflect
 			v = v.Elem()
 			fallthrough
 		case reflect.Struct:
-			if isPLS {
-				subProps, err := pls.Save()
-				if err != nil {
-					return err
-				}
-				p.Value = &Entity{Properties: subProps}
-				break
-			}
-
 			if !v.CanAddr() {
 				return fmt.Errorf("datastore: unsupported struct field: value is unaddressable")
 			}
-			sub, err := newStructPLS(v.Addr().Interface())
+			vi := v.Addr().Interface()
+
+			sub, err := newStructPLS(vi)
 			if err != nil {
 				return fmt.Errorf("datastore: unsupported struct field: %v", err)
 			}
@@ -133,6 +134,44 @@ func saveStructProperty(props *[]Property, name string, opts saveOpts, v reflect
 	return nil
 }
 
+// plsFieldSave first tries to converts v's value to a PLS, then v's addressed
+// value to a PLS. If neither succeeds, plsFieldSave returns false for first return
+// value.
+// If v is successfully converted to a PLS, plsFieldSave will then add the
+// Value to property p by way of the PLS's Save method, and append it to props.
+//
+// If the flatten option is present in opts, name must be prepended to each property's
+// name before it is appended to props. Eg. if name were "A" and a subproperty's name
+// were "B", the resultant name of the property to be appended to props would be "A.B".
+func plsFieldSave(props *[]Property, p Property, name string, opts saveOpts, v reflect.Value) (ok bool, err error) {
+	vpls, err := plsForSave(v)
+	if err != nil {
+		return false, err
+	}
+
+	if vpls == nil {
+		return false, nil
+	}
+
+	subProps, err := vpls.Save()
+	if err != nil {
+		return true, err
+	}
+
+	if opts.flatten {
+		for _, subp := range subProps {
+			subp.Name = name + "." + subp.Name
+			*props = append(*props, subp)
+		}
+		return true, nil
+	}
+
+	p.Value = &Entity{Properties: subProps}
+	*props = append(*props, p)
+
+	return true, nil
+}
+
 // key extracts the *Key struct field from struct v based on the structCodec of s.
 func (s structPLS) key(v reflect.Value) (*Key, error) {
 	if v.Kind() != reflect.Struct {
@@ -290,33 +329,36 @@ func interfaceToProto(iv interface{}, noIndex bool) (*pb.Value, error) {
 	val := &pb.Value{ExcludeFromIndexes: noIndex}
 	switch v := iv.(type) {
 	case int:
-		val.ValueType = &pb.Value_IntegerValue{int64(v)}
+		val.ValueType = &pb.Value_IntegerValue{IntegerValue: int64(v)}
 	case int32:
-		val.ValueType = &pb.Value_IntegerValue{int64(v)}
+		val.ValueType = &pb.Value_IntegerValue{IntegerValue: int64(v)}
 	case int64:
-		val.ValueType = &pb.Value_IntegerValue{v}
+		val.ValueType = &pb.Value_IntegerValue{IntegerValue: v}
 	case bool:
-		val.ValueType = &pb.Value_BooleanValue{v}
+		val.ValueType = &pb.Value_BooleanValue{BooleanValue: v}
 	case string:
 		if len(v) > 1500 && !noIndex {
 			return nil, errors.New("string property too long to index")
 		}
-		val.ValueType = &pb.Value_StringValue{v}
+		if !utf8.ValidString(v) {
+			return nil, fmt.Errorf("string is not valid utf8: %q", v)
+		}
+		val.ValueType = &pb.Value_StringValue{StringValue: v}
 	case float32:
-		val.ValueType = &pb.Value_DoubleValue{float64(v)}
+		val.ValueType = &pb.Value_DoubleValue{DoubleValue: float64(v)}
 	case float64:
-		val.ValueType = &pb.Value_DoubleValue{v}
+		val.ValueType = &pb.Value_DoubleValue{DoubleValue: v}
 	case *Key:
 		if v == nil {
 			val.ValueType = &pb.Value_NullValue{}
 		} else {
-			val.ValueType = &pb.Value_KeyValue{keyToProto(v)}
+			val.ValueType = &pb.Value_KeyValue{KeyValue: keyToProto(v)}
 		}
 	case GeoPoint:
 		if !v.Valid() {
 			return nil, errors.New("invalid GeoPoint value")
 		}
-		val.ValueType = &pb.Value_GeoPointValue{&llpb.LatLng{
+		val.ValueType = &pb.Value_GeoPointValue{GeoPointValue: &llpb.LatLng{
 			Latitude:  v.Lat,
 			Longitude: v.Lng,
 		}}
@@ -324,7 +366,7 @@ func interfaceToProto(iv interface{}, noIndex bool) (*pb.Value, error) {
 		if v.Before(minTime) || v.After(maxTime) {
 			return nil, errors.New("time value out of range")
 		}
-		val.ValueType = &pb.Value_TimestampValue{&timepb.Timestamp{
+		val.ValueType = &pb.Value_TimestampValue{TimestampValue: &timepb.Timestamp{
 			Seconds: v.Unix(),
 			Nanos:   int32(v.Nanosecond()),
 		}}
@@ -332,13 +374,13 @@ func interfaceToProto(iv interface{}, noIndex bool) (*pb.Value, error) {
 		if len(v) > 1500 && !noIndex {
 			return nil, errors.New("[]byte property too long to index")
 		}
-		val.ValueType = &pb.Value_BlobValue{v}
+		val.ValueType = &pb.Value_BlobValue{BlobValue: v}
 	case *Entity:
 		e, err := propertiesToProto(v.Key, v.Properties)
 		if err != nil {
 			return nil, err
 		}
-		val.ValueType = &pb.Value_EntityValue{e}
+		val.ValueType = &pb.Value_EntityValue{EntityValue: e}
 	case []interface{}:
 		arr := make([]*pb.Value, 0, len(v))
 		for i, v := range v {
@@ -348,7 +390,7 @@ func interfaceToProto(iv interface{}, noIndex bool) (*pb.Value, error) {
 			}
 			arr = append(arr, elem)
 		}
-		val.ValueType = &pb.Value_ArrayValue{&pb.ArrayValue{arr}}
+		val.ValueType = &pb.Value_ArrayValue{ArrayValue: &pb.ArrayValue{Values: arr}}
 		// ArrayValues have ExcludeFromIndexes set on the individual items, rather
 		// than the top-level value.
 		val.ExcludeFromIndexes = false