mirror/protobuf-go
1
0
Fork 0
mirror of https://github.com/protocolbuffers/protobuf-go.git synced 2025-01-29 18:32:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
protobuf-go/cmd/protoc-gen-go/testdata/import_public/b.pb.go

159 lines
5.3 KiB
Go
Raw Normal View History

cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: import_public/b.proto
package import_public
import (
proto "github.com/golang/protobuf/proto"
go.mod: rename google.golang.org/proto as github.com/golang/protobuf/v2 This change was created by running: git ls-files | xargs sed -i "s|google.golang.org/proto|github.com/golang/protobuf/v2|g" This change is *not* an endorsement of "github.com/golang/protobuf/v2" as the final import path when the v2 API is eventually released as stable. We continue to reserve the right to make breaking changes as we see fit. This change enables us to host the v2 API on a repository that is go-gettable (since go.googlesource.com is not a known host by the "go get" tool; and google.golang.org/proto was just a stub URL that is not currently served). Thus, we can start work on a forked version of the v1 API that explores what it would take to implement v1 in terms of v2 in a backwards compatible way. Change-Id: Ia3ebc41ac4238af62ee140200d3158b53ac9ec48 Reviewed-on: https://go-review.googlesource.com/136736 Reviewed-by: Damien Neil <dneil@google.com>
2018-09-21 17:44:00 -07:00
sub "github.com/golang/protobuf/v2/cmd/protoc-gen-go/testdata/import_public/sub"
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 14:44:37 -08: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 public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07: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 12:57:27 -08:00
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
type Local struct {
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
M *sub.M `protobuf:"bytes,1,opt,name=m" json:"m,omitempty"`
E *sub.E `protobuf:"varint,2,opt,name=e,enum=goproto.protoc.import_public.sub.E" json:"e,omitempty"`
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
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 14:44:37 -08:00
type xxx_Local struct{ m *Local }
func (m *Local) ProtoReflect() protoreflect.Message {
return xxx_Local{m}
}
func (m xxx_Local) Type() protoreflect.MessageType {
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
return xxx_B_protoFile_MessageTypes[0].Type
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 14:44:37 -08:00
}
func (m xxx_Local) KnownFields() protoreflect.KnownFields {
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
return xxx_B_protoFile_MessageTypes[0].KnownFieldsOf(m.m)
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 14:44:37 -08:00
}
func (m xxx_Local) UnknownFields() protoreflect.UnknownFields {
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
return xxx_B_protoFile_MessageTypes[0].UnknownFieldsOf(m.m)
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 14:44:37 -08:00
}
func (m xxx_Local) Interface() protoreflect.ProtoMessage {
return m.m
}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (m *Local) Reset() { *m = Local{} }
func (m *Local) String() string { return proto.CompactTextString(m) }
func (*Local) ProtoMessage() {}
func (*Local) Descriptor() ([]byte, []int) {
return fileDescriptor_84995586b3d09710, []int{0}
}
func (m *Local) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Local.Unmarshal(m, b)
}
func (m *Local) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Local.Marshal(b, m, deterministic)
}
func (m *Local) XXX_Merge(src proto.Message) {
xxx_messageInfo_Local.Merge(m, src)
}
func (m *Local) XXX_Size() int {
return xxx_messageInfo_Local.Size(m)
}
func (m *Local) XXX_DiscardUnknown() {
xxx_messageInfo_Local.DiscardUnknown(m)
}
var xxx_messageInfo_Local proto.InternalMessageInfo
func (m *Local) GetM() *sub.M {
if m != nil {
return m.M
}
return nil
}
func (m *Local) GetE() sub.E {
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
if m != nil && m.E != nil {
return *m.E
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
return sub.E_ZERO
}
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 15:42:52 -08:00
proto.RegisterFile("import_public/b.proto", fileDescriptor_84995586b3d09710)
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
proto.RegisterType((*Local)(nil), "goproto.protoc.import_public.Local")
}
var fileDescriptor_84995586b3d09710 = []byte{
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
// 176 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcd, 0xcc, 0x2d, 0xc8,
0x2f, 0x2a, 0x89, 0x2f, 0x28, 0x4d, 0xca, 0xc9, 0x4c, 0xd6, 0x4f, 0xd2, 0x2b, 0x28, 0xca, 0x2f,
0xc9, 0x17, 0x92, 0x49, 0xcf, 0x07, 0x33, 0x20, 0xdc, 0x64, 0x3d, 0x14, 0x55, 0x52, 0x92, 0xa8,
0x9a, 0x8a, 0x4b, 0x93, 0xf4, 0x13, 0x21, 0x2a, 0x95, 0x72, 0xb9, 0x58, 0x7d, 0xf2, 0x93, 0x13,
0x73, 0x84, 0x0c, 0xb9, 0x18, 0x73, 0x25, 0x18, 0x15, 0x18, 0x35, 0xb8, 0x8d, 0x94, 0xf5, 0xf0,
0x99, 0xa6, 0x57, 0x5c, 0x9a, 0xa4, 0xe7, 0x1b, 0xc4, 0x98, 0x0b, 0xd2, 0x92, 0x2a, 0xc1, 0xa4,
0xc0, 0xa8, 0xc1, 0x47, 0x8c, 0x16, 0xd7, 0x20, 0xc6, 0x54, 0x27, 0x8f, 0x28, 0xb7, 0xf4, 0xcc,
0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0xfd, 0xf4, 0xfc, 0x9c, 0xc4, 0xbc, 0x74, 0x7d,
0xb0, 0x96, 0xa4, 0xd2, 0x34, 0xfd, 0x32, 0x23, 0xfd, 0xe4, 0xdc, 0x14, 0x08, 0x3f, 0x59, 0x37,
0x3d, 0x35, 0x4f, 0x37, 0x3d, 0x5f, 0xbf, 0x24, 0xb5, 0xb8, 0x24, 0x25, 0xb1, 0x24, 0x51, 0x1f,
0xc5, 0x48, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x34, 0xb9, 0xda, 0x09, 0x01, 0x00, 0x00,
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07: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 14:44:37 -08:00
func init() {
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
xxx_B_protoFile_FileDesc.Messages = xxx_B_protoFile_MessageDescs[0:1]
xxx_B_protoFile_MessageDescs[0].Fields[0].MessageType = protoimpl.X.MessageTypeOf((*sub.M)(nil))
xxx_B_protoFile_MessageDescs[0].Fields[1].EnumType = protoimpl.X.EnumTypeOf(sub.E(0))
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 14:44:37 -08:00
var err error
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
B_protoFile, err = prototype.NewFile(&xxx_B_protoFile_FileDesc)
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 14:44:37 -08:00
if err != nil {
panic(err)
}
}
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
var B_protoFile protoreflect.FileDescriptor
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 14:44:37 -08:00
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
var xxx_B_protoFile_FileDesc = prototype.File{
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 14:44:37 -08:00
Syntax: protoreflect.Proto2,
Path: "import_public/b.proto",
Package: "goproto.protoc.import_public",
Imports: []protoreflect.FileImport{
{FileDescriptor: prototype.PlaceholderFile("import_public/sub/a.proto", "goproto.protoc.import_public.sub")},
},
}
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
var xxx_B_protoFile_MessageTypes = [1]protoimpl.MessageType{
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 14:44:37 -08:00
{Type: prototype.GoMessage(
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
xxx_B_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 02:57:13 -08:00
func(protoreflect.MessageType) protoreflect.Message {
return xxx_Local{new(Local)}
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 14:44:37 -08:00
},
)},
}
protogen: use _protoFile suffix for file descriptor variable A "_ProtoFile" suffix can potentially conflict with a sub-message named "ProtoFile" nested within a message that matches the camel-cased form of the basename of the .proto source file. Avoid unlikely conflicts and rename this to use a "_protoFile" suffix, which can never conflict except with an enum value that is also named "protoFile" (which is a violation of the style guide). Change-Id: Ie9d22f9f741a63021b8f76906b20c6c2f599885b Reviewed-on: https://go-review.googlesource.com/c/157218 Reviewed-by: Damien Neil <dneil@google.com>
2019-01-09 21:31:15 -08:00
var xxx_B_protoFile_MessageDescs = [1]prototype.Message{
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 14:44:37 -08:00
{
Name: "Local",
Fields: []prototype.Field{
{
Name: "m",
Number: 1,
Cardinality: protoreflect.Optional,
Kind: protoreflect.MessageKind,
JSONName: "m",
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 15:14:36 -08: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 14:44:37 -08:00
},
{
Name: "e",
Number: 2,
Cardinality: protoreflect.Optional,
Kind: protoreflect.EnumKind,
JSONName: "e",
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 15:14:36 -08: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 14:44:37 -08:00
},
},
},
}
Reference in New Issue Copy Permalink