mirror/protobuf-go
1
0
Fork 0
mirror of https://github.com/protocolbuffers/protobuf-go.git synced 2025-01-30 03:32:49 +00:00
Code Issues Packages Projects Releases Wiki Activity
protobuf-go/cmd/protoc-gen-go/testdata/proto2/nested_messages.pb.go

295 lines
10 KiB
Go
Raw Normal View History

protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -07:00
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: proto2/nested_messages.proto
protogen: compute package names, import paths, generated filenames Copy/duplicate the logic in github.com/golang/protobuf for computing package names and import paths and the names of generated files. This is all sufficiently complicated that the code is the best documentation. In practice, users should always set a go_package option containing an import path in every file and pass the paths=source_relative generator flag to get reasonable behavior. Change-Id: I34ae38fcc8db6909a4b25b16c73b982a7bad0463 Reviewed-on: https://go-review.googlesource.com/133876 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-06 10:23:53 -07:00
package proto2
protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -07:00
protoc-gen-go: generate imports consistent with previous protoc-gen-go Include references to the proto, fmt, and math packages, consistent with the ones in the previous generator: // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf Sort imports with ast.SortImports to ensure gofmt-compatible output. Copy the protoc-gen-go/testdata/imports test files from github.com/golang/protobuf. Change-Id: I263e2ac750d03596ae9cb23609049d5ef1016205 Reviewed-on: https://go-review.googlesource.com/135361 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-13 13:12:36 -07:00
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 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"
protoc-gen-go: generate imports consistent with previous protoc-gen-go Include references to the proto, fmt, and math packages, consistent with the ones in the previous generator: // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf Sort imports with ast.SortImports to ensure gofmt-compatible output. Copy the protoc-gen-go/testdata/imports test files from github.com/golang/protobuf. Change-Id: I263e2ac750d03596ae9cb23609049d5ef1016205 Reviewed-on: https://go-review.googlesource.com/135361 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-13 13:12:36 -07:00
)
cmd/protoc-gen-go: reference proto.ProtoPackageIsVersionX Include the compile-time assertion that the generated file is compatible with the proto package it is being compiled against. Change-Id: Iefa27ee3a99a6669a93303b6674b0033794ba0be Reviewed-on: https://go-review.googlesource.com/134995 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 11:13:49 -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: reference proto.ProtoPackageIsVersionX Include the compile-time assertion that the generated file is compatible with the proto package it is being compiled against. Change-Id: Iefa27ee3a99a6669a93303b6674b0033794ba0be Reviewed-on: https://go-review.googlesource.com/134995 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 11:13:49 -07:00
protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -07:00
type Layer1 struct {
cmd/protoc-gen-go: generate message fields This produces exactly the same output as github.com/golang/protobuf. Change-Id: I01aacc9277c5cb5b4cc295f5ee8af12b4a524781 Reviewed-on: https://go-review.googlesource.com/134955 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-10 12:26:21 -07:00
L2 *Layer1_Layer2 `protobuf:"bytes,1,opt,name=l2" json:"l2,omitempty"`
L3 *Layer1_Layer2_Layer3 `protobuf:"bytes,2,opt,name=l3" json:"l3,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -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
type xxx_Layer1 struct{ m *Layer1 }
func (m *Layer1) ProtoReflect() protoreflect.Message {
return xxx_Layer1{m}
}
func (m xxx_Layer1) 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_NestedMessages_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_Layer1) 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_NestedMessages_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_Layer1) 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_NestedMessages_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_Layer1) Interface() protoreflect.ProtoMessage {
return m.m
}
cmd/protoc-gen-go: generate common message methods Generate the standard Reset, String, ProtoMessage, and Descriptor methods for each message struct. Generate the table-driven support methods (XXX_Marshal, et al.). Change-Id: I8a5ed8af1433b481e2458ad534456692d6f74c1f Reviewed-on: https://go-review.googlesource.com/134996 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 13:36:34 -07:00
func (m *Layer1) Reset() { *m = Layer1{} }
func (m *Layer1) String() string { return proto.CompactTextString(m) }
func (*Layer1) ProtoMessage() {}
func (*Layer1) Descriptor() ([]byte, []int) {
return fileDescriptor_7417ee157699d191, []int{0}
}
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 15:41:11 -07:00
cmd/protoc-gen-go: generate common message methods Generate the standard Reset, String, ProtoMessage, and Descriptor methods for each message struct. Generate the table-driven support methods (XXX_Marshal, et al.). Change-Id: I8a5ed8af1433b481e2458ad534456692d6f74c1f Reviewed-on: https://go-review.googlesource.com/134996 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 13:36:34 -07:00
func (m *Layer1) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Layer1.Unmarshal(m, b)
}
func (m *Layer1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Layer1.Marshal(b, m, deterministic)
}
func (m *Layer1) XXX_Merge(src proto.Message) {
xxx_messageInfo_Layer1.Merge(m, src)
}
func (m *Layer1) XXX_Size() int {
return xxx_messageInfo_Layer1.Size(m)
}
func (m *Layer1) XXX_DiscardUnknown() {
xxx_messageInfo_Layer1.DiscardUnknown(m)
}
var xxx_messageInfo_Layer1 proto.InternalMessageInfo
cmd/protoc-gen-go: generate getters Refactor fieldGoType to return the non-pointer type for scalar types (i.e., "int", not "*int"), and a bool indicating whether the struct field is a pointer to that type. Change-Id: Ic80220e92f0b190e41ead847440d57af5c6cc919 Reviewed-on: https://go-review.googlesource.com/135336 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-13 10:59:17 -07:00
func (m *Layer1) GetL2() *Layer1_Layer2 {
if m != nil {
return m.L2
}
return nil
}
func (m *Layer1) GetL3() *Layer1_Layer2_Layer3 {
if m != nil {
return m.L3
}
return nil
}
protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -07:00
type Layer1_Layer2 struct {
cmd/protoc-gen-go: generate message fields This produces exactly the same output as github.com/golang/protobuf. Change-Id: I01aacc9277c5cb5b4cc295f5ee8af12b4a524781 Reviewed-on: https://go-review.googlesource.com/134955 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-10 12:26:21 -07:00
L3 *Layer1_Layer2_Layer3 `protobuf:"bytes,1,opt,name=l3" json:"l3,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -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
type xxx_Layer1_Layer2 struct{ m *Layer1_Layer2 }
func (m *Layer1_Layer2) ProtoReflect() protoreflect.Message {
return xxx_Layer1_Layer2{m}
}
func (m xxx_Layer1_Layer2) 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_NestedMessages_protoFile_MessageTypes[1].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_Layer1_Layer2) 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_NestedMessages_protoFile_MessageTypes[1].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_Layer1_Layer2) 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_NestedMessages_protoFile_MessageTypes[1].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_Layer1_Layer2) Interface() protoreflect.ProtoMessage {
return m.m
}
cmd/protoc-gen-go: generate common message methods Generate the standard Reset, String, ProtoMessage, and Descriptor methods for each message struct. Generate the table-driven support methods (XXX_Marshal, et al.). Change-Id: I8a5ed8af1433b481e2458ad534456692d6f74c1f Reviewed-on: https://go-review.googlesource.com/134996 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 13:36:34 -07:00
func (m *Layer1_Layer2) Reset() { *m = Layer1_Layer2{} }
func (m *Layer1_Layer2) String() string { return proto.CompactTextString(m) }
func (*Layer1_Layer2) ProtoMessage() {}
func (*Layer1_Layer2) Descriptor() ([]byte, []int) {
return fileDescriptor_7417ee157699d191, []int{0, 0}
}
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 15:41:11 -07:00
cmd/protoc-gen-go: generate common message methods Generate the standard Reset, String, ProtoMessage, and Descriptor methods for each message struct. Generate the table-driven support methods (XXX_Marshal, et al.). Change-Id: I8a5ed8af1433b481e2458ad534456692d6f74c1f Reviewed-on: https://go-review.googlesource.com/134996 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 13:36:34 -07:00
func (m *Layer1_Layer2) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Layer1_Layer2.Unmarshal(m, b)
}
func (m *Layer1_Layer2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Layer1_Layer2.Marshal(b, m, deterministic)
}
func (m *Layer1_Layer2) XXX_Merge(src proto.Message) {
xxx_messageInfo_Layer1_Layer2.Merge(m, src)
}
func (m *Layer1_Layer2) XXX_Size() int {
return xxx_messageInfo_Layer1_Layer2.Size(m)
}
func (m *Layer1_Layer2) XXX_DiscardUnknown() {
xxx_messageInfo_Layer1_Layer2.DiscardUnknown(m)
}
var xxx_messageInfo_Layer1_Layer2 proto.InternalMessageInfo
cmd/protoc-gen-go: generate getters Refactor fieldGoType to return the non-pointer type for scalar types (i.e., "int", not "*int"), and a bool indicating whether the struct field is a pointer to that type. Change-Id: Ic80220e92f0b190e41ead847440d57af5c6cc919 Reviewed-on: https://go-review.googlesource.com/135336 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-13 10:59:17 -07:00
func (m *Layer1_Layer2) GetL3() *Layer1_Layer2_Layer3 {
if m != nil {
return m.L3
}
return nil
}
protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -07:00
type Layer1_Layer2_Layer3 struct {
cmd/protoc-gen-go: generate message fields This produces exactly the same output as github.com/golang/protobuf. Change-Id: I01aacc9277c5cb5b4cc295f5ee8af12b4a524781 Reviewed-on: https://go-review.googlesource.com/134955 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-10 12:26:21 -07:00
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
protogen: generate message skeletons Copy generator.CamelCase for camel-casing names, with one change: Convert '.' in names to '_'. This removes the need for the CamelCaseSlice function which operates on a []string representing a name split along '.'s. Add protogen.Message. Reformat generated code. Add regenerate.bash, largely copied from regenerate.sh. Change-Id: Iecf0bfc43b552f53e458499a328b933b0c9c5f82 Reviewed-on: https://go-review.googlesource.com/130915 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-08-22 13:46:02 -07:00
}
cmd/protoc-gen-go: register FileDescriptorProto Generate the gzipped FileDescriptorProto var, and register it with proto.RegisterFile at init time. Change-Id: Ie232f20412ca9cd7bde91aaba7127dc181e9758c Reviewed-on: https://go-review.googlesource.com/134118 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-07 14:14:06 -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
type xxx_Layer1_Layer2_Layer3 struct{ m *Layer1_Layer2_Layer3 }
func (m *Layer1_Layer2_Layer3) ProtoReflect() protoreflect.Message {
return xxx_Layer1_Layer2_Layer3{m}
}
func (m xxx_Layer1_Layer2_Layer3) 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_NestedMessages_protoFile_MessageTypes[2].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_Layer1_Layer2_Layer3) 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_NestedMessages_protoFile_MessageTypes[2].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_Layer1_Layer2_Layer3) 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_NestedMessages_protoFile_MessageTypes[2].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_Layer1_Layer2_Layer3) Interface() protoreflect.ProtoMessage {
return m.m
}
cmd/protoc-gen-go: generate common message methods Generate the standard Reset, String, ProtoMessage, and Descriptor methods for each message struct. Generate the table-driven support methods (XXX_Marshal, et al.). Change-Id: I8a5ed8af1433b481e2458ad534456692d6f74c1f Reviewed-on: https://go-review.googlesource.com/134996 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 13:36:34 -07:00
func (m *Layer1_Layer2_Layer3) Reset() { *m = Layer1_Layer2_Layer3{} }
func (m *Layer1_Layer2_Layer3) String() string { return proto.CompactTextString(m) }
func (*Layer1_Layer2_Layer3) ProtoMessage() {}
func (*Layer1_Layer2_Layer3) Descriptor() ([]byte, []int) {
return fileDescriptor_7417ee157699d191, []int{0, 0, 0}
}
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 15:41:11 -07:00
cmd/protoc-gen-go: generate common message methods Generate the standard Reset, String, ProtoMessage, and Descriptor methods for each message struct. Generate the table-driven support methods (XXX_Marshal, et al.). Change-Id: I8a5ed8af1433b481e2458ad534456692d6f74c1f Reviewed-on: https://go-review.googlesource.com/134996 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-12 13:36:34 -07:00
func (m *Layer1_Layer2_Layer3) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Layer1_Layer2_Layer3.Unmarshal(m, b)
}
func (m *Layer1_Layer2_Layer3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Layer1_Layer2_Layer3.Marshal(b, m, deterministic)
}
func (m *Layer1_Layer2_Layer3) XXX_Merge(src proto.Message) {
xxx_messageInfo_Layer1_Layer2_Layer3.Merge(m, src)
}
func (m *Layer1_Layer2_Layer3) XXX_Size() int {
return xxx_messageInfo_Layer1_Layer2_Layer3.Size(m)
}
func (m *Layer1_Layer2_Layer3) XXX_DiscardUnknown() {
xxx_messageInfo_Layer1_Layer2_Layer3.DiscardUnknown(m)
}
var xxx_messageInfo_Layer1_Layer2_Layer3 proto.InternalMessageInfo
cmd/protoc-gen-go: register messages and map field types Move generation of the init function that registers all the types in a file into a single function. Take some care to generate the registrations in the same order as the previous protoc-gen-go, to make it easier to catch unintended differences in output. For the same reason, adjust the order of generation to generate all enums before all messages (matches previous behavior). Change-Id: Ie0d574004d01a16f8d7b10be3882719a3c41676e Reviewed-on: https://go-review.googlesource.com/135359 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-13 15:19:08 -07:00
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("proto2/nested_messages.proto", fileDescriptor_7417ee157699d191)
cmd/protoc-gen-go: register messages and map field types Move generation of the init function that registers all the types in a file into a single function. Take some care to generate the registrations in the same order as the previous protoc-gen-go, to make it easier to catch unintended differences in output. For the same reason, adjust the order of generation to generate all enums before all messages (matches previous behavior). Change-Id: Ie0d574004d01a16f8d7b10be3882719a3c41676e Reviewed-on: https://go-review.googlesource.com/135359 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-13 15:19:08 -07:00
proto.RegisterType((*Layer1)(nil), "goproto.protoc.proto2.Layer1")
proto.RegisterType((*Layer1_Layer2)(nil), "goproto.protoc.proto2.Layer1.Layer2")
proto.RegisterType((*Layer1_Layer2_Layer3)(nil), "goproto.protoc.proto2.Layer1.Layer2.Layer3")
}
cmd/protoc-gen-go: register FileDescriptorProto Generate the gzipped FileDescriptorProto var, and register it with proto.RegisterFile at init time. Change-Id: Ie232f20412ca9cd7bde91aaba7127dc181e9758c Reviewed-on: https://go-review.googlesource.com/134118 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-07 14:14:06 -07:00
var fileDescriptor_7417ee157699d191 = []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 13:21:58 -07:00
// 190 bytes of a gzipped FileDescriptorProto
cmd/protoc-gen-go: register FileDescriptorProto Generate the gzipped FileDescriptorProto var, and register it with proto.RegisterFile at init time. Change-Id: Ie232f20412ca9cd7bde91aaba7127dc181e9758c Reviewed-on: https://go-review.googlesource.com/134118 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-07 14:14:06 -07:00
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x29, 0x28, 0xca, 0x2f,
0xc9, 0x37, 0xd2, 0xcf, 0x4b, 0x2d, 0x2e, 0x49, 0x4d, 0x89, 0xcf, 0x4d, 0x2d, 0x2e, 0x4e, 0x4c,
0x4f, 0x2d, 0xd6, 0x03, 0x0b, 0x0b, 0x89, 0xa6, 0xe7, 0x83, 0x19, 0x10, 0x6e, 0x32, 0x84, 0x32,
0x52, 0x3a, 0xc3, 0xc8, 0xc5, 0xe6, 0x93, 0x58, 0x99, 0x5a, 0x64, 0x28, 0x64, 0xc2, 0xc5, 0x94,
0x63, 0x24, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0xa4, 0xa2, 0x87, 0x55, 0xb9, 0x1e, 0x44, 0x29,
0x84, 0x32, 0x0a, 0x62, 0xca, 0x31, 0x12, 0xb2, 0xe6, 0x62, 0xca, 0x31, 0x96, 0x60, 0x02, 0xeb,
0xd2, 0x26, 0x46, 0x17, 0x84, 0x32, 0x0e, 0x62, 0xca, 0x31, 0x96, 0xf2, 0x87, 0x5a, 0x0e, 0x33,
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 13:21:58 -07:00
0x86, 0x91, 0x3c, 0x63, 0x38, 0xa0, 0xc6, 0x18, 0x3b, 0x39, 0x46, 0xd9, 0xa7, 0x67, 0x96, 0x64,
0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5, 0xeb, 0x83, 0xb5,
0x27, 0x95, 0xa6, 0xe9, 0x97, 0x19, 0xe9, 0x27, 0xe7, 0xa6, 0x40, 0xf8, 0xc9, 0xba, 0xe9, 0xa9,
0x79, 0xba, 0xe9, 0xf9, 0xfa, 0x25, 0xa9, 0xc5, 0x25, 0x29, 0x89, 0x25, 0x89, 0x10, 0x61, 0x23,
0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x11, 0x21, 0xb0, 0x06, 0x47, 0x01, 0x00, 0x00,
cmd/protoc-gen-go: register FileDescriptorProto Generate the gzipped FileDescriptorProto var, and register it with proto.RegisterFile at init time. Change-Id: Ie232f20412ca9cd7bde91aaba7127dc181e9758c Reviewed-on: https://go-review.googlesource.com/134118 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-07 14:14:06 -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_NestedMessages_protoFile_FileDesc.Messages = xxx_NestedMessages_protoFile_MessageDescs[0:1]
xxx_NestedMessages_protoFile_MessageDescs[0].Messages = xxx_NestedMessages_protoFile_MessageDescs[1:2]
xxx_NestedMessages_protoFile_MessageDescs[1].Messages = xxx_NestedMessages_protoFile_MessageDescs[2:3]
xxx_NestedMessages_protoFile_MessageDescs[0].Fields[0].MessageType = xxx_NestedMessages_protoFile_MessageTypes[1].Type
xxx_NestedMessages_protoFile_MessageDescs[0].Fields[1].MessageType = xxx_NestedMessages_protoFile_MessageTypes[2].Type
xxx_NestedMessages_protoFile_MessageDescs[1].Fields[0].MessageType = xxx_NestedMessages_protoFile_MessageTypes[2].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
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
NestedMessages_protoFile, err = prototype.NewFile(&xxx_NestedMessages_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 NestedMessages_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_NestedMessages_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: "proto2/nested_messages.proto",
Package: "goproto.protoc.proto2",
}
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_NestedMessages_protoFile_MessageTypes = [3]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_NestedMessages_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_Layer1{new(Layer1)}
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_NestedMessages_protoFile_MessageDescs[1].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_Layer1_Layer2{new(Layer1_Layer2)}
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_NestedMessages_protoFile_MessageDescs[2].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_Layer1_Layer2_Layer3{new(Layer1_Layer2_Layer3)}
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_NestedMessages_protoFile_MessageDescs = [3]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: "Layer1",
Fields: []prototype.Field{
{
Name: "l2",
Number: 1,
Cardinality: protoreflect.Optional,
Kind: protoreflect.MessageKind,
JSONName: "l2",
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: "l3",
Number: 2,
Cardinality: protoreflect.Optional,
Kind: protoreflect.MessageKind,
JSONName: "l3",
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: "Layer2",
Fields: []prototype.Field{
{
Name: "l3",
Number: 1,
Cardinality: protoreflect.Optional,
Kind: protoreflect.MessageKind,
JSONName: "l3",
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: "Layer3",
},
}
Reference in New Issue Copy Permalink