all: use typed variant of protoreflect.ValueOf
Change-Id: I7479632b57e7c8efade12a2eb2b855e9c321adb1
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/196037
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/internal/encoding/defval/default.go b/internal/encoding/defval/default.go
index 7cde945..c1d81a1 100644
--- a/internal/encoding/defval/default.go
+++ b/internal/encoding/defval/default.go
@@ -41,16 +41,16 @@
if f == GoTag {
switch s {
case "1":
- return pref.ValueOf(true), nil, nil
+ return pref.ValueOfBool(true), nil, nil
case "0":
- return pref.ValueOf(false), nil, nil
+ return pref.ValueOfBool(false), nil, nil
}
} else {
switch s {
case "true":
- return pref.ValueOf(true), nil, nil
+ return pref.ValueOfBool(true), nil, nil
case "false":
- return pref.ValueOf(false), nil, nil
+ return pref.ValueOfBool(false), nil, nil
}
}
case pref.EnumKind:
@@ -58,31 +58,31 @@
// Go tags use the numeric form of the enum value.
if n, err := strconv.ParseInt(s, 10, 32); err == nil {
if ev := evs.ByNumber(pref.EnumNumber(n)); ev != nil {
- return pref.ValueOf(ev.Number()), ev, nil
+ return pref.ValueOfEnum(ev.Number()), ev, nil
}
}
} else {
// Descriptor default_value use the enum identifier.
ev := evs.ByName(pref.Name(s))
if ev != nil {
- return pref.ValueOf(ev.Number()), ev, nil
+ return pref.ValueOfEnum(ev.Number()), ev, nil
}
}
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
if v, err := strconv.ParseInt(s, 10, 32); err == nil {
- return pref.ValueOf(int32(v)), nil, nil
+ return pref.ValueOfInt32(int32(v)), nil, nil
}
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
if v, err := strconv.ParseInt(s, 10, 64); err == nil {
- return pref.ValueOf(int64(v)), nil, nil
+ return pref.ValueOfInt64(int64(v)), nil, nil
}
case pref.Uint32Kind, pref.Fixed32Kind:
if v, err := strconv.ParseUint(s, 10, 32); err == nil {
- return pref.ValueOf(uint32(v)), nil, nil
+ return pref.ValueOfUint32(uint32(v)), nil, nil
}
case pref.Uint64Kind, pref.Fixed64Kind:
if v, err := strconv.ParseUint(s, 10, 64); err == nil {
- return pref.ValueOf(uint64(v)), nil, nil
+ return pref.ValueOfUint64(uint64(v)), nil, nil
}
case pref.FloatKind, pref.DoubleKind:
var v float64
@@ -99,17 +99,17 @@
}
if err == nil {
if k == pref.FloatKind {
- return pref.ValueOf(float32(v)), nil, nil
+ return pref.ValueOfFloat32(float32(v)), nil, nil
} else {
- return pref.ValueOf(float64(v)), nil, nil
+ return pref.ValueOfFloat64(float64(v)), nil, nil
}
}
case pref.StringKind:
// String values are already unescaped and can be used as is.
- return pref.ValueOf(s), nil, nil
+ return pref.ValueOfString(s), nil, nil
case pref.BytesKind:
if b, ok := unmarshalBytes(s); ok {
- return pref.ValueOf(b), nil, nil
+ return pref.ValueOfBytes(b), nil, nil
}
}
return pref.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
diff --git a/internal/filedesc/desc.go b/internal/filedesc/desc.go
index 51ef7c1..72a45e2 100644
--- a/internal/filedesc/desc.go
+++ b/internal/filedesc/desc.go
@@ -533,7 +533,7 @@
// If we are unable to resolve the enum dependency, use a placeholder
// enum value since we will not be able to parse the default value.
if ed.IsPlaceholder() && pref.Name(b).IsValid() {
- v := pref.ValueOf(pref.EnumNumber(0))
+ v := pref.ValueOfEnum(0)
ev := PlaceholderEnumValue(ed.FullName().Parent().Append(pref.Name(b)))
return DefaultValue(v, ev)
}
@@ -561,28 +561,28 @@
}
switch fd.Kind() {
case pref.BoolKind:
- return pref.ValueOf(false)
+ return pref.ValueOfBool(false)
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
- return pref.ValueOf(int32(0))
+ return pref.ValueOfInt32(0)
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- return pref.ValueOf(int64(0))
+ return pref.ValueOfInt64(0)
case pref.Uint32Kind, pref.Fixed32Kind:
- return pref.ValueOf(uint32(0))
+ return pref.ValueOfUint32(0)
case pref.Uint64Kind, pref.Fixed64Kind:
- return pref.ValueOf(uint64(0))
+ return pref.ValueOfUint64(0)
case pref.FloatKind:
- return pref.ValueOf(float32(0))
+ return pref.ValueOfFloat32(0)
case pref.DoubleKind:
- return pref.ValueOf(float64(0))
+ return pref.ValueOfFloat64(0)
case pref.StringKind:
- return pref.ValueOf(string(""))
+ return pref.ValueOfString("")
case pref.BytesKind:
- return pref.ValueOf([]byte(nil))
+ return pref.ValueOfBytes(nil)
case pref.EnumKind:
if evs := fd.Enum().Values(); evs.Len() > 0 {
- return pref.ValueOf(evs.Get(0).Number())
+ return pref.ValueOfEnum(evs.Get(0).Number())
}
- return pref.ValueOf(pref.EnumNumber(0))
+ return pref.ValueOfEnum(0)
}
}
diff --git a/internal/filedesc/desc_lazy.go b/internal/filedesc/desc_lazy.go
index b989092..86720a0 100644
--- a/internal/filedesc/desc_lazy.go
+++ b/internal/filedesc/desc_lazy.go
@@ -451,7 +451,7 @@
case fieldnum.FieldDescriptorProto_JsonName:
fd.L1.JSONName = JSONName(sb.MakeString(v))
case fieldnum.FieldDescriptorProto_DefaultValue:
- fd.L1.Default.val = pref.ValueOf(v) // temporarily store as bytes; later resolved in resolveMessages
+ fd.L1.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
case fieldnum.FieldDescriptorProto_TypeName:
rawTypeName = v
case fieldnum.FieldDescriptorProto_Options:
@@ -544,7 +544,7 @@
case fieldnum.FieldDescriptorProto_JsonName:
xd.L2.JSONName = JSONName(sb.MakeString(v))
case fieldnum.FieldDescriptorProto_DefaultValue:
- xd.L2.Default.val = pref.ValueOf(v) // temporarily store as bytes; later resolved in resolveExtensions
+ xd.L2.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
case fieldnum.FieldDescriptorProto_TypeName:
rawTypeName = v
case fieldnum.FieldDescriptorProto_Options:
diff --git a/internal/impl/convert.go b/internal/impl/convert.go
index 67cd7f8..5fdb022 100644
--- a/internal/impl/convert.go
+++ b/internal/impl/convert.go
@@ -76,15 +76,15 @@
)
var (
- boolZero = pref.ValueOf(bool(false))
- int32Zero = pref.ValueOf(int32(0))
- int64Zero = pref.ValueOf(int64(0))
- uint32Zero = pref.ValueOf(uint32(0))
- uint64Zero = pref.ValueOf(uint64(0))
- float32Zero = pref.ValueOf(float32(0))
- float64Zero = pref.ValueOf(float64(0))
- stringZero = pref.ValueOf(string(""))
- bytesZero = pref.ValueOf([]byte(nil))
+ boolZero = pref.ValueOfBool(false)
+ int32Zero = pref.ValueOfInt32(0)
+ int64Zero = pref.ValueOfInt64(0)
+ uint32Zero = pref.ValueOfUint32(0)
+ uint64Zero = pref.ValueOfUint64(0)
+ float32Zero = pref.ValueOfFloat32(0)
+ float64Zero = pref.ValueOfFloat64(0)
+ stringZero = pref.ValueOfString("")
+ bytesZero = pref.ValueOfBytes(nil)
)
func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
@@ -376,7 +376,7 @@
func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter {
var def pref.Value
if fd.Cardinality() == pref.Repeated {
- def = pref.ValueOf(fd.Enum().Values().Get(0).Number())
+ def = pref.ValueOfEnum(fd.Enum().Values().Get(0).Number())
} else {
def = fd.Default()
}
@@ -387,7 +387,7 @@
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
- return pref.ValueOf(pref.EnumNumber(v.Int()))
+ return pref.ValueOfEnum(pref.EnumNumber(v.Int()))
}
func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value {
@@ -424,9 +424,9 @@
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
if m, ok := v.Interface().(pref.ProtoMessage); ok {
- return pref.ValueOf(m.ProtoReflect())
+ return pref.ValueOfMessage(m.ProtoReflect())
}
- return pref.ValueOf(legacyWrapMessage(v).ProtoReflect())
+ return pref.ValueOfMessage(legacyWrapMessage(v).ProtoReflect())
}
func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
diff --git a/internal/impl/convert_list.go b/internal/impl/convert_list.go
index 222f1a4..d17676b 100644
--- a/internal/impl/convert_list.go
+++ b/internal/impl/convert_list.go
@@ -32,7 +32,7 @@
}
pv := reflect.New(c.goType)
pv.Elem().Set(v)
- return pref.ValueOf(&listReflect{pv, c.c})
+ return pref.ValueOfList(&listReflect{pv, c.c})
}
func (c *listConverter) GoValueOf(v pref.Value) reflect.Value {
@@ -56,11 +56,11 @@
}
func (c *listConverter) New() pref.Value {
- return pref.ValueOf(&listReflect{reflect.New(c.goType), c.c})
+ return pref.ValueOfList(&listReflect{reflect.New(c.goType), c.c})
}
func (c *listConverter) Zero() pref.Value {
- return pref.ValueOf(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
+ return pref.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
}
type listPtrConverter struct {
@@ -72,7 +72,7 @@
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
- return pref.ValueOf(&listReflect{v, c.c})
+ return pref.ValueOfList(&listReflect{v, c.c})
}
func (c *listPtrConverter) GoValueOf(v pref.Value) reflect.Value {
diff --git a/internal/impl/convert_map.go b/internal/impl/convert_map.go
index 47b5f22..2ddfc78 100644
--- a/internal/impl/convert_map.go
+++ b/internal/impl/convert_map.go
@@ -31,7 +31,7 @@
if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
}
- return pref.ValueOf(&mapReflect{v, c.keyConv, c.valConv})
+ return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
}
func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
diff --git a/internal/impl/legacy_message.go b/internal/impl/legacy_message.go
index 6c52284..de03ee6 100644
--- a/internal/impl/legacy_message.go
+++ b/internal/impl/legacy_message.go
@@ -236,10 +236,10 @@
fd.L1.Options = func() pref.ProtoMessage {
opts := descopts.Field.ProtoReflect().New()
if fd.L1.IsWeak {
- opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOf(true))
+ opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true))
}
if fd.L1.HasPacked {
- opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOf(fd.L1.IsPacked))
+ opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOfBool(fd.L1.IsPacked))
}
return opts.Interface()
}
@@ -273,7 +273,7 @@
md2.L2.IsMapEntry = true
md2.L2.Options = func() pref.ProtoMessage {
opts := descopts.Message.ProtoReflect().New()
- opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOf(true))
+ opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true))
return opts.Interface()
}
diff --git a/internal/impl/message_reflect_field.go b/internal/impl/message_reflect_field.go
index e55b6de..e384aa3 100644
--- a/internal/impl/message_reflect_field.go
+++ b/internal/impl/message_reflect_field.go
@@ -99,7 +99,7 @@
}
rv = rv.Elem().Elem().Field(0)
if rv.IsNil() {
- rv.Set(conv.GoValueOf(pref.ValueOf(conv.New().Message())))
+ rv.Set(conv.GoValueOf(pref.ValueOfMessage(conv.New().Message())))
}
return conv.PBValueOf(rv)
},
@@ -324,14 +324,14 @@
get: func(p pointer) pref.Value {
lazyInit()
if p.IsNil() {
- return pref.ValueOf(messageType.Zero())
+ return pref.ValueOfMessage(messageType.Zero())
}
fs := p.Apply(weakOffset).WeakFields()
m, ok := (*fs)[num]
if !ok {
- return pref.ValueOf(messageType.Zero())
+ return pref.ValueOfMessage(messageType.Zero())
}
- return pref.ValueOf(m.(pref.ProtoMessage).ProtoReflect())
+ return pref.ValueOfMessage(m.(pref.ProtoMessage).ProtoReflect())
},
set: func(p pointer, v pref.Value) {
lazyInit()
@@ -356,7 +356,7 @@
m = messageType.New().Interface().(piface.MessageV1)
(*fs)[num] = m
}
- return pref.ValueOf(m.(pref.ProtoMessage).ProtoReflect())
+ return pref.ValueOfMessage(m.(pref.ProtoMessage).ProtoReflect())
},
newMessage: func() pref.Message {
lazyInit()
@@ -364,7 +364,7 @@
},
newField: func() pref.Value {
lazyInit()
- return pref.ValueOf(messageType.New())
+ return pref.ValueOfMessage(messageType.New())
},
}
}