mirror/protobuf-go
1
0
Fork 0
mirror of https://github.com/protocolbuffers/protobuf-go.git synced 2025-01-06 00:55:51 +00:00
Code Issues Packages Projects Releases Wiki Activity
3bc7d6f5cd
protobuf-go/cmd/protoc-gen-go/testdata/extensions/extra/extra.pb.go

136 lines
4.7 KiB
Go
Raw Normal View History

cmd/protoc-gen-go: generate extensions Generate everything related to extensions: extension descriptors, XXX_InternalExtensions fields, etc. Tweak the order in which we generate code for descriptors to ensure consistent output with the previous protoc-gen-go. Change Field.ContainingType to Field.ParentMessage, since we need to get at the parent of both message fields and extensions (and the "containing type" of an extension field is the extended message, under existing terminology). Change-Id: I5d045ca80536436e7c987bca3d8fb8c1e1521e55 Reviewed-on: https://go-review.googlesource.com/136155 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-14 22:41:11 +00:00
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: extensions/extra/extra.proto
package extra
import (
proto "github.com/golang/protobuf/proto"
cmd/protoc-gen-go: add support for protobuf reflection Implement support in protoc-gen-go for generating messages and enums that satisfy the v2 protobuf reflection interfaces. Specifically, the following are added: * top-level variable representing the file descriptor * ProtoReflect method on enums (to implement protoV2.Enum) * ProtoReflect method on messages (to implement protoV2.Message) The following are not supported yet: * resolving transitive dependencies for file imports * Extension descriptors * Service descriptors The implementation approach creates a single array for all the message and enum declarations and references sections of that array to complete dependencies. Since protobuf declarations can form a graph (a message may depend on itself), it is difficult to construct a graph as a single literal. One way is to use placeholder descriptors, but that is not efficient as it requires encoding the full name of each dependent enum and message and then later resolving it; thus, both expanding the binary size and also increasing initialization cost. Instead, we add a prototype.{Enum,Message}.Reference method to obtain a descriptor reference for the purposes for satisfying dependencies. As such, nested declarations and dependencies are populated in an init function. Other changes to support the implementation: * Added a protoimpl package to expose the MessageType type and also the MessageTypeOf and EnumTypeOf helper functions. * Added a protogen.File.GoIdent field to provide a suggested variable name for the file descriptor. * Added prototype.{Enum,Message}.Reference that provides a descriptor reference for the purposes for satisfying cyclic dependencies. * Added protoreflect.{Syntax,Cardinality,Kind}.GoString to obtain a Go source identifier that represents the given constant. Change-Id: I9455764882dee6ad10f251901e7d419091e8bf1d Reviewed-on: https://go-review.googlesource.com/c/150074 Reviewed-by: Damien Neil <dneil@google.com>
2018-11-15 22:44:37 +00:00
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
prototype "github.com/golang/protobuf/v2/reflect/prototype"
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
cmd/protoc-gen-go: generate extensions Generate everything related to extensions: extension descriptors, XXX_InternalExtensions fields, etc. Tweak the order in which we generate code for descriptors to ensure consistent output with the previous protoc-gen-go. Change Field.ContainingType to Field.ParentMessage, since we need to get at the parent of both message fields and extensions (and the "containing type" of an extension field is the extended message, under existing terminology). Change-Id: I5d045ca80536436e7c987bca3d8fb8c1e1521e55 Reviewed-on: https://go-review.googlesource.com/136155 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-14 22:41:11 +00:00
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
cmd/protoc-gen-go: generate XXX_OneofWrappers instead of XXX_OneofFuncs The marshaler, unmarshaler, and sizer functions are unused ever since the underlying implementation was switched to be table-driven. Change the function to only return the wrapper structs. This change: * enables generated protos to drop dependencies on certain proto types * reduces the size of generated protos * simplifies the implementation of oneofs in protoc-gen-go Updates #708 Change-Id: I845c9009bc0236d1b51d34b014dc3e184303c0f2 Reviewed-on: https://go-review.googlesource.com/c/151357 Reviewed-by: Damien Neil <dneil@google.com>
2018-11-26 20:57:27 +00:00
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
cmd/protoc-gen-go: generate extensions Generate everything related to extensions: extension descriptors, XXX_InternalExtensions fields, etc. Tweak the order in which we generate code for descriptors to ensure consistent output with the previous protoc-gen-go. Change Field.ContainingType to Field.ParentMessage, since we need to get at the parent of both message fields and extensions (and the "containing type" of an extension field is the extended message, under existing terminology). Change-Id: I5d045ca80536436e7c987bca3d8fb8c1e1521e55 Reviewed-on: https://go-review.googlesource.com/136155 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-14 22:41:11 +00:00
type ExtraMessage struct {
Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
cmd/protoc-gen-go: add support for protobuf reflection Implement support in protoc-gen-go for generating messages and enums that satisfy the v2 protobuf reflection interfaces. Specifically, the following are added: * top-level variable representing the file descriptor * ProtoReflect method on enums (to implement protoV2.Enum) * ProtoReflect method on messages (to implement protoV2.Message) The following are not supported yet: * resolving transitive dependencies for file imports * Extension descriptors * Service descriptors The implementation approach creates a single array for all the message and enum declarations and references sections of that array to complete dependencies. Since protobuf declarations can form a graph (a message may depend on itself), it is difficult to construct a graph as a single literal. One way is to use placeholder descriptors, but that is not efficient as it requires encoding the full name of each dependent enum and message and then later resolving it; thus, both expanding the binary size and also increasing initialization cost. Instead, we add a prototype.{Enum,Message}.Reference method to obtain a descriptor reference for the purposes for satisfying dependencies. As such, nested declarations and dependencies are populated in an init function. Other changes to support the implementation: * Added a protoimpl package to expose the MessageType type and also the MessageTypeOf and EnumTypeOf helper functions. * Added a protogen.File.GoIdent field to provide a suggested variable name for the file descriptor. * Added prototype.{Enum,Message}.Reference that provides a descriptor reference for the purposes for satisfying cyclic dependencies. * Added protoreflect.{Syntax,Cardinality,Kind}.GoString to obtain a Go source identifier that represents the given constant. Change-Id: I9455764882dee6ad10f251901e7d419091e8bf1d Reviewed-on: https://go-review.googlesource.com/c/150074 Reviewed-by: Damien Neil <dneil@google.com>
2018-11-15 22:44:37 +00:00
type xxx_ExtraMessage struct{ m *ExtraMessage }
func (m *ExtraMessage) ProtoReflect() protoreflect.Message {
return xxx_ExtraMessage{m}
}
func (m xxx_ExtraMessage) Type() protoreflect.MessageType {
return xxx_Extra_ProtoFile_MessageTypes[0].Type
}
func (m xxx_ExtraMessage) KnownFields() protoreflect.KnownFields {
return xxx_Extra_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
}
func (m xxx_ExtraMessage) UnknownFields() protoreflect.UnknownFields {
return xxx_Extra_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
}
func (m xxx_ExtraMessage) Interface() protoreflect.ProtoMessage {
return m.m
}
cmd/protoc-gen-go: generate extensions Generate everything related to extensions: extension descriptors, XXX_InternalExtensions fields, etc. Tweak the order in which we generate code for descriptors to ensure consistent output with the previous protoc-gen-go. Change Field.ContainingType to Field.ParentMessage, since we need to get at the parent of both message fields and extensions (and the "containing type" of an extension field is the extended message, under existing terminology). Change-Id: I5d045ca80536436e7c987bca3d8fb8c1e1521e55 Reviewed-on: https://go-review.googlesource.com/136155 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-14 22:41:11 +00:00
func (m *ExtraMessage) Reset() { *m = ExtraMessage{} }
func (m *ExtraMessage) String() string { return proto.CompactTextString(m) }
func (*ExtraMessage) ProtoMessage() {}
func (*ExtraMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_496c2a5e9c1e8739, []int{0}
}
func (m *ExtraMessage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ExtraMessage.Unmarshal(m, b)
}
func (m *ExtraMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ExtraMessage.Marshal(b, m, deterministic)
}
func (m *ExtraMessage) XXX_Merge(src proto.Message) {
xxx_messageInfo_ExtraMessage.Merge(m, src)
}
func (m *ExtraMessage) XXX_Size() int {
return xxx_messageInfo_ExtraMessage.Size(m)
}
func (m *ExtraMessage) XXX_DiscardUnknown() {
xxx_messageInfo_ExtraMessage.DiscardUnknown(m)
}
var xxx_messageInfo_ExtraMessage proto.InternalMessageInfo
func (m *ExtraMessage) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func init() {
cmd/protoc-gen-go: reduce technical debt The following TODOs were addressed: * Consistently collect all enums, messages, and extensions in a breadth-first order. The practical affect of this is that the declaration order in a Go file may change. This simplifies reflection generation, which relies on consistent ordering. * Removal of placeholder declarations (e.g., "var _ = proto.Marshal") since protogen is intelligent about including imports as necessary. * Always generate a default variable or constant for explicit empty strings. The practical effect of this is the addition of new declarations in some cases. However, it simplifies our logic such that it matches the protobuf data model. * Generate the registration statements in a consistent order. Change-Id: I627bb72589432bb65d53b50965ea88e5f7983977 Reviewed-on: https://go-review.googlesource.com/c/152778 Reviewed-by: Damien Neil <dneil@google.com>
2018-12-05 23:42:52 +00:00
proto.RegisterFile("extensions/extra/extra.proto", fileDescriptor_496c2a5e9c1e8739)
cmd/protoc-gen-go: generate extensions Generate everything related to extensions: extension descriptors, XXX_InternalExtensions fields, etc. Tweak the order in which we generate code for descriptors to ensure consistent output with the previous protoc-gen-go. Change Field.ContainingType to Field.ParentMessage, since we need to get at the parent of both message fields and extensions (and the "containing type" of an extension field is the extended message, under existing terminology). Change-Id: I5d045ca80536436e7c987bca3d8fb8c1e1521e55 Reviewed-on: https://go-review.googlesource.com/136155 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-14 22:41:11 +00:00
proto.RegisterType((*ExtraMessage)(nil), "goproto.protoc.extension.extra.ExtraMessage")
}
var fileDescriptor_496c2a5e9c1e8739 = []byte{
cmd/protoc-gen-go: special cases for MessageSet extensions Add special-case handling for extension fields named "message_set_extension" that extend a message_set_wire_format message. Support special cases for a proto1 feature that was superseded by proto2 extensions. Change-Id: Icbdb711111c66be547bf8d6f37ab3079c320e2a1 Reviewed-on: https://go-review.googlesource.com/136536 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-19 20:21:58 +00:00
// 149 bytes of a gzipped FileDescriptorProto
cmd/protoc-gen-go: generate extensions Generate everything related to extensions: extension descriptors, XXX_InternalExtensions fields, etc. Tweak the order in which we generate code for descriptors to ensure consistent output with the previous protoc-gen-go. Change Field.ContainingType to Field.ParentMessage, since we need to get at the parent of both message fields and extensions (and the "containing type" of an extension field is the extended message, under existing terminology). Change-Id: I5d045ca80536436e7c987bca3d8fb8c1e1521e55 Reviewed-on: https://go-review.googlesource.com/136155 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-14 22:41:11 +00:00
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0xad, 0x28, 0x49,
0xcd, 0x2b, 0xce, 0xcc, 0xcf, 0x2b, 0xd6, 0x4f, 0xad, 0x28, 0x29, 0x4a, 0x84, 0x90, 0x7a, 0x05,
0x45, 0xf9, 0x25, 0xf9, 0x42, 0x72, 0xe9, 0xf9, 0x60, 0x06, 0x84, 0x9b, 0xac, 0x07, 0x57, 0xac,
0x07, 0x56, 0xa5, 0xa4, 0xc4, 0xc5, 0xe3, 0x0a, 0x62, 0xf8, 0xa6, 0x16, 0x17, 0x27, 0xa6, 0xa7,
0x0a, 0x09, 0x71, 0xb1, 0xa4, 0x24, 0x96, 0x24, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x04, 0x81,
cmd/protoc-gen-go: special cases for MessageSet extensions Add special-case handling for extension fields named "message_set_extension" that extend a message_set_wire_format message. Support special cases for a proto1 feature that was superseded by proto2 extensions. Change-Id: Icbdb711111c66be547bf8d6f37ab3079c320e2a1 Reviewed-on: https://go-review.googlesource.com/136536 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-19 20:21:58 +00:00
0xd9, 0x4e, 0xde, 0x51, 0x9e, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa,
0xe9, 0xf9, 0x39, 0x89, 0x79, 0xe9, 0xfa, 0x60, 0xf3, 0x92, 0x4a, 0xd3, 0xf4, 0xcb, 0x8c, 0xf4,
0x93, 0x73, 0x53, 0x20, 0xfc, 0x64, 0xdd, 0xf4, 0xd4, 0x3c, 0xdd, 0xf4, 0x7c, 0xfd, 0x92, 0xd4,
0xe2, 0x12, 0x90, 0x5e, 0x7d, 0x74, 0xc7, 0x01, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xfb, 0x31,
0xfc, 0xaf, 0x00, 0x00, 0x00,
cmd/protoc-gen-go: generate extensions Generate everything related to extensions: extension descriptors, XXX_InternalExtensions fields, etc. Tweak the order in which we generate code for descriptors to ensure consistent output with the previous protoc-gen-go. Change Field.ContainingType to Field.ParentMessage, since we need to get at the parent of both message fields and extensions (and the "containing type" of an extension field is the extended message, under existing terminology). Change-Id: I5d045ca80536436e7c987bca3d8fb8c1e1521e55 Reviewed-on: https://go-review.googlesource.com/136155 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-14 22:41:11 +00:00
}
cmd/protoc-gen-go: add support for protobuf reflection Implement support in protoc-gen-go for generating messages and enums that satisfy the v2 protobuf reflection interfaces. Specifically, the following are added: * top-level variable representing the file descriptor * ProtoReflect method on enums (to implement protoV2.Enum) * ProtoReflect method on messages (to implement protoV2.Message) The following are not supported yet: * resolving transitive dependencies for file imports * Extension descriptors * Service descriptors The implementation approach creates a single array for all the message and enum declarations and references sections of that array to complete dependencies. Since protobuf declarations can form a graph (a message may depend on itself), it is difficult to construct a graph as a single literal. One way is to use placeholder descriptors, but that is not efficient as it requires encoding the full name of each dependent enum and message and then later resolving it; thus, both expanding the binary size and also increasing initialization cost. Instead, we add a prototype.{Enum,Message}.Reference method to obtain a descriptor reference for the purposes for satisfying dependencies. As such, nested declarations and dependencies are populated in an init function. Other changes to support the implementation: * Added a protoimpl package to expose the MessageType type and also the MessageTypeOf and EnumTypeOf helper functions. * Added a protogen.File.GoIdent field to provide a suggested variable name for the file descriptor. * Added prototype.{Enum,Message}.Reference that provides a descriptor reference for the purposes for satisfying cyclic dependencies. * Added protoreflect.{Syntax,Cardinality,Kind}.GoString to obtain a Go source identifier that represents the given constant. Change-Id: I9455764882dee6ad10f251901e7d419091e8bf1d Reviewed-on: https://go-review.googlesource.com/c/150074 Reviewed-by: Damien Neil <dneil@google.com>
2018-11-15 22:44:37 +00:00
func init() {
xxx_Extra_ProtoFile_FileDesc.Messages = xxx_Extra_ProtoFile_MessageDescs[0:1]
var err error
Extra_ProtoFile, err = prototype.NewFile(&xxx_Extra_ProtoFile_FileDesc)
if err != nil {
panic(err)
}
}
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
var Extra_ProtoFile protoreflect.FileDescriptor
var xxx_Extra_ProtoFile_FileDesc = prototype.File{
Syntax: protoreflect.Proto2,
Path: "extensions/extra/extra.proto",
Package: "goproto.protoc.extension.extra",
}
var xxx_Extra_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
{Type: prototype.GoMessage(
xxx_Extra_ProtoFile_MessageDescs[0].Reference(),
reflect: switch MessageType.New to return Message Most usages of New actually prefer to interact with the reflective view rather than the native Go type. Thus, change New to return that instead. This parallels reflect.New, which returns the reflective view (i.e., reflect.Value) instead of native type (i.e., interface{}). We make the equivalent change to KnownFields.NewMessage, List.NewMessage, and Map.NewMessage for consistency. Since this is a subtle change where the type system will not always catch the changed type, this change was made by both changing the type and renaming the function to NewXXX and manually looking at every usage of the the function to ensure that the usage correctly operates on either the native Go type or the reflective view of the type. After the entire codebase was cleaned up, a rename was performed to convert NewXXX back to New. Change-Id: I153fef627b4bf0a427e4039ce0aaec52e20c7950 Reviewed-on: https://go-review.googlesource.com/c/157077 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 10:57:13 +00:00
func(protoreflect.MessageType) protoreflect.Message {
return xxx_ExtraMessage{new(ExtraMessage)}
cmd/protoc-gen-go: add support for protobuf reflection Implement support in protoc-gen-go for generating messages and enums that satisfy the v2 protobuf reflection interfaces. Specifically, the following are added: * top-level variable representing the file descriptor * ProtoReflect method on enums (to implement protoV2.Enum) * ProtoReflect method on messages (to implement protoV2.Message) The following are not supported yet: * resolving transitive dependencies for file imports * Extension descriptors * Service descriptors The implementation approach creates a single array for all the message and enum declarations and references sections of that array to complete dependencies. Since protobuf declarations can form a graph (a message may depend on itself), it is difficult to construct a graph as a single literal. One way is to use placeholder descriptors, but that is not efficient as it requires encoding the full name of each dependent enum and message and then later resolving it; thus, both expanding the binary size and also increasing initialization cost. Instead, we add a prototype.{Enum,Message}.Reference method to obtain a descriptor reference for the purposes for satisfying dependencies. As such, nested declarations and dependencies are populated in an init function. Other changes to support the implementation: * Added a protoimpl package to expose the MessageType type and also the MessageTypeOf and EnumTypeOf helper functions. * Added a protogen.File.GoIdent field to provide a suggested variable name for the file descriptor. * Added prototype.{Enum,Message}.Reference that provides a descriptor reference for the purposes for satisfying cyclic dependencies. * Added protoreflect.{Syntax,Cardinality,Kind}.GoString to obtain a Go source identifier that represents the given constant. Change-Id: I9455764882dee6ad10f251901e7d419091e8bf1d Reviewed-on: https://go-review.googlesource.com/c/150074 Reviewed-by: Damien Neil <dneil@google.com>
2018-11-15 22:44:37 +00:00
},
)},
}
var xxx_Extra_ProtoFile_MessageDescs = [1]prototype.Message{
{
Name: "ExtraMessage",
Fields: []prototype.Field{
{
Name: "data",
Number: 1,
Cardinality: protoreflect.Optional,
Kind: protoreflect.BytesKind,
JSONName: "data",
reflect/prototype: hoist semantic options into builders Add fields to the Message and Field builder structs which hold the value of MessageOptions.map_entry, FieldOptions.packed, and FieldOptions.weak options. Remove all access to the contents of options messages from the prototype package. Change IsPacked to always return false for unpackable field types, which is consistent with the equivalent C++ API. This change helps avoid dependency cycles between prototype and the options messages. (Previously this was resolved by accessing options with reflection, but just breaking the dependency from prototype to the options message is cleaner and simpler.) Change-Id: I756aefe2e04cfa8fea31eaaaa0b5a99d4ac9e851 Reviewed-on: https://go-review.googlesource.com/c/153517 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-12-10 23:14:36 +00:00
IsPacked: prototype.False,
cmd/protoc-gen-go: add support for protobuf reflection Implement support in protoc-gen-go for generating messages and enums that satisfy the v2 protobuf reflection interfaces. Specifically, the following are added: * top-level variable representing the file descriptor * ProtoReflect method on enums (to implement protoV2.Enum) * ProtoReflect method on messages (to implement protoV2.Message) The following are not supported yet: * resolving transitive dependencies for file imports * Extension descriptors * Service descriptors The implementation approach creates a single array for all the message and enum declarations and references sections of that array to complete dependencies. Since protobuf declarations can form a graph (a message may depend on itself), it is difficult to construct a graph as a single literal. One way is to use placeholder descriptors, but that is not efficient as it requires encoding the full name of each dependent enum and message and then later resolving it; thus, both expanding the binary size and also increasing initialization cost. Instead, we add a prototype.{Enum,Message}.Reference method to obtain a descriptor reference for the purposes for satisfying dependencies. As such, nested declarations and dependencies are populated in an init function. Other changes to support the implementation: * Added a protoimpl package to expose the MessageType type and also the MessageTypeOf and EnumTypeOf helper functions. * Added a protogen.File.GoIdent field to provide a suggested variable name for the file descriptor. * Added prototype.{Enum,Message}.Reference that provides a descriptor reference for the purposes for satisfying cyclic dependencies. * Added protoreflect.{Syntax,Cardinality,Kind}.GoString to obtain a Go source identifier that represents the given constant. Change-Id: I9455764882dee6ad10f251901e7d419091e8bf1d Reviewed-on: https://go-review.googlesource.com/c/150074 Reviewed-by: Damien Neil <dneil@google.com>
2018-11-15 22:44:37 +00:00
},
},
},
}
Reference in New Issue Copy Permalink