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

507 lines
17 KiB
Go
Raw Normal View History

cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: import_public/sub/a.proto
package sub
import (
all: change module to google.golang.org/protobuf Temporarily remove go.mod, since we can't generate an accurate one until the corresponding v1 change is submitted. Change-Id: I1e1ad97f2b455e33f61ffaeb8676289795e47e72 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/177000 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-05-13 23:55:40 -07:00
sub2 "google.golang.org/protobuf/cmd/protoc-gen-go/testdata/import_public/sub2"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoregistry "google.golang.org/protobuf/reflect/protoregistry"
protoiface "google.golang.org/protobuf/runtime/protoiface"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
math "math"
cmd/protoc-gen-go: lazily GZIP-encode the raw descriptor This reduces the init-time cost slightly since the GZIP'd raw descriptor is constructed lazily on demand. Change-Id: I482c6a2201b8786e425d7dee5612fdfd60ab1500 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169917 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-28 01:13:26 -07:00
sync "sync"
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
)
cmd/protoc-gen-go, runtime/protoimpl: enforce minimum and maximum versions Generate the needed infrastructure to ensure that we can statically enforce minimum and maximum versions. This enables us to have a policy when we release v2 where it fails to build for: * new generated code with really old runtimes * new runtimes with really old generated code Change-Id: Ib699ad62c06dff8f9285806394a741c18db00288 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/178546 Reviewed-by: Damien Neil <dneil@google.com>
2019-05-22 16:27:51 -04:00
const (
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 0)
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(0 - protoimpl.MinVersion)
)
cmd/protoc-gen-go: lazily GZIP-encode the raw descriptor This reduces the init-time cost slightly since the GZIP'd raw descriptor is constructed lazily on demand. Change-Id: I482c6a2201b8786e425d7dee5612fdfd60ab1500 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169917 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-28 01:13:26 -07:00
cmd/protoc-gen-go: add additional import public test case New test case demonstrating an import public bug: a.proto publicly imports b.proto and c.proto b.proto publicly imports c.proto a.pb.go includes two copies of symbols in c.pb.go The problem is that the new implementation of public imports, which parses the generated code for the import to determine what symbols are present, doesn't distinguish between symbols defined in a file and symbols imported from a public import of some other file. This can then lead to duplicate definitions in cases like the above. Change-Id: Ia86e9f188d7bae8d9d4afbd2b5db9b64071425c3 Reviewed-on: https://go-review.googlesource.com/c/156347 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-01-06 16:22:13 -08:00
// Symbols defined in public import of import_public/sub2/a.proto
type Sub2Message = sub2.Sub2Message
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
type E int32
const (
E_ZERO E = 0
)
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use E.Type.Values instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
var E_name = map[int32]string{
0: "ZERO",
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use E.Type.Values instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
var E_value = map[string]int32{
"ZERO": 0,
}
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
func (x E) Enum() *E {
cmd/protoc-gen-go: revert Enum simplication Go1.12 on GoLLVM with LLVM 9.0.0 has a bug where the simpler but equivalent expression results in memory corruption. Revert to the more complex expression to avoid breaking GoLLVM and it is not worth waiting for a GoLLVM fix. Change-Id: I8b42965ca9bd333deb8693021e7b22f966e13521 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/171463 Reviewed-by: Damien Neil <dneil@google.com>
2019-04-10 15:29:01 -07:00
p := new(E)
*p = x
return p
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (x E) String() string {
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
func (E) Descriptor() protoreflect.EnumDescriptor {
return file_import_public_sub_a_proto_enumTypes[0].Descriptor()
}
// Deprecated: Use Descriptor instead.
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (E) Type() protoreflect.EnumType {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_enumTypes[0]
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
}
func (x E) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Do not use.
func (x *E) UnmarshalJSON(b []byte) error {
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
if err != nil {
return err
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
*x = E(num)
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
return nil
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use E.Type instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (E) EnumDescriptor() ([]byte, []int) {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_rawDescGZIP(), []int{0}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
type M_Subenum int32
const (
M_M_ZERO M_Subenum = 0
)
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M_Subenum.Type.Values instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
var M_Subenum_name = map[int32]string{
0: "M_ZERO",
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M_Subenum.Type.Values instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
var M_Subenum_value = map[string]int32{
"M_ZERO": 0,
}
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
func (x M_Subenum) Enum() *M_Subenum {
cmd/protoc-gen-go: revert Enum simplication Go1.12 on GoLLVM with LLVM 9.0.0 has a bug where the simpler but equivalent expression results in memory corruption. Revert to the more complex expression to avoid breaking GoLLVM and it is not worth waiting for a GoLLVM fix. Change-Id: I8b42965ca9bd333deb8693021e7b22f966e13521 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/171463 Reviewed-by: Damien Neil <dneil@google.com>
2019-04-10 15:29:01 -07:00
p := new(M_Subenum)
*p = x
return p
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (x M_Subenum) String() string {
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (M_Subenum) Descriptor() protoreflect.EnumDescriptor {
return file_import_public_sub_a_proto_enumTypes[1].Descriptor()
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
// Deprecated: Use Descriptor instead.
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (M_Subenum) Type() protoreflect.EnumType {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_enumTypes[1]
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
}
func (x M_Subenum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Do not use.
func (x *M_Subenum) UnmarshalJSON(b []byte) error {
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
if err != nil {
return err
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
*x = M_Subenum(num)
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
return nil
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M_Subenum.Type instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (M_Subenum) EnumDescriptor() ([]byte, []int) {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_rawDescGZIP(), []int{0, 0}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
type M_Submessage_Submessage_Subenum int32
const (
M_Submessage_M_SUBMESSAGE_ZERO M_Submessage_Submessage_Subenum = 0
)
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M_Submessage_Submessage_Subenum.Type.Values instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
var M_Submessage_Submessage_Subenum_name = map[int32]string{
0: "M_SUBMESSAGE_ZERO",
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M_Submessage_Submessage_Subenum.Type.Values instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
var M_Submessage_Submessage_Subenum_value = map[string]int32{
"M_SUBMESSAGE_ZERO": 0,
}
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
func (x M_Submessage_Submessage_Subenum) Enum() *M_Submessage_Submessage_Subenum {
cmd/protoc-gen-go: revert Enum simplication Go1.12 on GoLLVM with LLVM 9.0.0 has a bug where the simpler but equivalent expression results in memory corruption. Revert to the more complex expression to avoid breaking GoLLVM and it is not worth waiting for a GoLLVM fix. Change-Id: I8b42965ca9bd333deb8693021e7b22f966e13521 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/171463 Reviewed-by: Damien Neil <dneil@google.com>
2019-04-10 15:29:01 -07:00
p := new(M_Submessage_Submessage_Subenum)
*p = x
return p
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (x M_Submessage_Submessage_Subenum) String() string {
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (M_Submessage_Submessage_Subenum) Descriptor() protoreflect.EnumDescriptor {
return file_import_public_sub_a_proto_enumTypes[2].Descriptor()
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
// Deprecated: Use Descriptor instead.
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (M_Submessage_Submessage_Subenum) Type() protoreflect.EnumType {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_enumTypes[2]
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
}
func (x M_Submessage_Submessage_Subenum) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Do not use.
func (x *M_Submessage_Submessage_Subenum) UnmarshalJSON(b []byte) error {
reflect/protoreflect: add Descriptor specific methods Added methods: Enum.Descriptor Message.Descriptor EnumType.Descriptor MessageType.Descriptor ExtensionType.Descriptor Message.New All functionality is switched over to use those methods instead of implicitly relying on the fact that {Enum,Message}Type implicitly implement the associated descriptor interface. This CL does not yet remove {Enum,Message}.Type or prevent {Enum,Message,Extension}Type from implementating a descriptor. That is a subsequent CL. The Message.New method is also added to replace functionality that will be lost when the Type methods are removed. Change-Id: I7fefde1673bbd40bfdac489aca05cec9a6c98eb1 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/174918 Reviewed-by: Damien Neil <dneil@google.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-05-01 12:29:25 -07:00
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
if err != nil {
return err
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
*x = M_Submessage_Submessage_Subenum(num)
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
return nil
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M_Submessage_Submessage_Subenum.Type instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (M_Submessage_Submessage_Subenum) EnumDescriptor() ([]byte, []int) {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_rawDescGZIP(), []int{0, 0, 0}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
type M struct {
// Field using a type in the same Go package, but a different source file.
cmd/protoc-gen-go: fix forwarding decls for inf and NaN defaults Floating-point defaults of -inf, +inf, and NaN must be generated as vars rather than consts. Fix the forwarding declaration for public imports of these vars. (Was "const", is now "var".) Change-Id: Ic6dc90ab7f88378ba477bff39e047de5f5193c35 Reviewed-on: https://go-review.googlesource.com/c/151757 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-11-29 08:57:07 -08:00
M2 *M2 `protobuf:"bytes,1,opt,name=m2" json:"m2,omitempty"`
S *string `protobuf:"bytes,4,opt,name=s,def=default" json:"s,omitempty"`
B []byte `protobuf:"bytes,5,opt,name=b,def=default" json:"b,omitempty"`
F *float64 `protobuf:"fixed64,6,opt,name=f,def=nan" json:"f,omitempty"`
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
// Types that are valid to be assigned to OneofField:
// *M_OneofInt32
// *M_OneofInt64
cmd/protoc-gen-go: used named types for special fields Using a named fields gives us the flexibility to change the underlying representation of special fields without needing to regenerate user code. We add a named type for ExtensionFields, UnknownFields, and SizeCache. Change-Id: I107cf82899850ea76665310ce79def60f0f7ab97 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172402 Reviewed-by: Damien Neil <dneil@google.com>
2019-04-16 13:22:20 -07:00
OneofField isM_OneofField `protobuf_oneof:"oneof_field"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_InternalExtensions protoimpl.ExtensionFields `json:"-"`
XXX_unrecognized protoimpl.UnknownFields `json:"-"`
XXX_sizecache protoimpl.SizeCache `json:"-"`
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M) Reset() {
*x = M{}
}
func (x *M) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*M) ProtoMessage() {}
func (x *M) ProtoReflect() protoreflect.Message {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_msgTypes[0].MessageOf(x)
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
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
proto, runtime/protoiface: add support for fast-path marshaling Allow message implementations to provide optimized versions of standard operations. Generated messages now include a ProtoReflectMethods method, returning a protoiface.Methods struct containing pointers to assorted optional functions. The Methods struct also includes a Flags field indicating support for optional features such as deterministic marshaling. Implementation of the fast paths (and tests) will come in later CLs. Change-Id: Idd1beed0ecf43ec5e5e7b8da2ee1e08d3ce32213 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170340 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-04-01 13:31:55 -07:00
func (m *M) XXX_Methods() *protoiface.Methods {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_msgTypes[0].Methods()
proto, runtime/protoiface: add support for fast-path marshaling Allow message implementations to provide optimized versions of standard operations. Generated messages now include a ProtoReflectMethods method, returning a protoiface.Methods struct containing pointers to assorted optional functions. The Methods struct also includes a Flags field indicating support for optional features such as deterministic marshaling. Implementation of the fast paths (and tests) will come in later CLs. Change-Id: Idd1beed0ecf43ec5e5e7b8da2ee1e08d3ce32213 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170340 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-04-01 13:31:55 -07:00
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M.ProtoReflect.Type instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (*M) Descriptor() ([]byte, []int) {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_rawDescGZIP(), []int{0}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
all: move v1 types over to the v2 repository As a goal, v2 should not depend on v1. As another step towards that end, we move all the types that used to be in the v1 protoapi package over to v2. For now, we place MessageV1, ExtensionRangeV1, and ExtensionDescV1 in runtime/protoiface since these are types that generated messages will probably have to reference forever. An alternative location could be reflect/protoreflect, but it seems unfortunate to have to dirty the namespace of that package with these types. We move ExtensionFieldV1, ExtensionFieldsV1, and ExtensionFieldsOf to internal/impl, since these are related to the implementation of a generated message. Since moving these types from v1 to v2 implies that the v1 protoapi package is useless, we update all usages of v1 protoapi in the v2 repository to point to the relevant v2 type or functionality. CL/168538 is the corresponding change to alter v1. There will be a temporary build failure as it is not possible to submit CL/168519 and CL/168538 atomically. Change-Id: Ide4025c1b6af5b7f0696f4b65b988b4d10a50f0b Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/168519 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-20 18:29:32 -07:00
var extRange_M = []protoiface.ExtensionRangeV1{
cmd/protoc-gen-go: generate forwarding decls for ExtensionDescs When publicly importing a package with extension definitions, generate forwarding declarations for the "E_..." ExtensionDesc var: var E_ExtensionField = publicimport.E_ExtensionField Change-Id: Ifd57c487c3a44f303c2c098a42ea249b219b734f Reviewed-on: https://go-review.googlesource.com/c/145498 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-29 09:14:14 -07:00
{Start: 100, End: 536870911},
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M.ProtoReflect.Type.ExtensionRanges instead.
all: move v1 types over to the v2 repository As a goal, v2 should not depend on v1. As another step towards that end, we move all the types that used to be in the v1 protoapi package over to v2. For now, we place MessageV1, ExtensionRangeV1, and ExtensionDescV1 in runtime/protoiface since these are types that generated messages will probably have to reference forever. An alternative location could be reflect/protoreflect, but it seems unfortunate to have to dirty the namespace of that package with these types. We move ExtensionFieldV1, ExtensionFieldsV1, and ExtensionFieldsOf to internal/impl, since these are related to the implementation of a generated message. Since moving these types from v1 to v2 implies that the v1 protoapi package is useless, we update all usages of v1 protoapi in the v2 repository to point to the relevant v2 type or functionality. CL/168538 is the corresponding change to alter v1. There will be a temporary build failure as it is not possible to submit CL/168519 and CL/168538 atomically. Change-Id: Ide4025c1b6af5b7f0696f4b65b988b4d10a50f0b Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/168519 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-20 18:29:32 -07:00
func (*M) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
cmd/protoc-gen-go: generate forwarding decls for ExtensionDescs When publicly importing a package with extension definitions, generate forwarding declarations for the "E_..." ExtensionDesc var: var E_ExtensionField = publicimport.E_ExtensionField Change-Id: Ifd57c487c3a44f303c2c098a42ea249b219b734f Reviewed-on: https://go-review.googlesource.com/c/145498 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-29 09:14:14 -07:00
return extRange_M
}
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
const Default_M_S string = "default"
cmd/protoc-gen-go: fix forwarding decls for inf and NaN defaults Floating-point defaults of -inf, +inf, and NaN must be generated as vars rather than consts. Fix the forwarding declaration for public imports of these vars. (Was "const", is now "var".) Change-Id: Ic6dc90ab7f88378ba477bff39e047de5f5193c35 Reviewed-on: https://go-review.googlesource.com/c/151757 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-11-29 08:57:07 -08:00
var Default_M_B []byte = []byte("default")
var Default_M_F float64 = math.NaN()
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M) GetM2() *M2 {
if x != nil {
return x.M2
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
return nil
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M) GetS() string {
if x != nil && x.S != nil {
return *x.S
cmd/protoc-gen-go: import public: forward default const/vars Generate forwarders for default value const/vars defined in public imports: const Default_Message_Field = pubimport.Default_Message_Field Change-Id: Ife09e38ae6a674b4460dd6613a8264e23f30b277 Reviewed-on: https://go-review.googlesource.com/c/140897 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-10-09 12:49:13 -07:00
}
return Default_M_S
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M) GetB() []byte {
if x != nil && x.B != nil {
return x.B
cmd/protoc-gen-go: fix forwarding decls for inf and NaN defaults Floating-point defaults of -inf, +inf, and NaN must be generated as vars rather than consts. Fix the forwarding declaration for public imports of these vars. (Was "const", is now "var".) Change-Id: Ic6dc90ab7f88378ba477bff39e047de5f5193c35 Reviewed-on: https://go-review.googlesource.com/c/151757 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-11-29 08:57:07 -08:00
}
return append([]byte(nil), Default_M_B...)
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M) GetF() float64 {
if x != nil && x.F != nil {
return *x.F
cmd/protoc-gen-go: fix forwarding decls for inf and NaN defaults Floating-point defaults of -inf, +inf, and NaN must be generated as vars rather than consts. Fix the forwarding declaration for public imports of these vars. (Was "const", is now "var".) Change-Id: Ic6dc90ab7f88378ba477bff39e047de5f5193c35 Reviewed-on: https://go-review.googlesource.com/c/151757 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-11-29 08:57:07 -08:00
}
return Default_M_F
}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (m *M) GetOneofField() isM_OneofField {
if m != nil {
return m.OneofField
}
return nil
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M) GetOneofInt32() int32 {
if x, ok := x.GetOneofField().(*M_OneofInt32); ok {
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
return x.OneofInt32
}
return 0
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M) GetOneofInt64() int64 {
if x, ok := x.GetOneofField().(*M_OneofInt64); ok {
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
return x.OneofInt64
}
return 0
}
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
// XXX_OneofWrappers is for the internal use of the proto package.
func (*M) XXX_OneofWrappers() []interface{} {
return []interface{}{
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
(*M_OneofInt32)(nil),
(*M_OneofInt64)(nil),
}
}
cmd/protoc-gen-go: generate oneof types seperately Seperate out the generation of the oneof wrapper types from the code block that is about getter methods. Change-Id: Ief44ef953d0b5ad8c998a8542c830ca70468a3bf Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/171029 Reviewed-by: Damien Neil <dneil@google.com>
2019-04-08 14:03:15 -07:00
type isM_OneofField interface {
isM_OneofField()
}
type M_OneofInt32 struct {
OneofInt32 int32 `protobuf:"varint,2,opt,name=oneof_int32,json=oneofInt32,oneof"`
}
type M_OneofInt64 struct {
OneofInt64 int64 `protobuf:"varint,3,opt,name=oneof_int64,json=oneofInt64,oneof"`
}
func (*M_OneofInt32) isM_OneofField() {}
func (*M_OneofInt64) isM_OneofField() {}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
type M_Submessage struct {
// Types that are valid to be assigned to SubmessageOneofField:
// *M_Submessage_SubmessageOneofInt32
// *M_Submessage_SubmessageOneofInt64
SubmessageOneofField isM_Submessage_SubmessageOneofField `protobuf_oneof:"submessage_oneof_field"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
cmd/protoc-gen-go: used named types for special fields Using a named fields gives us the flexibility to change the underlying representation of special fields without needing to regenerate user code. We add a named type for ExtensionFields, UnknownFields, and SizeCache. Change-Id: I107cf82899850ea76665310ce79def60f0f7ab97 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172402 Reviewed-by: Damien Neil <dneil@google.com>
2019-04-16 13:22:20 -07:00
XXX_unrecognized protoimpl.UnknownFields `json:"-"`
XXX_sizecache protoimpl.SizeCache `json:"-"`
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M_Submessage) Reset() {
*x = M_Submessage{}
}
func (x *M_Submessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*M_Submessage) ProtoMessage() {}
func (x *M_Submessage) ProtoReflect() protoreflect.Message {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_msgTypes[1].MessageOf(x)
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
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
proto, runtime/protoiface: add support for fast-path marshaling Allow message implementations to provide optimized versions of standard operations. Generated messages now include a ProtoReflectMethods method, returning a protoiface.Methods struct containing pointers to assorted optional functions. The Methods struct also includes a Flags field indicating support for optional features such as deterministic marshaling. Implementation of the fast paths (and tests) will come in later CLs. Change-Id: Idd1beed0ecf43ec5e5e7b8da2ee1e08d3ce32213 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170340 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-04-01 13:31:55 -07:00
func (m *M_Submessage) XXX_Methods() *protoiface.Methods {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_msgTypes[1].Methods()
proto, runtime/protoiface: add support for fast-path marshaling Allow message implementations to provide optimized versions of standard operations. Generated messages now include a ProtoReflectMethods method, returning a protoiface.Methods struct containing pointers to assorted optional functions. The Methods struct also includes a Flags field indicating support for optional features such as deterministic marshaling. Implementation of the fast paths (and tests) will come in later CLs. Change-Id: Idd1beed0ecf43ec5e5e7b8da2ee1e08d3ce32213 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170340 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-04-01 13:31:55 -07:00
}
cmd/protoc-gen-go: rely on protoimpl for basic helpers The EnumName, UnmarshalJSONEnum, and CompressGZIP helpers currently live in v1 protoapi, which would cause all generated messages to depend on v1. In an effort to break the dependency of v2 on v1, we move these helper functions to v2 (and re-written to take advantage of protobuf reflection). These helpers are unfortunate, but we cannot eliminate the functionality that they implement since they are exposed in the publicly generated API. Since EnumName does not rely on the enum maps, it removes another dependency on those variables. Eventually, we can get to the point where these variables (though declared) are not linked into the binary if the user does not use them. Also, we rely on the v1 proto package for registration instead of v1 protoapi. This may re-introduce a cyclic dependency on descriptor proto again in the future, but the better approach is to just start registering with v2. Change-Id: Id755585a7a1df14e4a6a2dfa650df221a3c153fb Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167921 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-16 00:05:34 -07:00
// Deprecated: Use M_Submessage.ProtoReflect.Type instead.
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
func (*M_Submessage) Descriptor() ([]byte, []int) {
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_rawDescGZIP(), []int{0, 0}
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
}
func (m *M_Submessage) GetSubmessageOneofField() isM_Submessage_SubmessageOneofField {
if m != nil {
return m.SubmessageOneofField
}
return nil
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M_Submessage) GetSubmessageOneofInt32() int32 {
if x, ok := x.GetSubmessageOneofField().(*M_Submessage_SubmessageOneofInt32); ok {
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
return x.SubmessageOneofInt32
}
return 0
}
cmd/protoc-gen-go: perform some code cleanup Minor changes: * Use x as the receiver since "e" and "m" are meaningless in the presence of user-defined enum and message names. * Consistently keep enum methods together, rather awkwardly split apart by the value maps. Change-Id: I68e5666efb56ac7a4d062fb223b9f826dc72aba9 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/170357 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-01 12:59:24 -07:00
func (x *M_Submessage) GetSubmessageOneofInt64() int64 {
if x, ok := x.GetSubmessageOneofField().(*M_Submessage_SubmessageOneofInt64); ok {
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
return x.SubmessageOneofInt64
}
return 0
}
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
// XXX_OneofWrappers is for the internal use of the proto package.
func (*M_Submessage) XXX_OneofWrappers() []interface{} {
return []interface{}{
cmd/protoc-gen-go: generate public imports Generate forwarding declarations for all types, consts, and vars in publicly imported files. Change-Id: I2f1041fa91b0ae18b1e123935951618b8d594f84 Reviewed-on: https://go-review.googlesource.com/136175 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2018-09-17 15:11:24 -07:00
(*M_Submessage_SubmessageOneofInt32)(nil),
(*M_Submessage_SubmessageOneofInt64)(nil),
}
}
cmd/protoc-gen-go: generate oneof types seperately Seperate out the generation of the oneof wrapper types from the code block that is about getter methods. Change-Id: Ief44ef953d0b5ad8c998a8542c830ca70468a3bf Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/171029 Reviewed-by: Damien Neil <dneil@google.com>
2019-04-08 14:03:15 -07:00
type isM_Submessage_SubmessageOneofField interface {
isM_Submessage_SubmessageOneofField()
}
type M_Submessage_SubmessageOneofInt32 struct {
SubmessageOneofInt32 int32 `protobuf:"varint,1,opt,name=submessage_oneof_int32,json=submessageOneofInt32,oneof"`
}
type M_Submessage_SubmessageOneofInt64 struct {
SubmessageOneofInt64 int64 `protobuf:"varint,2,opt,name=submessage_oneof_int64,json=submessageOneofInt64,oneof"`
}
func (*M_Submessage_SubmessageOneofInt32) isM_Submessage_SubmessageOneofField() {}
func (*M_Submessage_SubmessageOneofInt64) isM_Submessage_SubmessageOneofField() {}
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
var file_import_public_sub_a_proto_extDescs = []protoiface.ExtensionDescV1{
cmd/protoc-gen-go: correlate v1 ExtensionDesc with v2 ExtensionType Unfortunately a good amount of code uses pointer comparisons on the v1 ExtensionDesc to determine exactly which extension field is set, rather than checking whether the extension descriptor semantically describes the field that they are interested in. To preserve this behavior in v1, we need a 1:1 mapping between a v2 ExtensionType and a specific v1 ExtensionDesc. Change-Id: I852b3cefb4585bd656e48e5adad6cc28795d02df Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167759 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-14 16:08:22 -07:00
{
ExtendedType: (*M)(nil),
ExtensionType: (*string)(nil),
Field: 100,
Name: "goproto.protoc.import_public.sub.extension_field",
Tag: "bytes,100,opt,name=extension_field",
Filename: "import_public/sub/a.proto",
},
}
var (
// extend goproto.protoc.import_public.sub.M { optional string extension_field = 100; }
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
E_ExtensionField = &file_import_public_sub_a_proto_extDescs[0]
cmd/protoc-gen-go: correlate v1 ExtensionDesc with v2 ExtensionType Unfortunately a good amount of code uses pointer comparisons on the v1 ExtensionDesc to determine exactly which extension field is set, rather than checking whether the extension descriptor semantically describes the field that they are interested in. To preserve this behavior in v1, we need a 1:1 mapping between a v2 ExtensionType and a specific v1 ExtensionDesc. Change-Id: I852b3cefb4585bd656e48e5adad6cc28795d02df Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/167759 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-14 16:08:22 -07:00
)
cmd/protoc-gen-go: lazily GZIP-encode the raw descriptor This reduces the init-time cost slightly since the GZIP'd raw descriptor is constructed lazily on demand. Change-Id: I482c6a2201b8786e425d7dee5612fdfd60ab1500 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169917 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-28 01:13:26 -07:00
var File_import_public_sub_a_proto protoreflect.FileDescriptor
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
var file_import_public_sub_a_proto_rawDesc = []byte{
internal/fileinit: generate reflect data structures from raw descriptors This CL takes a significantly different approach to generating support for protobuf reflection. The previous approach involved generating a large number of Go literals to represent the reflection information. While that approach was correct, it resulted in too much binary bloat. The approach taken here initializes the reflection information from the raw descriptor proto, which is a relatively dense representation of the protobuf reflection information. In order to keep initialization cost low, several measures were taken: * At program init, the bare minimum is parsed in order to initialize naming information for enums, messages, extensions, and services declared in the file. This is done because those top-level declarations are often relevant for registration. * Only upon first are most of the other data structures for protobuf reflection actually initialized. * Instead of using proto.Unmarshal, a hand-written unmarshaler is used. This allows us to avoid a dependendency on the descriptor proto and also because the API for the descriptor proto is fundamentally non-performant since it requires an allocation for every primitive field. At a high-level, the new implementation lives in internal/fileinit. Several changes were made to other parts of the repository: * cmd/protoc-gen-go: * Stop compressing the raw descriptors. While compression does reduce the size of the descriptors by approximately 2x, it is a pre-mature optimization since the descriptors themselves are around 1% of the total binary bloat that is due to generated protobufs. * Seeding protobuf reflection from the raw descriptor significantly simplifies the generator implementation since it is no longer responsible for constructing a tree of Go literals to represent the same information. * We remove the generation of the shadow types and instead call protoimpl.MessageType.MessageOf. Unfortunately, this incurs an allocation for every call to ProtoReflect since we need to allocate a tuple that wraps a pointer to the message value, and a pointer to message type. * internal/impl: * We add a MessageType.GoType field and make it required that it is set prior to first use. This is done so that we can avoid calling MessageType.init except for when it is actually needed. The allows code to call (*FooMessage)(nil).ProtoReflect().Type() without fearing that the init code will run, possibly triggering a recursive deadlock (where the init code depends on getting the Type of some dependency which may be declared within the same file). * internal/cmd/generate-types: * The code to generate reflect/prototype/protofile_list_gen.go was copied and altered to generated internal/fileinit.desc_list_gen.go. At a high-level this CL adds significant technical complexity. However, this is offset by several possible future changes: * The prototype package can be drastically simplified. We can probably reimplement internal/legacy to use internal/fileinit instead, allowing us to drop another dependency on the prototype package. As a result, we can probably delete most of the constructor types in that package. * With the prototype package significantly pruned, and the fact that generated code no longer depend on depends on that package, we can consider merging what's left of prototype into protodesc. Change-Id: I6090f023f2e1b6afaf62bd3ae883566242e30715 Reviewed-on: https://go-review.googlesource.com/c/158539 Reviewed-by: Herbie Ong <herbie@google.com> Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-01-18 09:32:24 -08:00
0x0a, 0x19, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f,
0x73, 0x75, 0x62, 0x2f, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x20, 0x67, 0x6f, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f,
0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62, 0x1a, 0x19, 0x69,
0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62,
0x2f, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74,
0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2f, 0x73, 0x75, 0x62, 0x32, 0x2f, 0x61, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb6, 0x03, 0x0a, 0x01, 0x4d, 0x12, 0x34, 0x0a, 0x02, 0x6d, 0x32,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73, 0x75, 0x62, 0x2e, 0x4d, 0x32, 0x52, 0x02, 0x6d, 0x32,
0x12, 0x15, 0x0a, 0x01, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x3a, 0x07, 0x64, 0x65, 0x66,
0x61, 0x75, 0x6c, 0x74, 0x52, 0x01, 0x73, 0x12, 0x15, 0x0a, 0x01, 0x62, 0x18, 0x05, 0x20, 0x01,
0x28, 0x0c, 0x3a, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x01, 0x62, 0x12, 0x11,
0x0a, 0x01, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x3a, 0x03, 0x6e, 0x61, 0x6e, 0x52, 0x01,
0x66, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32,
0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49,
0x6e, 0x74, 0x33, 0x32, 0x12, 0x21, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e,
0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x6f, 0x6e, 0x65,
0x6f, 0x66, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x1a, 0xc3, 0x01, 0x0a, 0x0a, 0x53, 0x75, 0x62, 0x6d,
0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x16, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73,
0x73, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32,
0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x14, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73,
0x73, 0x61, 0x67, 0x65, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x36,
0x0a, 0x16, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x6e, 0x65,
0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00,
0x52, 0x14, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x6e, 0x65, 0x6f,
0x66, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x22, 0x2b, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x65, 0x73,
0x73, 0x61, 0x67, 0x65, 0x5f, 0x53, 0x75, 0x62, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x15, 0x0a, 0x11,
0x4d, 0x5f, 0x53, 0x55, 0x42, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x5f, 0x5a, 0x45, 0x52,
0x4f, 0x10, 0x00, 0x42, 0x18, 0x0a, 0x16, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x5f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x22, 0x15, 0x0a,
0x07, 0x53, 0x75, 0x62, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x5f, 0x5a, 0x45,
0x52, 0x4f, 0x10, 0x00, 0x2a, 0x08, 0x08, 0x64, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x42, 0x0d,
0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2a, 0x0d, 0x0a,
0x01, 0x45, 0x12, 0x08, 0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x3a, 0x4c, 0x0a, 0x0f,
0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12,
0x23, 0x2e, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x2e, 0x73,
0x75, 0x62, 0x2e, 0x4d, 0x18, 0x64, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65,
all: change module to google.golang.org/protobuf Temporarily remove go.mod, since we can't generate an accurate one until the corresponding v1 change is submitted. Change-Id: I1e1ad97f2b455e33f61ffaeb8676289795e47e72 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/177000 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-05-13 23:55:40 -07:00
0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x49, 0x5a, 0x47, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, 0x6d, 0x64, 0x2f, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64,
0x61, 0x74, 0x61, 0x2f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x2f, 0x73, 0x75, 0x62, 0x50, 0x01,
internal/fileinit: generate reflect data structures from raw descriptors This CL takes a significantly different approach to generating support for protobuf reflection. The previous approach involved generating a large number of Go literals to represent the reflection information. While that approach was correct, it resulted in too much binary bloat. The approach taken here initializes the reflection information from the raw descriptor proto, which is a relatively dense representation of the protobuf reflection information. In order to keep initialization cost low, several measures were taken: * At program init, the bare minimum is parsed in order to initialize naming information for enums, messages, extensions, and services declared in the file. This is done because those top-level declarations are often relevant for registration. * Only upon first are most of the other data structures for protobuf reflection actually initialized. * Instead of using proto.Unmarshal, a hand-written unmarshaler is used. This allows us to avoid a dependendency on the descriptor proto and also because the API for the descriptor proto is fundamentally non-performant since it requires an allocation for every primitive field. At a high-level, the new implementation lives in internal/fileinit. Several changes were made to other parts of the repository: * cmd/protoc-gen-go: * Stop compressing the raw descriptors. While compression does reduce the size of the descriptors by approximately 2x, it is a pre-mature optimization since the descriptors themselves are around 1% of the total binary bloat that is due to generated protobufs. * Seeding protobuf reflection from the raw descriptor significantly simplifies the generator implementation since it is no longer responsible for constructing a tree of Go literals to represent the same information. * We remove the generation of the shadow types and instead call protoimpl.MessageType.MessageOf. Unfortunately, this incurs an allocation for every call to ProtoReflect since we need to allocate a tuple that wraps a pointer to the message value, and a pointer to message type. * internal/impl: * We add a MessageType.GoType field and make it required that it is set prior to first use. This is done so that we can avoid calling MessageType.init except for when it is actually needed. The allows code to call (*FooMessage)(nil).ProtoReflect().Type() without fearing that the init code will run, possibly triggering a recursive deadlock (where the init code depends on getting the Type of some dependency which may be declared within the same file). * internal/cmd/generate-types: * The code to generate reflect/prototype/protofile_list_gen.go was copied and altered to generated internal/fileinit.desc_list_gen.go. At a high-level this CL adds significant technical complexity. However, this is offset by several possible future changes: * The prototype package can be drastically simplified. We can probably reimplement internal/legacy to use internal/fileinit instead, allowing us to drop another dependency on the prototype package. As a result, we can probably delete most of the constructor types in that package. * With the prototype package significantly pruned, and the fact that generated code no longer depend on depends on that package, we can consider merging what's left of prototype into protodesc. Change-Id: I6090f023f2e1b6afaf62bd3ae883566242e30715 Reviewed-on: https://go-review.googlesource.com/c/158539 Reviewed-by: Herbie Ong <herbie@google.com> Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-01-18 09:32:24 -08:00
}
cmd/protoc-gen-go: lazily GZIP-encode the raw descriptor This reduces the init-time cost slightly since the GZIP'd raw descriptor is constructed lazily on demand. Change-Id: I482c6a2201b8786e425d7dee5612fdfd60ab1500 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169917 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-28 01:13:26 -07:00
var (
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
file_import_public_sub_a_proto_rawDescOnce sync.Once
file_import_public_sub_a_proto_rawDescData = file_import_public_sub_a_proto_rawDesc
cmd/protoc-gen-go: lazily GZIP-encode the raw descriptor This reduces the init-time cost slightly since the GZIP'd raw descriptor is constructed lazily on demand. Change-Id: I482c6a2201b8786e425d7dee5612fdfd60ab1500 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169917 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-28 01:13:26 -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
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
func file_import_public_sub_a_proto_rawDescGZIP() []byte {
file_import_public_sub_a_proto_rawDescOnce.Do(func() {
file_import_public_sub_a_proto_rawDescData = protoimpl.X.CompressGZIP(file_import_public_sub_a_proto_rawDescData)
cmd/protoc-gen-go: lazily GZIP-encode the raw descriptor This reduces the init-time cost slightly since the GZIP'd raw descriptor is constructed lazily on demand. Change-Id: I482c6a2201b8786e425d7dee5612fdfd60ab1500 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169917 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-28 01:13:26 -07:00
})
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
return file_import_public_sub_a_proto_rawDescData
cmd/protoc-gen-go: lazily GZIP-encode the raw descriptor This reduces the init-time cost slightly since the GZIP'd raw descriptor is constructed lazily on demand. Change-Id: I482c6a2201b8786e425d7dee5612fdfd60ab1500 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169917 Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-28 01:13:26 -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
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
var file_import_public_sub_a_proto_enumTypes = make([]protoreflect.EnumType, 3)
internal/impl: rename MessageType as MessageInfo The name MessageType is easily confused with protoreflect.MessageType. Rename it as MessageInfo, which follows the pattern set by v1, where the equivalent data structure is called InternalMessageInfo. Change-Id: I535956e1f7c6e9b07e9585e889d5e93388d0d2ce Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/178478 Reviewed-by: Damien Neil <dneil@google.com>
2019-05-22 05:12:36 -04:00
var file_import_public_sub_a_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
var file_import_public_sub_a_proto_goTypes = []interface{}{
internal/fileinit: generate reflect data structures from raw descriptors This CL takes a significantly different approach to generating support for protobuf reflection. The previous approach involved generating a large number of Go literals to represent the reflection information. While that approach was correct, it resulted in too much binary bloat. The approach taken here initializes the reflection information from the raw descriptor proto, which is a relatively dense representation of the protobuf reflection information. In order to keep initialization cost low, several measures were taken: * At program init, the bare minimum is parsed in order to initialize naming information for enums, messages, extensions, and services declared in the file. This is done because those top-level declarations are often relevant for registration. * Only upon first are most of the other data structures for protobuf reflection actually initialized. * Instead of using proto.Unmarshal, a hand-written unmarshaler is used. This allows us to avoid a dependendency on the descriptor proto and also because the API for the descriptor proto is fundamentally non-performant since it requires an allocation for every primitive field. At a high-level, the new implementation lives in internal/fileinit. Several changes were made to other parts of the repository: * cmd/protoc-gen-go: * Stop compressing the raw descriptors. While compression does reduce the size of the descriptors by approximately 2x, it is a pre-mature optimization since the descriptors themselves are around 1% of the total binary bloat that is due to generated protobufs. * Seeding protobuf reflection from the raw descriptor significantly simplifies the generator implementation since it is no longer responsible for constructing a tree of Go literals to represent the same information. * We remove the generation of the shadow types and instead call protoimpl.MessageType.MessageOf. Unfortunately, this incurs an allocation for every call to ProtoReflect since we need to allocate a tuple that wraps a pointer to the message value, and a pointer to message type. * internal/impl: * We add a MessageType.GoType field and make it required that it is set prior to first use. This is done so that we can avoid calling MessageType.init except for when it is actually needed. The allows code to call (*FooMessage)(nil).ProtoReflect().Type() without fearing that the init code will run, possibly triggering a recursive deadlock (where the init code depends on getting the Type of some dependency which may be declared within the same file). * internal/cmd/generate-types: * The code to generate reflect/prototype/protofile_list_gen.go was copied and altered to generated internal/fileinit.desc_list_gen.go. At a high-level this CL adds significant technical complexity. However, this is offset by several possible future changes: * The prototype package can be drastically simplified. We can probably reimplement internal/legacy to use internal/fileinit instead, allowing us to drop another dependency on the prototype package. As a result, we can probably delete most of the constructor types in that package. * With the prototype package significantly pruned, and the fact that generated code no longer depend on depends on that package, we can consider merging what's left of prototype into protodesc. Change-Id: I6090f023f2e1b6afaf62bd3ae883566242e30715 Reviewed-on: https://go-review.googlesource.com/c/158539 Reviewed-by: Herbie Ong <herbie@google.com> Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-01-18 09:32:24 -08:00
(E)(0), // 0: goproto.protoc.import_public.sub.E
(M_Subenum)(0), // 1: goproto.protoc.import_public.sub.M.Subenum
(M_Submessage_Submessage_Subenum)(0), // 2: goproto.protoc.import_public.sub.M.Submessage.Submessage_Subenum
(*M)(nil), // 3: goproto.protoc.import_public.sub.M
(*M_Submessage)(nil), // 4: goproto.protoc.import_public.sub.M.Submessage
(*M2)(nil), // 5: goproto.protoc.import_public.sub.M2
}
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
var file_import_public_sub_a_proto_depIdxs = []int32{
internal/fileinit: generate reflect data structures from raw descriptors This CL takes a significantly different approach to generating support for protobuf reflection. The previous approach involved generating a large number of Go literals to represent the reflection information. While that approach was correct, it resulted in too much binary bloat. The approach taken here initializes the reflection information from the raw descriptor proto, which is a relatively dense representation of the protobuf reflection information. In order to keep initialization cost low, several measures were taken: * At program init, the bare minimum is parsed in order to initialize naming information for enums, messages, extensions, and services declared in the file. This is done because those top-level declarations are often relevant for registration. * Only upon first are most of the other data structures for protobuf reflection actually initialized. * Instead of using proto.Unmarshal, a hand-written unmarshaler is used. This allows us to avoid a dependendency on the descriptor proto and also because the API for the descriptor proto is fundamentally non-performant since it requires an allocation for every primitive field. At a high-level, the new implementation lives in internal/fileinit. Several changes were made to other parts of the repository: * cmd/protoc-gen-go: * Stop compressing the raw descriptors. While compression does reduce the size of the descriptors by approximately 2x, it is a pre-mature optimization since the descriptors themselves are around 1% of the total binary bloat that is due to generated protobufs. * Seeding protobuf reflection from the raw descriptor significantly simplifies the generator implementation since it is no longer responsible for constructing a tree of Go literals to represent the same information. * We remove the generation of the shadow types and instead call protoimpl.MessageType.MessageOf. Unfortunately, this incurs an allocation for every call to ProtoReflect since we need to allocate a tuple that wraps a pointer to the message value, and a pointer to message type. * internal/impl: * We add a MessageType.GoType field and make it required that it is set prior to first use. This is done so that we can avoid calling MessageType.init except for when it is actually needed. The allows code to call (*FooMessage)(nil).ProtoReflect().Type() without fearing that the init code will run, possibly triggering a recursive deadlock (where the init code depends on getting the Type of some dependency which may be declared within the same file). * internal/cmd/generate-types: * The code to generate reflect/prototype/protofile_list_gen.go was copied and altered to generated internal/fileinit.desc_list_gen.go. At a high-level this CL adds significant technical complexity. However, this is offset by several possible future changes: * The prototype package can be drastically simplified. We can probably reimplement internal/legacy to use internal/fileinit instead, allowing us to drop another dependency on the prototype package. As a result, we can probably delete most of the constructor types in that package. * With the prototype package significantly pruned, and the fact that generated code no longer depend on depends on that package, we can consider merging what's left of prototype into protodesc. Change-Id: I6090f023f2e1b6afaf62bd3ae883566242e30715 Reviewed-on: https://go-review.googlesource.com/c/158539 Reviewed-by: Herbie Ong <herbie@google.com> Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-01-18 09:32:24 -08:00
3, // goproto.protoc.import_public.sub.extension_field:extendee -> goproto.protoc.import_public.sub.M
5, // goproto.protoc.import_public.sub.M.m2:type_name -> goproto.protoc.import_public.sub.M2
}
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
func init() { file_import_public_sub_a_proto_init() }
func file_import_public_sub_a_proto_init() {
cmd/protoc-gen-go: enforce init order within packages Ensure that the init funcs for files within a Go package run in the dependency order of the source .proto files. That is, if a.proto and b.proto are part of the same Go package, and a.proto imports b.proto, then b.pb.go's init funcs must run before a.pb.go's. Change-Id: I0e86ff22e5c4cab9df7a73fe4805390fadd34b0d Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/166419 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com> Reviewed-by: Herbie Ong <herbie@google.com>
2019-03-08 17:18:11 -08:00
if File_import_public_sub_a_proto != nil {
return
}
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
file_import_public_sub_b_proto_init()
cmd/protoc-gen-go: change some arrays to slices to save bytes Using arrays in the generated reflection information adds unnecessary eq and hash functions being added to the package. Change to slices to reduce bloat. Change-Id: I1a4f6d59021644d93dd6c24679b9233141e89a75 Reviewed-on: https://go-review.googlesource.com/c/164640 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-03-01 13:22:30 -08:00
extensionTypes := make([]protoreflect.ExtensionType, 1)
protogen: use full path for generated file variable name Use the full path (including the extension) for the generation of the per-file variable name. Several reasons for this: * The current logic is buggy in the case where pathType == pathTypeImport since the prefix variable will be mangled with the Go import path. * The extension is technically part of the path. Thus, "path/to/foo.proto" and "path/to/foo.protodevel" are two distinctly different imports. * Style-wise, it subjectively looks better. Rather than being a mixture of camelCase and snake_case, it is all snake_case for the common case: before: ProtoFile_google_protobuf_any after: File_google_protobuf_any_proto * Since the extension is almost always ".proto", this results in a suffix of "_proto", which provides an additional layer of protection against possible name conflicts. The previous approach could possibly have a conflict between "Foo.proto" and a message named ProtoFile with a sub-message called Foo. Also, use the per-file variable name for the raw descriptor variables instead of the hashed version. Change-Id: Ic91e326b7593e5985cee6ececc60539c27fe32fe Reviewed-on: https://go-review.googlesource.com/c/164379 Reviewed-by: Damien Neil <dneil@google.com>
2019-02-27 20:25:51 -08:00
File_import_public_sub_a_proto = protoimpl.FileBuilder{
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
RawDescriptor: file_import_public_sub_a_proto_rawDesc,
GoTypes: file_import_public_sub_a_proto_goTypes,
DependencyIndexes: file_import_public_sub_a_proto_depIdxs,
LegacyExtensions: file_import_public_sub_a_proto_extDescs,
EnumOutputTypes: file_import_public_sub_a_proto_enumTypes,
MessageOutputTypes: file_import_public_sub_a_proto_msgTypes,
cmd/protoc-gen-go: change some arrays to slices to save bytes Using arrays in the generated reflection information adds unnecessary eq and hash functions being added to the package. Change to slices to reduce bloat. Change-Id: I1a4f6d59021644d93dd6c24679b9233141e89a75 Reviewed-on: https://go-review.googlesource.com/c/164640 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-03-01 13:22:30 -08:00
ExtensionOutputTypes: extensionTypes,
cmd/protoc-gen-go: generate for v2-only dependencies This removes yet another set of dependencies of v2 on v1. The only remaining dependency are in the _test.go files, primarily for proto.Equal. Changes made: * cmd/protoc-gen-go no longer generates any functionality that depends on the v1 package, and instead only depends on v2. * internal/fileinit.FileBuilder.MessageOutputTypes is switched from protoreflect.MessageType to protoimpl.MessageType since the implementation must be fully inialized before registration occurs. * The test for internal/legacy/file_test.go is switched to a legacy_test package to avoid a cyclic dependency. This requires Load{Enum,Message,File}Desc to be exported. Change-Id: I43e2fe64cff4eea204258ce11e791aca5eb6e569 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/169298 Reviewed-by: Damien Neil <dneil@google.com>
2019-03-25 14:41:32 -07:00
FilesRegistry: protoregistry.GlobalFiles,
TypesRegistry: protoregistry.GlobalTypes,
internal/fileinit: generate reflect data structures from raw descriptors This CL takes a significantly different approach to generating support for protobuf reflection. The previous approach involved generating a large number of Go literals to represent the reflection information. While that approach was correct, it resulted in too much binary bloat. The approach taken here initializes the reflection information from the raw descriptor proto, which is a relatively dense representation of the protobuf reflection information. In order to keep initialization cost low, several measures were taken: * At program init, the bare minimum is parsed in order to initialize naming information for enums, messages, extensions, and services declared in the file. This is done because those top-level declarations are often relevant for registration. * Only upon first are most of the other data structures for protobuf reflection actually initialized. * Instead of using proto.Unmarshal, a hand-written unmarshaler is used. This allows us to avoid a dependendency on the descriptor proto and also because the API for the descriptor proto is fundamentally non-performant since it requires an allocation for every primitive field. At a high-level, the new implementation lives in internal/fileinit. Several changes were made to other parts of the repository: * cmd/protoc-gen-go: * Stop compressing the raw descriptors. While compression does reduce the size of the descriptors by approximately 2x, it is a pre-mature optimization since the descriptors themselves are around 1% of the total binary bloat that is due to generated protobufs. * Seeding protobuf reflection from the raw descriptor significantly simplifies the generator implementation since it is no longer responsible for constructing a tree of Go literals to represent the same information. * We remove the generation of the shadow types and instead call protoimpl.MessageType.MessageOf. Unfortunately, this incurs an allocation for every call to ProtoReflect since we need to allocate a tuple that wraps a pointer to the message value, and a pointer to message type. * internal/impl: * We add a MessageType.GoType field and make it required that it is set prior to first use. This is done so that we can avoid calling MessageType.init except for when it is actually needed. The allows code to call (*FooMessage)(nil).ProtoReflect().Type() without fearing that the init code will run, possibly triggering a recursive deadlock (where the init code depends on getting the Type of some dependency which may be declared within the same file). * internal/cmd/generate-types: * The code to generate reflect/prototype/protofile_list_gen.go was copied and altered to generated internal/fileinit.desc_list_gen.go. At a high-level this CL adds significant technical complexity. However, this is offset by several possible future changes: * The prototype package can be drastically simplified. We can probably reimplement internal/legacy to use internal/fileinit instead, allowing us to drop another dependency on the prototype package. As a result, we can probably delete most of the constructor types in that package. * With the prototype package significantly pruned, and the fact that generated code no longer depend on depends on that package, we can consider merging what's left of prototype into protodesc. Change-Id: I6090f023f2e1b6afaf62bd3ae883566242e30715 Reviewed-on: https://go-review.googlesource.com/c/158539 Reviewed-by: Herbie Ong <herbie@google.com> Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-01-18 09:32:24 -08:00
}.Init()
cmd/protoc-gen-go: drop xxx_ prefix for package-level variables Lower-casing the FileDescriptor variable provides for shorter and more readable global variable names. This has a very minor benefit that the read-only data section of a binary is slightly smaller since function names do end up in the final binary. Change-Id: I077364905e5c9adea69873b3ea580fddc68b9eb8 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172119 Reviewed-by: Herbie Ong <herbie@google.com>
2019-04-15 13:57:56 -07:00
file_import_public_sub_a_proto_rawDesc = nil
file_import_public_sub_a_proto_goTypes = nil
file_import_public_sub_a_proto_depIdxs = nil
cmd/protoc-gen-go: add support for protobuf reflection Implement support in protoc-gen-go for generating messages and enums that satisfy the v2 protobuf reflection interfaces. Specifically, the following are added: * top-level variable representing the file descriptor * ProtoReflect method on enums (to implement protoV2.Enum) * ProtoReflect method on messages (to implement protoV2.Message) The following are not supported yet: * resolving transitive dependencies for file imports * Extension descriptors * Service descriptors The implementation approach creates a single array for all the message and enum declarations and references sections of that array to complete dependencies. Since protobuf declarations can form a graph (a message may depend on itself), it is difficult to construct a graph as a single literal. One way is to use placeholder descriptors, but that is not efficient as it requires encoding the full name of each dependent enum and message and then later resolving it; thus, both expanding the binary size and also increasing initialization cost. Instead, we add a prototype.{Enum,Message}.Reference method to obtain a descriptor reference for the purposes for satisfying dependencies. As such, nested declarations and dependencies are populated in an init function. Other changes to support the implementation: * Added a protoimpl package to expose the MessageType type and also the MessageTypeOf and EnumTypeOf helper functions. * Added a protogen.File.GoIdent field to provide a suggested variable name for the file descriptor. * Added prototype.{Enum,Message}.Reference that provides a descriptor reference for the purposes for satisfying cyclic dependencies. * Added protoreflect.{Syntax,Cardinality,Kind}.GoString to obtain a Go source identifier that represents the given constant. Change-Id: I9455764882dee6ad10f251901e7d419091e8bf1d Reviewed-on: https://go-review.googlesource.com/c/150074 Reviewed-by: Damien Neil <dneil@google.com>
2018-11-15 14:44:37 -08:00
}
Reference in New Issue Copy Permalink