all: move v1 types over to the v2 repository
As a goal, v2 should not depend on v1. As another step towards that end,
we move all the types that used to be in the v1 protoapi package over to v2.
For now, we place MessageV1, ExtensionRangeV1, and ExtensionDescV1
in runtime/protoiface since these are types that generated messages will
probably have to reference forever. An alternative location could be
reflect/protoreflect, but it seems unfortunate to have to dirty the
namespace of that package with these types.
We move ExtensionFieldV1, ExtensionFieldsV1, and ExtensionFieldsOf
to internal/impl, since these are related to the implementation of a
generated message.
Since moving these types from v1 to v2 implies that the v1 protoapi
package is useless, we update all usages of v1 protoapi in the v2
repository to point to the relevant v2 type or functionality.
CL/168538 is the corresponding change to alter v1.
There will be a temporary build failure as it is not possible
to submit CL/168519 and CL/168538 atomically.
Change-Id: Ide4025c1b6af5b7f0696f4b65b988b4d10a50f0b
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/168519
Reviewed-by: Herbie Ong <herbie@google.com>
diff --git a/internal/impl/legacy_export.go b/internal/impl/legacy_export.go
index 8038333..44bb101 100644
--- a/internal/impl/legacy_export.go
+++ b/internal/impl/legacy_export.go
@@ -7,6 +7,7 @@
import (
"encoding/binary"
"encoding/json"
+ "fmt"
"hash/crc32"
"math"
@@ -74,3 +75,19 @@
out = append(out, gzipFooter[:]...)
return out
}
+
+// ExtensionFieldsOf returns an interface abstraction over various
+// internal representations of extension fields.
+//
+// TODO: Delete this once v1 no longer needs to interact with the low-level
+// extensions data structure.
+func (Export) ExtensionFieldsOf(p interface{}) legacyExtensionFieldsIface {
+ switch p := p.(type) {
+ case *map[int32]ExtensionFieldV1:
+ return (*legacyExtensionMap)(p)
+ case *ExtensionFieldsV1:
+ return (*legacyExtensionSyncMap)(p)
+ default:
+ panic(fmt.Sprintf("invalid extension fields type: %T", p))
+ }
+}
diff --git a/internal/impl/legact_export_test.go b/internal/impl/legacy_export_test.go
similarity index 100%
rename from internal/impl/legact_export_test.go
rename to internal/impl/legacy_export_test.go
diff --git a/internal/impl/legacy_extension.go b/internal/impl/legacy_extension.go
index 83d5e99..424ee3f 100644
--- a/internal/impl/legacy_extension.go
+++ b/internal/impl/legacy_extension.go
@@ -6,9 +6,10 @@
import (
"reflect"
+ "sync"
- papi "github.com/golang/protobuf/protoapi"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ piface "github.com/golang/protobuf/v2/runtime/protoiface"
)
func makeLegacyExtensionFieldsFunc(t reflect.Type) func(p *messageDataType) pref.KnownFields {
@@ -25,25 +26,25 @@
}
var (
- extTypeA = reflect.TypeOf(map[int32]papi.ExtensionField(nil))
- extTypeB = reflect.TypeOf(papi.XXX_InternalExtensions{})
+ extTypeA = reflect.TypeOf(map[int32]ExtensionFieldV1(nil))
+ extTypeB = reflect.TypeOf(ExtensionFieldsV1{})
)
-func makeLegacyExtensionMapFunc(t reflect.Type) func(*messageDataType) papi.ExtensionFields {
+func makeLegacyExtensionMapFunc(t reflect.Type) func(*messageDataType) legacyExtensionFieldsIface {
fx1, _ := t.FieldByName("XXX_extensions")
fx2, _ := t.FieldByName("XXX_InternalExtensions")
switch {
case fx1.Type == extTypeA:
fieldOffset := offsetOf(fx1)
- return func(p *messageDataType) papi.ExtensionFields {
+ return func(p *messageDataType) legacyExtensionFieldsIface {
v := p.p.Apply(fieldOffset).AsValueOf(fx1.Type).Interface()
- return papi.ExtensionFieldsOf(v)
+ return Export{}.ExtensionFieldsOf(v)
}
case fx2.Type == extTypeB:
fieldOffset := offsetOf(fx2)
- return func(p *messageDataType) papi.ExtensionFields {
+ return func(p *messageDataType) legacyExtensionFieldsIface {
v := p.p.Apply(fieldOffset).AsValueOf(fx2.Type).Interface()
- return papi.ExtensionFieldsOf(v)
+ return Export{}.ExtensionFieldsOf(v)
}
default:
return nil
@@ -52,11 +53,11 @@
type legacyExtensionFields struct {
mi *MessageType
- x papi.ExtensionFields
+ x legacyExtensionFieldsIface
}
func (p legacyExtensionFields) Len() (n int) {
- p.x.Range(func(num pref.FieldNumber, _ papi.ExtensionField) bool {
+ p.x.Range(func(num pref.FieldNumber, _ ExtensionFieldV1) bool {
if p.Has(pref.FieldNumber(num)) {
n++
}
@@ -119,7 +120,7 @@
}
func (p legacyExtensionFields) Range(f func(pref.FieldNumber, pref.Value) bool) {
- p.x.Range(func(n pref.FieldNumber, x papi.ExtensionField) bool {
+ p.x.Range(func(n pref.FieldNumber, x ExtensionFieldV1) bool {
if p.Has(n) {
return f(n, p.Get(n))
}
@@ -143,7 +144,7 @@
type legacyExtensionTypes legacyExtensionFields
func (p legacyExtensionTypes) Len() (n int) {
- p.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
+ p.x.Range(func(_ pref.FieldNumber, x ExtensionFieldV1) bool {
if x.Desc != nil {
n++
}
@@ -204,7 +205,7 @@
}
func (p legacyExtensionTypes) ByName(s pref.FullName) (t pref.ExtensionType) {
- p.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
+ p.x.Range(func(_ pref.FieldNumber, x ExtensionFieldV1) bool {
if x.Desc != nil && x.Desc.Name == string(s) {
t = extensionTypeFromDesc(x.Desc)
return false
@@ -215,7 +216,7 @@
}
func (p legacyExtensionTypes) Range(f func(pref.ExtensionType) bool) {
- p.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
+ p.x.Range(func(_ pref.FieldNumber, x ExtensionFieldV1) bool {
if x.Desc != nil {
if !f(extensionTypeFromDesc(x.Desc)) {
return false
@@ -225,8 +226,10 @@
})
}
-func extensionDescFromType(typ pref.ExtensionType) *papi.ExtensionDesc {
- if xt, ok := typ.(interface{ ProtoLegacyExtensionDesc() *papi.ExtensionDesc }); ok {
+func extensionDescFromType(typ pref.ExtensionType) *piface.ExtensionDescV1 {
+ if xt, ok := typ.(interface {
+ ProtoLegacyExtensionDesc() *piface.ExtensionDescV1
+ }); ok {
if desc := xt.ProtoLegacyExtensionDesc(); desc != nil {
return desc
}
@@ -234,9 +237,160 @@
return legacyWrapper.ExtensionDescFromType(typ)
}
-func extensionTypeFromDesc(desc *papi.ExtensionDesc) pref.ExtensionType {
+func extensionTypeFromDesc(desc *piface.ExtensionDescV1) pref.ExtensionType {
if desc.Type != nil {
return desc.Type
}
return legacyWrapper.ExtensionTypeFromDesc(desc)
}
+
+type legacyExtensionFieldsIface = interface {
+ Len() int
+ Has(pref.FieldNumber) bool
+ Get(pref.FieldNumber) ExtensionFieldV1
+ Set(pref.FieldNumber, ExtensionFieldV1)
+ Clear(pref.FieldNumber)
+ Range(f func(pref.FieldNumber, ExtensionFieldV1) bool)
+
+ // HasInit and Locker are used by v1 GetExtension to provide
+ // an artificial degree of concurrent safety.
+ HasInit() bool
+ sync.Locker
+}
+
+type ExtensionFieldV1 struct {
+ // TODO: Unexport these fields when v1 no longer interacts with the
+ // extension data structures directly.
+
+ // When an extension is stored in a message using SetExtension
+ // only desc and value are set. When the message is marshaled
+ // Raw will be set to the encoded form of the message.
+ //
+ // When a message is unmarshaled and contains extensions, each
+ // extension will have only Raw set. When such an extension is
+ // accessed using GetExtension (or GetExtensions) desc and value
+ // will be set.
+ Desc *piface.ExtensionDescV1 // TODO: switch to protoreflect.ExtensionType
+
+ // Value is a concrete value for the extension field. Let the type of
+ // Desc.ExtensionType be the "API type" and the type of Value be the
+ // "storage type". The API type and storage type are the same except:
+ // * for scalars (except []byte), where the API type uses *T,
+ // while the storage type uses T.
+ // * for repeated fields, where the API type uses []T,
+ // while the storage type uses *[]T.
+ //
+ // The reason for the divergence is so that the storage type more naturally
+ // matches what is expected of when retrieving the values through the
+ // protobuf reflection APIs.
+ //
+ // The Value may only be populated if Desc is also populated.
+ Value interface{} // TODO: switch to protoreflect.Value
+
+ // Raw is the raw encoded bytes for the extension field.
+ // It is possible for Raw to be populated irrespective of whether the
+ // other fields are populated.
+ Raw []byte // TODO: switch to protoreflect.RawFields
+}
+
+type ExtensionFieldsV1 legacyExtensionSyncMap
+type legacyExtensionSyncMap struct {
+ p *struct {
+ mu sync.Mutex
+ m legacyExtensionMap
+ }
+}
+
+func (m legacyExtensionSyncMap) Len() int {
+ if m.p == nil {
+ return 0
+ }
+ return m.p.m.Len()
+}
+func (m legacyExtensionSyncMap) Has(n pref.FieldNumber) bool {
+ if m.p == nil {
+ return false
+ }
+ return m.p.m.Has(n)
+}
+func (m legacyExtensionSyncMap) Get(n pref.FieldNumber) ExtensionFieldV1 {
+ if m.p == nil {
+ return ExtensionFieldV1{}
+ }
+ return m.p.m.Get(n)
+}
+func (m *legacyExtensionSyncMap) Set(n pref.FieldNumber, x ExtensionFieldV1) {
+ if m.p == nil {
+ m.p = new(struct {
+ mu sync.Mutex
+ m legacyExtensionMap
+ })
+ }
+ m.p.m.Set(n, x)
+}
+func (m legacyExtensionSyncMap) Clear(n pref.FieldNumber) {
+ if m.p == nil {
+ return
+ }
+ m.p.m.Clear(n)
+}
+func (m legacyExtensionSyncMap) Range(f func(pref.FieldNumber, ExtensionFieldV1) bool) {
+ if m.p == nil {
+ return
+ }
+ m.p.m.Range(f)
+}
+
+func (m legacyExtensionSyncMap) HasInit() bool {
+ return m.p != nil
+}
+func (m legacyExtensionSyncMap) Lock() {
+ m.p.mu.Lock()
+}
+func (m legacyExtensionSyncMap) Unlock() {
+ m.p.mu.Unlock()
+}
+
+type legacyExtensionMap map[int32]ExtensionFieldV1
+
+func (m legacyExtensionMap) Len() int {
+ return len(m)
+}
+func (m legacyExtensionMap) Has(n pref.FieldNumber) bool {
+ _, ok := m[int32(n)]
+ return ok
+}
+func (m legacyExtensionMap) Get(n pref.FieldNumber) ExtensionFieldV1 {
+ return m[int32(n)]
+}
+func (m *legacyExtensionMap) Set(n pref.FieldNumber, x ExtensionFieldV1) {
+ if *m == nil {
+ *m = make(map[int32]ExtensionFieldV1)
+ }
+ (*m)[int32(n)] = x
+}
+func (m *legacyExtensionMap) Clear(n pref.FieldNumber) {
+ delete(*m, int32(n))
+}
+func (m legacyExtensionMap) Range(f func(pref.FieldNumber, ExtensionFieldV1) bool) {
+ for n, x := range m {
+ if !f(pref.FieldNumber(n), x) {
+ return
+ }
+ }
+}
+
+var legacyExtensionLock sync.Mutex
+
+func (m legacyExtensionMap) HasInit() bool {
+ return m != nil
+}
+func (m legacyExtensionMap) Lock() {
+ if !m.HasInit() {
+ panic("cannot lock an uninitialized map")
+ }
+ legacyExtensionLock.Lock()
+}
+func (m legacyExtensionMap) Unlock() {
+ legacyExtensionLock.Unlock()
+}
diff --git a/internal/impl/legacy_test.go b/internal/impl/legacy_test.go
index 7fea32e..1bc5acf 100644
--- a/internal/impl/legacy_test.go
+++ b/internal/impl/legacy_test.go
@@ -10,13 +10,13 @@
"reflect"
"testing"
- papi "github.com/golang/protobuf/protoapi"
pack "github.com/golang/protobuf/v2/internal/encoding/pack"
pimpl "github.com/golang/protobuf/v2/internal/impl"
pragma "github.com/golang/protobuf/v2/internal/pragma"
ptype "github.com/golang/protobuf/v2/internal/prototype"
scalar "github.com/golang/protobuf/v2/internal/scalar"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ piface "github.com/golang/protobuf/v2/runtime/protoiface"
cmp "github.com/google/go-cmp/cmp"
cmpopts "github.com/google/go-cmp/cmp/cmpopts"
@@ -28,15 +28,15 @@
)
type legacyTestMessage struct {
- XXX_unrecognized []byte
- papi.XXX_InternalExtensions
+ XXX_unrecognized []byte
+ XXX_InternalExtensions pimpl.ExtensionFieldsV1
}
func (*legacyTestMessage) Reset() {}
func (*legacyTestMessage) String() string { return "" }
func (*legacyTestMessage) ProtoMessage() {}
-func (*legacyTestMessage) ExtensionRangeArray() []papi.ExtensionRange {
- return []papi.ExtensionRange{{Start: 10, End: 20}, {Start: 40, End: 80}, {Start: 10000, End: 20000}}
+func (*legacyTestMessage) ExtensionRangeArray() []piface.ExtensionRangeV1 {
+ return []piface.ExtensionRangeV1{{Start: 10, End: 20}, {Start: 40, End: 80}, {Start: 10000, End: 20000}}
}
func TestLegacyUnknown(t *testing.T) {
@@ -440,7 +440,7 @@
}, (*EnumMessages)(nil)),
}
- extensionDescs = []*papi.ExtensionDesc{{
+ extensionDescs = []*piface.ExtensionDescV1{{
ExtendedType: (*legacyTestMessage)(nil),
ExtensionType: (*bool)(nil),
Field: 10000,
@@ -794,7 +794,7 @@
}
opts = cmp.Options{
- cmpopts.IgnoreFields(papi.ExtensionDesc{}, "Type"),
+ cmpopts.IgnoreFields(piface.ExtensionDescV1{}, "Type"),
}
if diff := cmp.Diff(wantDesc, gotDesc, opts); diff != "" {
t.Errorf("ExtensionDesc mismatch (-want, +got):\n%v", diff)
diff --git a/internal/impl/legacy_unknown.go b/internal/impl/legacy_unknown.go
index b5c6840..759bab9 100644
--- a/internal/impl/legacy_unknown.go
+++ b/internal/impl/legacy_unknown.go
@@ -9,7 +9,6 @@
"reflect"
"sort"
- papi "github.com/golang/protobuf/protoapi"
"github.com/golang/protobuf/v2/internal/encoding/wire"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
)
@@ -47,13 +46,13 @@
// and also the extension field map.
type legacyUnknownBytesAndExtensionMap struct {
u pref.UnknownFields
- x papi.ExtensionFields
+ x legacyExtensionFieldsIface
r pref.FieldRanges
}
func (fs *legacyUnknownBytesAndExtensionMap) Len() int {
n := fs.u.Len()
- fs.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
+ fs.x.Range(func(_ pref.FieldNumber, x ExtensionFieldV1) bool {
if len(x.Raw) > 0 {
n++
}
@@ -98,7 +97,7 @@
raw pref.RawFields
}
var xs []entry
- fs.x.Range(func(n pref.FieldNumber, x papi.ExtensionField) bool {
+ fs.x.Range(func(n pref.FieldNumber, x ExtensionFieldV1) bool {
if len(x.Raw) > 0 {
xs = append(xs, entry{n, x.Raw})
}