mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-27 21:35:28 +00:00
cmd/protoc-gen-go: add support for protobuf reflection
Implement support in protoc-gen-go for generating messages and enums
that satisfy the v2 protobuf reflection interfaces. Specifically, the following
are added:
* top-level variable representing the file descriptor
* ProtoReflect method on enums (to implement protoV2.Enum)
* ProtoReflect method on messages (to implement protoV2.Message)
The following are not supported yet:
* resolving transitive dependencies for file imports
* Extension descriptors
* Service descriptors
The implementation approach creates a single array for all the message and enum
declarations and references sections of that array to complete dependencies.
Since protobuf declarations can form a graph (a message may depend on itself),
it is difficult to construct a graph as a single literal. One way is to use
placeholder descriptors, but that is not efficient as it requires encoding
the full name of each dependent enum and message and then later resolving it;
thus, both expanding the binary size and also increasing initialization cost.
Instead, we add a prototype.{Enum,Message}.Reference method to obtain a
descriptor reference for the purposes for satisfying dependencies.
As such, nested declarations and dependencies are populated in an init function.
Other changes to support the implementation:
* Added a protoimpl package to expose the MessageType type and also the
MessageTypeOf and EnumTypeOf helper functions.
* Added a protogen.File.GoIdent field to provide a suggested variable name
for the file descriptor.
* Added prototype.{Enum,Message}.Reference that provides a descriptor reference
for the purposes for satisfying cyclic dependencies.
* Added protoreflect.{Syntax,Cardinality,Kind}.GoString to obtain a Go source
identifier that represents the given constant.
Change-Id: I9455764882dee6ad10f251901e7d419091e8bf1d
Reviewed-on: https://go-review.googlesource.com/c/150074
Reviewed-by: Damien Neil <dneil@google.com>
This commit is contained in:
Joe Tsai
Joe Tsai
parent
eeca8bb946
commit
b6405bd782
@ -6,6 +6,9 @@ package grpc
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -37,3 +40,24 @@ var fileDescriptor_1e7146702b7fe8c5 = []byte{
|
||||
0x12, 0x4b, 0x12, 0xc1, 0x8e, 0x4e, 0x62, 0x03, 0x4b, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff,
|
||||
0x8d, 0xbe, 0xc2, 0x16, 0xf5, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
var err error
|
||||
Deprecation_ProtoFile, err = prototype.NewFile(&xxx_Deprecation_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Deprecation_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Deprecation_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "grpc/deprecation.proto",
|
||||
Package: "goproto.protoc.grpc",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("grpc/grpc.proto", "goproto.protoc.grpc")},
|
||||
},
|
||||
}
|
||||
|
||||
82
cmd/protoc-gen-go-grpc/testdata/grpc/grpc.pb.go
vendored
82
cmd/protoc-gen-go-grpc/testdata/grpc/grpc.pb.go
vendored
@ -6,6 +6,9 @@ package grpc
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type Request struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Request struct{ m *Request }
|
||||
|
||||
func (m *Request) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Request{m}
|
||||
}
|
||||
func (m xxx_Request) Type() protoreflect.MessageType {
|
||||
return xxx_Grpc_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Request) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Grpc_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Request) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Grpc_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Request) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Request) ProtoMutable() {}
|
||||
|
||||
func (m *Request) Reset() { *m = Request{} }
|
||||
func (m *Request) String() string { return proto.CompactTextString(m) }
|
||||
func (*Request) ProtoMessage() {}
|
||||
@ -57,6 +79,25 @@ type Response struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Response struct{ m *Response }
|
||||
|
||||
func (m *Response) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Response{m}
|
||||
}
|
||||
func (m xxx_Response) Type() protoreflect.MessageType {
|
||||
return xxx_Grpc_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_Response) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Grpc_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Response) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Grpc_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Response) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Response) ProtoMutable() {}
|
||||
|
||||
func (m *Response) Reset() { *m = Response{} }
|
||||
func (m *Response) String() string { return proto.CompactTextString(m) }
|
||||
func (*Response) ProtoMessage() {}
|
||||
@ -106,3 +147,44 @@ var fileDescriptor_81ea47a3f88c2082 = []byte{
|
||||
0xa6, 0x24, 0x36, 0xb0, 0xa4, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x29, 0xd5, 0xc4, 0xd0, 0xba,
|
||||
0x01, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Grpc_ProtoFile_FileDesc.Messages = xxx_Grpc_ProtoFile_MessageDescs[0:2]
|
||||
var err error
|
||||
Grpc_ProtoFile, err = prototype.NewFile(&xxx_Grpc_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Grpc_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Grpc_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "grpc/grpc.proto",
|
||||
Package: "goproto.protoc.grpc",
|
||||
}
|
||||
var xxx_Grpc_ProtoFile_MessageTypes = [2]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Grpc_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Request)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Grpc_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Response)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Grpc_ProtoFile_MessageDescs = [2]prototype.Message{
|
||||
{
|
||||
Name: "Request",
|
||||
},
|
||||
{
|
||||
Name: "Response",
|
||||
},
|
||||
}
|
||||
|
||||
@ -42,6 +42,8 @@ type fileInfo struct {
|
||||
allEnums []*protogen.Enum
|
||||
allMessages []*protogen.Message
|
||||
allExtensions []*protogen.Extension
|
||||
|
||||
fileReflect fileReflect
|
||||
}
|
||||
|
||||
// GenerateFile generates the contents of a .pb.go file.
|
||||
@ -53,7 +55,7 @@ func GenerateFile(gen *protogen.Plugin, file *protogen.File, g *protogen.Generat
|
||||
// The different order for enums and extensions is to match the output
|
||||
// of the previous implementation.
|
||||
//
|
||||
// TODO: Eventually make this consistent.
|
||||
// TODO: Eventually make this consistent (and remove fileReflect).
|
||||
f.allEnums = append(f.allEnums, f.File.Enums...)
|
||||
walkMessages(f.Messages, func(message *protogen.Message) {
|
||||
f.allMessages = append(f.allMessages, message)
|
||||
@ -62,6 +64,9 @@ func GenerateFile(gen *protogen.Plugin, file *protogen.File, g *protogen.Generat
|
||||
})
|
||||
f.allExtensions = append(f.allExtensions, f.File.Extensions...)
|
||||
|
||||
// Initialize data structures needed for reflection.
|
||||
f.fileReflect.init(f)
|
||||
|
||||
// Determine the name of the var holding the file descriptor:
|
||||
//
|
||||
// fileDescriptor_<hash of filename>
|
||||
@ -121,6 +126,8 @@ func GenerateFile(gen *protogen.Plugin, file *protogen.File, g *protogen.Generat
|
||||
|
||||
genInitFunction(gen, g, f)
|
||||
genFileDescriptor(gen, g, f)
|
||||
genReflectInitFunction(gen, g, f)
|
||||
genReflectFileDescriptor(gen, g, f)
|
||||
}
|
||||
|
||||
// walkMessages calls f on each message and all of its descendants.
|
||||
@ -264,6 +271,10 @@ func genEnum(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo, enum
|
||||
}
|
||||
g.P(")")
|
||||
g.P()
|
||||
|
||||
// Generate support for protobuf reflection.
|
||||
genReflectEnum(gen, g, f, enum)
|
||||
|
||||
nameMap := enum.GoIdent.GoName + "_name"
|
||||
g.P("var ", nameMap, " = map[int32]string{")
|
||||
generated := make(map[protoreflect.EnumNumber]bool)
|
||||
@ -406,6 +417,9 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo, me
|
||||
g.P("}")
|
||||
g.P()
|
||||
|
||||
// Generate support for protobuf reflection.
|
||||
genReflectMessage(gen, g, f, message)
|
||||
|
||||
// Reset
|
||||
g.P("func (m *", message.GoIdent, ") Reset() { *m = ", message.GoIdent, "{} }")
|
||||
// String
|
||||
@ -736,7 +750,7 @@ func extensionVar(f *protogen.File, extension *protogen.Extension) protogen.GoId
|
||||
// genInitFunction generates an init function that registers the types in the
|
||||
// generated file with the proto package.
|
||||
func genInitFunction(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo) {
|
||||
if len(f.allMessages) == 0 && len(f.allEnums) == 0 && len(f.allExtensions) == 0 {
|
||||
if len(f.allEnums)+len(f.allMessages)+len(f.allExtensions) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
392
cmd/protoc-gen-go/internal_gengo/reflect.go
Normal file
392
cmd/protoc-gen-go/internal_gengo/reflect.go
Normal file
@ -0,0 +1,392 @@
|
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package internal_gengo
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/golang/protobuf/v2/protogen"
|
||||
"github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
)
|
||||
|
||||
// TODO: Remove this flag.
|
||||
const enableReflect = true
|
||||
|
||||
// minimumVersion is minimum version of the v2 proto package that is required.
|
||||
// This is incremented every time the generated code relies on some property
|
||||
// in the proto package that was introduced in a later version.
|
||||
const minimumVersion = 0
|
||||
|
||||
const (
|
||||
protoimplPackage = protogen.GoImportPath("github.com/golang/protobuf/v2/runtime/protoimpl")
|
||||
protoreflectPackage = protogen.GoImportPath("github.com/golang/protobuf/v2/reflect/protoreflect")
|
||||
prototypePackage = protogen.GoImportPath("github.com/golang/protobuf/v2/reflect/prototype")
|
||||
)
|
||||
|
||||
// TODO: Add support for proto options.
|
||||
|
||||
// fileReflect is embedded in fileInfo to maintain state needed for reflection.
|
||||
//
|
||||
// TODO: Remove this when we have the freedom to change the order of
|
||||
// fileInfo.{allEnums,allMessages,allExtensions} to be a breadth-first search
|
||||
// to ensure that all declarations are coalesced together.
|
||||
type fileReflect struct {
|
||||
allEnums []*protogen.Enum
|
||||
allEnumsByPtr map[*protogen.Enum]int // value is index into allEnums
|
||||
allMessages []*protogen.Message
|
||||
allMessagesByPtr map[*protogen.Message]int // value is index into allMessages
|
||||
}
|
||||
|
||||
func (r *fileReflect) init(f *fileInfo) {
|
||||
r.allEnums = append(r.allEnums, f.Enums...)
|
||||
r.allMessages = append(r.allMessages, f.Messages...)
|
||||
walkMessages(f.Messages, func(m *protogen.Message) {
|
||||
r.allEnums = append(r.allEnums, m.Enums...)
|
||||
r.allMessages = append(r.allMessages, m.Messages...)
|
||||
})
|
||||
|
||||
// Derive a reverse mapping of enum and message pointers to their index
|
||||
// in allEnums and allMessages.
|
||||
if len(r.allEnums) > 0 {
|
||||
r.allEnumsByPtr = make(map[*protogen.Enum]int)
|
||||
for i, e := range r.allEnums {
|
||||
r.allEnumsByPtr[e] = i
|
||||
}
|
||||
}
|
||||
if len(r.allMessages) > 0 {
|
||||
r.allMessagesByPtr = make(map[*protogen.Message]int)
|
||||
for i, m := range r.allMessages {
|
||||
r.allMessagesByPtr[m] = i
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func genReflectInitFunction(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo) {
|
||||
if !enableReflect {
|
||||
return
|
||||
}
|
||||
|
||||
if len(f.fileReflect.allEnums)+len(f.fileReflect.allMessages)+len(f.allExtensions)+len(f.Services) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
g.P("func init() {")
|
||||
|
||||
// TODO: Fix up file imports to reference a protoreflect.FileDescriptor
|
||||
// in a remote dependency. Since we cannot yet rely on the existence of
|
||||
// a variable containing the file descriptor, we find a random message or
|
||||
// enum the package and see if we can ascend to the parent file descriptor.
|
||||
|
||||
fileDescVar := fileDescVarName(f)
|
||||
enumTypesVar := enumTypesVarName(f)
|
||||
enumDescsVar := enumDescsVarName(f)
|
||||
messageTypesVar := messageTypesVarName(f)
|
||||
messageDescsVar := messageDescsVarName(f)
|
||||
|
||||
// Populate all declarations for messages and enums.
|
||||
// These are not declared in the literals to avoid an initialization loop.
|
||||
if enums := f.Enums; len(enums) > 0 {
|
||||
i := f.fileReflect.allEnumsByPtr[enums[0]]
|
||||
g.P(fileDescVar, ".Enums = ", enumDescsVar, "[", i, ":", i+len(enums), "]")
|
||||
}
|
||||
if messages := f.Messages; len(messages) > 0 {
|
||||
i := f.fileReflect.allMessagesByPtr[messages[0]]
|
||||
g.P(fileDescVar, ".Messages = ", messageDescsVar, "[", i, ":", i+len(messages), "]")
|
||||
}
|
||||
for i, message := range f.fileReflect.allMessages {
|
||||
if enums := message.Enums; len(enums) > 0 {
|
||||
j := f.fileReflect.allEnumsByPtr[enums[0]]
|
||||
g.P(messageDescsVar, "[", i, "].Enums = ", enumDescsVar, "[", j, ":", j+len(enums), "]")
|
||||
}
|
||||
if messages := message.Messages; len(messages) > 0 {
|
||||
j := f.fileReflect.allMessagesByPtr[messages[0]]
|
||||
g.P(messageDescsVar, "[", i, "].Messages = ", messageDescsVar, "[", j, ":", j+len(messages), "]")
|
||||
}
|
||||
}
|
||||
|
||||
// Populate all dependencies for messages and enums.
|
||||
//
|
||||
// Externally defined enums and messages may or may not support the
|
||||
// v2 protobuf reflection interfaces. The EnumTypeOf and MessageTypeOf
|
||||
// helper functions checks for compliance and derives a v2 type from the
|
||||
// legacy v1 enum or message if necessary.
|
||||
for i, message := range f.fileReflect.allMessages {
|
||||
for j, field := range message.Fields {
|
||||
fieldSel := fmt.Sprintf("[%d].Fields[%d]", i, j)
|
||||
if et := field.EnumType; et != nil {
|
||||
idx, ok := f.fileReflect.allEnumsByPtr[et]
|
||||
if ok {
|
||||
// Locally defined enums are found in the type array.
|
||||
g.P(messageDescsVar, fieldSel, ".EnumType = ", enumTypesVar, "[", idx, "]")
|
||||
} else {
|
||||
// Externally defined enums may need special handling.
|
||||
g.P(messageDescsVar, fieldSel, ".EnumType = ", protoimplPackage.Ident("X"), ".EnumTypeOf(", et.GoIdent, "(0))")
|
||||
}
|
||||
}
|
||||
if mt := field.MessageType; mt != nil {
|
||||
idx, ok := f.fileReflect.allMessagesByPtr[mt]
|
||||
if ok {
|
||||
if mt.Desc.IsMapEntry() {
|
||||
// Map entry types have no Go type generated for them.
|
||||
g.P(messageDescsVar, fieldSel, ".MessageType = ", messageDescsVar, "[", idx, "].Reference()")
|
||||
} else {
|
||||
// Locally defined messages are found in the type array.
|
||||
g.P(messageDescsVar, fieldSel, ".MessageType = ", messageTypesVar, "[", idx, "].Type")
|
||||
}
|
||||
} else {
|
||||
// Externally defined messages may need special handling.
|
||||
g.P(messageDescsVar, fieldSel, ".MessageType = ", protoimplPackage.Ident("X"), ".MessageTypeOf((*", mt.GoIdent, ")(nil))")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// TODO: Fix up extension dependencies.
|
||||
// TODO: Fix up method dependencies.
|
||||
|
||||
// Construct the file descriptor.
|
||||
g.P("var err error")
|
||||
g.P(f.GoDescriptorIdent, ", err = ", prototypePackage.Ident("NewFile"), "(&", fileDescVarName(f), ")")
|
||||
g.P("if err != nil { panic(err) }")
|
||||
|
||||
// TODO: Add v2 registration and stop v1 registration in genInitFunction.
|
||||
|
||||
g.P("}")
|
||||
}
|
||||
|
||||
func genReflectFileDescriptor(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo) {
|
||||
if !enableReflect {
|
||||
return
|
||||
}
|
||||
|
||||
// Emit a static check that enforces a minimum version of the proto package.
|
||||
g.P("const _ = ", protoimplPackage.Ident("EnforceVersion"), "(", protoimplPackage.Ident("Version"), " - ", minimumVersion, ")")
|
||||
|
||||
g.P("var ", f.GoDescriptorIdent, " ", protoreflectPackage.Ident("FileDescriptor"))
|
||||
g.P()
|
||||
|
||||
// Generate literal for file descriptor.
|
||||
fileDescVar := fileDescVarName(f)
|
||||
g.P("var ", fileDescVar, " = ", prototypePackage.Ident("File"), "{")
|
||||
g.P("Syntax: ", protoreflectPackage.Ident(f.Desc.Syntax().GoString()), ",")
|
||||
g.P("Path: ", strconv.Quote(f.Desc.Path()), ",")
|
||||
g.P("Package: ", strconv.Quote(string(f.Desc.Package())), ",")
|
||||
if imps := f.Desc.Imports(); imps.Len() > 0 {
|
||||
g.P("Imports: ", "[]", protoreflectPackage.Ident("FileImport"), "{")
|
||||
for i := 0; i < imps.Len(); i++ {
|
||||
imp := imps.Get(i)
|
||||
path := strconv.Quote(imp.Path())
|
||||
pkg := strconv.Quote(string(imp.Package()))
|
||||
var isPublic, isWeak string
|
||||
if imp.IsPublic {
|
||||
isPublic = ", IsPublic: true"
|
||||
}
|
||||
if imp.IsWeak {
|
||||
isWeak = ", IsWeak: true"
|
||||
}
|
||||
// NOTE: FileDescriptor may be updated later by init.
|
||||
g.P("{FileDescriptor: ", prototypePackage.Ident("PlaceholderFile"), "(", path, ", ", pkg, ")", isPublic, isWeak, "},")
|
||||
}
|
||||
g.P("},")
|
||||
}
|
||||
// NOTE: Messages, Enums, Extensions, and Services are populated by init.
|
||||
g.P("}")
|
||||
|
||||
// Generate literals for enum descriptors.
|
||||
if len(f.fileReflect.allEnums) > 0 {
|
||||
enumTypesVar := enumTypesVarName(f)
|
||||
enumDescsVar := enumDescsVarName(f)
|
||||
g.P("var ", enumTypesVar, " = [", len(f.fileReflect.allEnums), "]", protoreflectPackage.Ident("EnumType"), "{")
|
||||
for i, enum := range f.fileReflect.allEnums {
|
||||
g.P(prototypePackage.Ident("GoEnum"), "(")
|
||||
g.P(enumDescsVar, "[", i, "].Reference(),")
|
||||
g.P("func(_ ", protoreflectPackage.Ident("EnumType"), ", n ", protoreflectPackage.Ident("EnumNumber"), ") ", protoreflectPackage.Ident("ProtoEnum"), " {")
|
||||
g.P("return ", enum.GoIdent, "(n)")
|
||||
g.P("},")
|
||||
g.P("),")
|
||||
}
|
||||
g.P("}")
|
||||
|
||||
g.P("var ", enumDescsVar, " = [", len(f.fileReflect.allEnums), "]", prototypePackage.Ident("Enum"), "{")
|
||||
for _, enum := range f.fileReflect.allEnums {
|
||||
g.P("{")
|
||||
g.P("Name: ", strconv.Quote(string(enum.Desc.Name())), ",")
|
||||
g.P("Values: []", prototypePackage.Ident("EnumValue"), "{")
|
||||
for _, value := range enum.Values {
|
||||
g.P("{Name: ", strconv.Quote(string(value.Desc.Name())), ", Number: ", value.Desc.Number(), "},")
|
||||
}
|
||||
g.P("},")
|
||||
g.P("},")
|
||||
}
|
||||
g.P("}")
|
||||
}
|
||||
|
||||
// Generate literals for message descriptors.
|
||||
if len(f.fileReflect.allMessages) > 0 {
|
||||
messageTypesVar := messageTypesVarName(f)
|
||||
messageDescsVar := messageDescsVarName(f)
|
||||
g.P("var ", messageTypesVar, " = [", len(f.fileReflect.allMessages), "]", protoimplPackage.Ident("MessageType"), "{")
|
||||
for i, message := range f.fileReflect.allMessages {
|
||||
if message.Desc.IsMapEntry() {
|
||||
// Map entry types have no Go type generated for them.
|
||||
g.P("{ /* no message type for ", message.GoIdent, " */ },")
|
||||
continue
|
||||
}
|
||||
g.P("{Type: ", prototypePackage.Ident("GoMessage"), "(")
|
||||
g.P(messageDescsVar, "[", i, "].Reference(),")
|
||||
g.P("func(", protoreflectPackage.Ident("MessageType"), ") ", protoreflectPackage.Ident("ProtoMessage"), " {")
|
||||
g.P("return new(", message.GoIdent, ")")
|
||||
g.P("},")
|
||||
g.P(")},")
|
||||
}
|
||||
g.P("}")
|
||||
|
||||
g.P("var ", messageDescsVar, " = [", len(f.fileReflect.allMessages), "]", prototypePackage.Ident("Message"), "{")
|
||||
for _, message := range f.fileReflect.allMessages {
|
||||
g.P("{")
|
||||
g.P("Name: ", strconv.Quote(string(message.Desc.Name())), ",")
|
||||
if fields := message.Desc.Fields(); fields.Len() > 0 {
|
||||
g.P("Fields: []", prototypePackage.Ident("Field"), "{")
|
||||
for i := 0; i < fields.Len(); i++ {
|
||||
field := fields.Get(i)
|
||||
g.P("{")
|
||||
g.P("Name: ", strconv.Quote(string(field.Name())), ",")
|
||||
g.P("Number: ", field.Number(), ",")
|
||||
g.P("Cardinality: ", protoreflectPackage.Ident(field.Cardinality().GoString()), ",")
|
||||
g.P("Kind: ", protoreflectPackage.Ident(field.Kind().GoString()), ",")
|
||||
// TODO: omit JSONName if it can be derived from Name?
|
||||
g.P("JSONName: ", strconv.Quote(field.JSONName()), ",")
|
||||
if field.HasDefault() {
|
||||
v := field.Default().Interface()
|
||||
typeName := reflect.TypeOf(v).Name()
|
||||
valLit := fmt.Sprint(v)
|
||||
switch v.(type) {
|
||||
case protoreflect.EnumNumber:
|
||||
typeName = "string"
|
||||
valLit = strconv.Quote(string(field.DefaultEnumValue().Name()))
|
||||
case float32, float64:
|
||||
switch f := field.Default().Float(); {
|
||||
case math.IsInf(f, -1):
|
||||
valLit = g.QualifiedGoIdent(mathPackage.Ident("Inf")) + "(-1)"
|
||||
case math.IsInf(f, +1):
|
||||
valLit = g.QualifiedGoIdent(mathPackage.Ident("Inf")) + "(+1)"
|
||||
case math.IsNaN(f):
|
||||
valLit = g.QualifiedGoIdent(mathPackage.Ident("NaN")) + "()"
|
||||
}
|
||||
case string, []byte:
|
||||
valLit = fmt.Sprintf("%q", v)
|
||||
}
|
||||
g.P("Default: ", protoreflectPackage.Ident("ValueOf"), "(", typeName, "(", valLit, ")),")
|
||||
}
|
||||
if oneof := field.OneofType(); oneof != nil {
|
||||
g.P("OneofName: ", strconv.Quote(string(oneof.Name())), ",")
|
||||
}
|
||||
// NOTE: MessageType and EnumType are populated by init.
|
||||
g.P("},")
|
||||
}
|
||||
g.P("},")
|
||||
}
|
||||
if oneofs := message.Desc.Oneofs(); oneofs.Len() > 0 {
|
||||
g.P("Oneofs: []", prototypePackage.Ident("Oneof"), "{")
|
||||
for i := 0; i < oneofs.Len(); i++ {
|
||||
oneof := oneofs.Get(i)
|
||||
g.P("{Name: ", strconv.Quote(string(oneof.Name())), "},")
|
||||
}
|
||||
g.P("},")
|
||||
}
|
||||
if extRanges := message.Desc.ExtensionRanges(); extRanges.Len() > 0 {
|
||||
var ss []string
|
||||
for i := 0; i < extRanges.Len(); i++ {
|
||||
r := extRanges.Get(i)
|
||||
ss = append(ss, fmt.Sprintf("{%d,%d}", r[0], r[1]))
|
||||
}
|
||||
g.P("ExtensionRanges: [][2]", protoreflectPackage.Ident("FieldNumber"), "{", strings.Join(ss, ","), "},")
|
||||
}
|
||||
// NOTE: Messages, Enums, and Extensions are populated by init.
|
||||
g.P("},")
|
||||
}
|
||||
g.P("}")
|
||||
}
|
||||
|
||||
// TODO: Add support for extensions.
|
||||
// TODO: Add support for services.
|
||||
}
|
||||
|
||||
func genReflectEnum(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo, enum *protogen.Enum) {
|
||||
if !enableReflect {
|
||||
return
|
||||
}
|
||||
|
||||
shadowType := shadowTypeName(enum.GoIdent)
|
||||
g.P("type ", shadowType, " ", enum.GoIdent)
|
||||
g.P()
|
||||
|
||||
idx := f.fileReflect.allEnumsByPtr[enum]
|
||||
typesVar := enumTypesVarName(f)
|
||||
g.P("func (e ", enum.GoIdent, ") ProtoReflect() ", protoreflectPackage.Ident("Enum"), " {")
|
||||
g.P("return (", shadowType, ")(e)")
|
||||
g.P("}")
|
||||
g.P("func (e ", shadowType, ") Type() ", protoreflectPackage.Ident("EnumType"), " {")
|
||||
g.P("return ", typesVar, "[", idx, "]")
|
||||
g.P("}")
|
||||
g.P("func (e ", shadowType, ") Number() ", protoreflectPackage.Ident("EnumNumber"), " {")
|
||||
g.P("return ", protoreflectPackage.Ident("EnumNumber"), "(e)")
|
||||
g.P("}")
|
||||
}
|
||||
|
||||
func genReflectMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, f *fileInfo, message *protogen.Message) {
|
||||
if !enableReflect {
|
||||
return
|
||||
}
|
||||
|
||||
shadowType := shadowTypeName(message.GoIdent)
|
||||
g.P("type ", shadowType, " struct{m *", message.GoIdent, "}")
|
||||
g.P()
|
||||
|
||||
idx := f.fileReflect.allMessagesByPtr[message]
|
||||
typesVar := messageTypesVarName(f)
|
||||
g.P("func (m *", message.GoIdent, ") ProtoReflect() ", protoreflectPackage.Ident("Message"), " {")
|
||||
g.P("return ", shadowType, "{m}")
|
||||
g.P("}")
|
||||
g.P("func (m ", shadowType, ") Type() ", protoreflectPackage.Ident("MessageType"), " {")
|
||||
g.P("return ", typesVar, "[", idx, "].Type")
|
||||
g.P("}")
|
||||
g.P("func (m ", shadowType, ") KnownFields() ", protoreflectPackage.Ident("KnownFields"), " {")
|
||||
g.P("return ", typesVar, "[", idx, "].KnownFieldsOf(m.m)")
|
||||
g.P("}")
|
||||
g.P("func (m ", shadowType, ") UnknownFields() ", protoreflectPackage.Ident("UnknownFields"), " {")
|
||||
g.P("return ", typesVar, "[", idx, "].UnknownFieldsOf(m.m)")
|
||||
g.P("}")
|
||||
g.P("func (m ", shadowType, ") Interface() ", protoreflectPackage.Ident("ProtoMessage"), " {")
|
||||
g.P("return m.m")
|
||||
g.P("}")
|
||||
g.P("func (m ", shadowType, ") ProtoMutable() {}")
|
||||
g.P()
|
||||
}
|
||||
|
||||
func fileDescVarName(f *fileInfo) string {
|
||||
return "xxx_" + f.GoDescriptorIdent.GoName + "_FileDesc"
|
||||
}
|
||||
func enumTypesVarName(f *fileInfo) string {
|
||||
return "xxx_" + f.GoDescriptorIdent.GoName + "_EnumTypes"
|
||||
}
|
||||
func enumDescsVarName(f *fileInfo) string {
|
||||
return "xxx_" + f.GoDescriptorIdent.GoName + "_EnumDescs"
|
||||
}
|
||||
func messageTypesVarName(f *fileInfo) string {
|
||||
return "xxx_" + f.GoDescriptorIdent.GoName + "_MessageTypes"
|
||||
}
|
||||
func messageDescsVarName(f *fileInfo) string {
|
||||
return "xxx_" + f.GoDescriptorIdent.GoName + "_MessageDescs"
|
||||
}
|
||||
func extensionDescsVarName(f *fileInfo) string {
|
||||
return "xxx_" + f.GoDescriptorIdent.GoName + "_ExtensionDescs"
|
||||
}
|
||||
func shadowTypeName(ident protogen.GoIdent) string {
|
||||
return "xxx_" + ident.GoName
|
||||
}
|
||||
@ -6,6 +6,9 @@ package annotations
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,18 @@ const (
|
||||
AnnotationsTestEnum_ANNOTATIONS_TEST_ENUM_VALUE AnnotationsTestEnum = 0
|
||||
)
|
||||
|
||||
type xxx_AnnotationsTestEnum AnnotationsTestEnum
|
||||
|
||||
func (e AnnotationsTestEnum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_AnnotationsTestEnum)(e)
|
||||
}
|
||||
func (e xxx_AnnotationsTestEnum) Type() protoreflect.EnumType {
|
||||
return xxx_Annotations_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_AnnotationsTestEnum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var AnnotationsTestEnum_name = map[int32]string{
|
||||
0: "ANNOTATIONS_TEST_ENUM_VALUE",
|
||||
}
|
||||
@ -64,6 +79,25 @@ type AnnotationsTestMessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_AnnotationsTestMessage struct{ m *AnnotationsTestMessage }
|
||||
|
||||
func (m *AnnotationsTestMessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_AnnotationsTestMessage{m}
|
||||
}
|
||||
func (m xxx_AnnotationsTestMessage) Type() protoreflect.MessageType {
|
||||
return xxx_Annotations_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_AnnotationsTestMessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Annotations_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_AnnotationsTestMessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Annotations_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_AnnotationsTestMessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_AnnotationsTestMessage) ProtoMutable() {}
|
||||
|
||||
func (m *AnnotationsTestMessage) Reset() { *m = AnnotationsTestMessage{} }
|
||||
func (m *AnnotationsTestMessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*AnnotationsTestMessage) ProtoMessage() {}
|
||||
@ -119,3 +153,61 @@ var fileDescriptor_21dfaf6fd39fa3b7 = []byte{
|
||||
0x49, 0x22, 0xb2, 0x7f, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x40, 0xd6, 0xe5, 0x9d, 0x09, 0x01,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Annotations_ProtoFile_FileDesc.Enums = xxx_Annotations_ProtoFile_EnumDescs[0:1]
|
||||
xxx_Annotations_ProtoFile_FileDesc.Messages = xxx_Annotations_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
Annotations_ProtoFile, err = prototype.NewFile(&xxx_Annotations_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Annotations_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Annotations_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "annotations/annotations.proto",
|
||||
Package: "goproto.protoc.annotations",
|
||||
}
|
||||
var xxx_Annotations_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Annotations_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return AnnotationsTestEnum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Annotations_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "AnnotationsTestEnum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ANNOTATIONS_TEST_ENUM_VALUE", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_Annotations_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Annotations_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(AnnotationsTestMessage)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Annotations_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "AnnotationsTestMessage",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "AnnotationsTestField",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "AnnotationsTestField",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
216
cmd/protoc-gen-go/testdata/comments/comments.pb.go
vendored
216
cmd/protoc-gen-go/testdata/comments/comments.pb.go
vendored
@ -8,6 +8,9 @@ package comments
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -37,6 +40,25 @@ type Message1 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message1 struct{ m *Message1 }
|
||||
|
||||
func (m *Message1) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message1{m}
|
||||
}
|
||||
func (m xxx_Message1) Type() protoreflect.MessageType {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Message1) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message1) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message1) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message1) ProtoMutable() {}
|
||||
|
||||
func (m *Message1) Reset() { *m = Message1{} }
|
||||
func (m *Message1) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message1) ProtoMessage() {}
|
||||
@ -107,6 +129,25 @@ type Message1_Message1A struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message1_Message1A struct{ m *Message1_Message1A }
|
||||
|
||||
func (m *Message1_Message1A) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message1_Message1A{m}
|
||||
}
|
||||
func (m xxx_Message1_Message1A) Type() protoreflect.MessageType {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[2].Type
|
||||
}
|
||||
func (m xxx_Message1_Message1A) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[2].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message1_Message1A) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[2].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message1_Message1A) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message1_Message1A) ProtoMutable() {}
|
||||
|
||||
func (m *Message1_Message1A) Reset() { *m = Message1_Message1A{} }
|
||||
func (m *Message1_Message1A) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message1_Message1A) ProtoMessage() {}
|
||||
@ -139,6 +180,25 @@ type Message1_Message1B struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message1_Message1B struct{ m *Message1_Message1B }
|
||||
|
||||
func (m *Message1_Message1B) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message1_Message1B{m}
|
||||
}
|
||||
func (m xxx_Message1_Message1B) Type() protoreflect.MessageType {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[3].Type
|
||||
}
|
||||
func (m xxx_Message1_Message1B) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[3].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message1_Message1B) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[3].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message1_Message1B) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message1_Message1B) ProtoMutable() {}
|
||||
|
||||
func (m *Message1_Message1B) Reset() { *m = Message1_Message1B{} }
|
||||
func (m *Message1_Message1B) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message1_Message1B) ProtoMessage() {}
|
||||
@ -171,6 +231,25 @@ type Message2 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message2 struct{ m *Message2 }
|
||||
|
||||
func (m *Message2) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message2{m}
|
||||
}
|
||||
func (m xxx_Message2) Type() protoreflect.MessageType {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_Message2) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message2) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message2) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message2) ProtoMutable() {}
|
||||
|
||||
func (m *Message2) Reset() { *m = Message2{} }
|
||||
func (m *Message2) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message2) ProtoMessage() {}
|
||||
@ -203,6 +282,25 @@ type Message2_Message2A struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message2_Message2A struct{ m *Message2_Message2A }
|
||||
|
||||
func (m *Message2_Message2A) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message2_Message2A{m}
|
||||
}
|
||||
func (m xxx_Message2_Message2A) Type() protoreflect.MessageType {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[4].Type
|
||||
}
|
||||
func (m xxx_Message2_Message2A) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[4].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message2_Message2A) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[4].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message2_Message2A) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message2_Message2A) ProtoMutable() {}
|
||||
|
||||
func (m *Message2_Message2A) Reset() { *m = Message2_Message2A{} }
|
||||
func (m *Message2_Message2A) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message2_Message2A) ProtoMessage() {}
|
||||
@ -235,6 +333,25 @@ type Message2_Message2B struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message2_Message2B struct{ m *Message2_Message2B }
|
||||
|
||||
func (m *Message2_Message2B) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message2_Message2B{m}
|
||||
}
|
||||
func (m xxx_Message2_Message2B) Type() protoreflect.MessageType {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[5].Type
|
||||
}
|
||||
func (m xxx_Message2_Message2B) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[5].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message2_Message2B) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Comments_ProtoFile_MessageTypes[5].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message2_Message2B) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message2_Message2B) ProtoMutable() {}
|
||||
|
||||
func (m *Message2_Message2B) Reset() { *m = Message2_Message2B{} }
|
||||
func (m *Message2_Message2B) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message2_Message2B) ProtoMessage() {}
|
||||
@ -286,3 +403,102 @@ var fileDescriptor_885e8293f1fab554 = []byte{
|
||||
0x3d, 0x35, 0x4f, 0x37, 0x3d, 0x5f, 0xbf, 0x24, 0xb5, 0xb8, 0x24, 0x25, 0xb1, 0x24, 0x11, 0xee,
|
||||
0x79, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x27, 0xeb, 0x57, 0xe0, 0x10, 0x01, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Comments_ProtoFile_FileDesc.Messages = xxx_Comments_ProtoFile_MessageDescs[0:2]
|
||||
xxx_Comments_ProtoFile_MessageDescs[0].Messages = xxx_Comments_ProtoFile_MessageDescs[2:4]
|
||||
xxx_Comments_ProtoFile_MessageDescs[1].Messages = xxx_Comments_ProtoFile_MessageDescs[4:6]
|
||||
var err error
|
||||
Comments_ProtoFile, err = prototype.NewFile(&xxx_Comments_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Comments_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Comments_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "comments/comments.proto",
|
||||
Package: "goproto.protoc.comments",
|
||||
}
|
||||
var xxx_Comments_ProtoFile_MessageTypes = [6]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Comments_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message1)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Comments_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message2)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Comments_ProtoFile_MessageDescs[2].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message1_Message1A)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Comments_ProtoFile_MessageDescs[3].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message1_Message1B)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Comments_ProtoFile_MessageDescs[4].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message2_Message2A)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Comments_ProtoFile_MessageDescs[5].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message2_Message2B)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Comments_ProtoFile_MessageDescs = [6]prototype.Message{
|
||||
{
|
||||
Name: "Message1",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "Field1A",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "Field1A",
|
||||
},
|
||||
{
|
||||
Name: "Oneof1AField1",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "Oneof1AField1",
|
||||
OneofName: "Oneof1a",
|
||||
},
|
||||
},
|
||||
Oneofs: []prototype.Oneof{
|
||||
{Name: "Oneof1a"},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "Message2",
|
||||
},
|
||||
{
|
||||
Name: "Message1A",
|
||||
},
|
||||
{
|
||||
Name: "Message1B",
|
||||
},
|
||||
{
|
||||
Name: "Message2A",
|
||||
},
|
||||
{
|
||||
Name: "Message2B",
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package comments
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -25,6 +28,18 @@ const (
|
||||
DeprecatedEnum_DEPRECATED DeprecatedEnum = 0 // Deprecated: Do not use.
|
||||
)
|
||||
|
||||
type xxx_DeprecatedEnum DeprecatedEnum
|
||||
|
||||
func (e DeprecatedEnum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_DeprecatedEnum)(e)
|
||||
}
|
||||
func (e xxx_DeprecatedEnum) Type() protoreflect.EnumType {
|
||||
return xxx_Deprecated_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_DeprecatedEnum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var DeprecatedEnum_name = map[int32]string{
|
||||
0: "DEPRECATED",
|
||||
}
|
||||
@ -49,6 +64,25 @@ type DeprecatedMessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_DeprecatedMessage struct{ m *DeprecatedMessage }
|
||||
|
||||
func (m *DeprecatedMessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_DeprecatedMessage{m}
|
||||
}
|
||||
func (m xxx_DeprecatedMessage) Type() protoreflect.MessageType {
|
||||
return xxx_Deprecated_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_DeprecatedMessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Deprecated_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_DeprecatedMessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Deprecated_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_DeprecatedMessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_DeprecatedMessage) ProtoMutable() {}
|
||||
|
||||
func (m *DeprecatedMessage) Reset() { *m = DeprecatedMessage{} }
|
||||
func (m *DeprecatedMessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*DeprecatedMessage) ProtoMessage() {}
|
||||
@ -105,3 +139,61 @@ var fileDescriptor_0336e614ee2de5f7 = []byte{
|
||||
0x4b, 0x52, 0x12, 0x4b, 0x12, 0xf5, 0x61, 0xce, 0xde, 0xc1, 0xc8, 0x98, 0xc4, 0x06, 0x56, 0x63,
|
||||
0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x39, 0xab, 0x43, 0x93, 0xf6, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Deprecated_ProtoFile_FileDesc.Enums = xxx_Deprecated_ProtoFile_EnumDescs[0:1]
|
||||
xxx_Deprecated_ProtoFile_FileDesc.Messages = xxx_Deprecated_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
Deprecated_ProtoFile, err = prototype.NewFile(&xxx_Deprecated_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Deprecated_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Deprecated_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "comments/deprecated.proto",
|
||||
Package: "goproto.protoc.comments",
|
||||
}
|
||||
var xxx_Deprecated_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Deprecated_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return DeprecatedEnum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Deprecated_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "DeprecatedEnum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "DEPRECATED", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_Deprecated_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Deprecated_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(DeprecatedMessage)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Deprecated_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "DeprecatedMessage",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "deprecated_field",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "deprecatedField",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package base
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -28,6 +31,25 @@ type BaseMessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_BaseMessage struct{ m *BaseMessage }
|
||||
|
||||
func (m *BaseMessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_BaseMessage{m}
|
||||
}
|
||||
func (m xxx_BaseMessage) Type() protoreflect.MessageType {
|
||||
return xxx_Base_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_BaseMessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Base_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_BaseMessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Base_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_BaseMessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_BaseMessage) ProtoMutable() {}
|
||||
|
||||
func (m *BaseMessage) Reset() { *m = BaseMessage{} }
|
||||
func (m *BaseMessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*BaseMessage) ProtoMessage() {}
|
||||
@ -76,6 +98,25 @@ type MessageSetWireFormatMessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_MessageSetWireFormatMessage struct{ m *MessageSetWireFormatMessage }
|
||||
|
||||
func (m *MessageSetWireFormatMessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_MessageSetWireFormatMessage{m}
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatMessage) Type() protoreflect.MessageType {
|
||||
return xxx_Base_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatMessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Base_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatMessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Base_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatMessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatMessage) ProtoMutable() {}
|
||||
|
||||
func (m *MessageSetWireFormatMessage) Reset() { *m = MessageSetWireFormatMessage{} }
|
||||
func (m *MessageSetWireFormatMessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*MessageSetWireFormatMessage) ProtoMessage() {}
|
||||
@ -132,3 +173,55 @@ var fileDescriptor_aebb28f8d5a04466 = []byte{
|
||||
0x3d, 0x5f, 0xbf, 0x24, 0xb5, 0xb8, 0x24, 0x25, 0xb1, 0x24, 0x51, 0x1f, 0xcd, 0x5f, 0x80, 0x00,
|
||||
0x00, 0x00, 0xff, 0xff, 0x1c, 0x75, 0xde, 0x5a, 0xe9, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Base_ProtoFile_FileDesc.Messages = xxx_Base_ProtoFile_MessageDescs[0:2]
|
||||
var err error
|
||||
Base_ProtoFile, err = prototype.NewFile(&xxx_Base_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Base_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Base_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "extensions/base/base.proto",
|
||||
Package: "goproto.protoc.extension.base",
|
||||
}
|
||||
var xxx_Base_ProtoFile_MessageTypes = [2]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Base_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(BaseMessage)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Base_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(MessageSetWireFormatMessage)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Base_ProtoFile_MessageDescs = [2]prototype.Message{
|
||||
{
|
||||
Name: "BaseMessage",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "field",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "field",
|
||||
},
|
||||
},
|
||||
ExtensionRanges: [][2]protoreflect.FieldNumber{{4, 10}, {16, 536870912}},
|
||||
},
|
||||
{
|
||||
Name: "MessageSetWireFormatMessage",
|
||||
ExtensionRanges: [][2]protoreflect.FieldNumber{{100, 2147483647}},
|
||||
},
|
||||
}
|
||||
|
||||
317
cmd/protoc-gen-go/testdata/extensions/ext/ext.pb.go
vendored
317
cmd/protoc-gen-go/testdata/extensions/ext/ext.pb.go
vendored
@ -8,6 +8,9 @@ import (
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
base "github.com/golang/protobuf/v2/cmd/protoc-gen-go/testdata/extensions/base"
|
||||
extra "github.com/golang/protobuf/v2/cmd/protoc-gen-go/testdata/extensions/extra"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -28,6 +31,18 @@ const (
|
||||
Enum_ZERO Enum = 0
|
||||
)
|
||||
|
||||
type xxx_Enum Enum
|
||||
|
||||
func (e Enum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_Enum)(e)
|
||||
}
|
||||
func (e xxx_Enum) Type() protoreflect.EnumType {
|
||||
return xxx_Ext_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_Enum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var Enum_name = map[int32]string{
|
||||
0: "ZERO",
|
||||
}
|
||||
@ -66,6 +81,25 @@ type Message struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message struct{ m *Message }
|
||||
|
||||
func (m *Message) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message{m}
|
||||
}
|
||||
func (m xxx_Message) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Message) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message) ProtoMutable() {}
|
||||
|
||||
func (m *Message) Reset() { *m = Message{} }
|
||||
func (m *Message) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message) ProtoMessage() {}
|
||||
@ -104,6 +138,25 @@ type Message_M struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message_M struct{ m *Message_M }
|
||||
|
||||
func (m *Message_M) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message_M{m}
|
||||
}
|
||||
func (m xxx_Message_M) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[6].Type
|
||||
}
|
||||
func (m xxx_Message_M) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[6].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message_M) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[6].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message_M) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message_M) ProtoMutable() {}
|
||||
|
||||
func (m *Message_M) Reset() { *m = Message_M{} }
|
||||
func (m *Message_M) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message_M) ProtoMessage() {}
|
||||
@ -136,6 +189,25 @@ type ExtensionGroup struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_ExtensionGroup struct{ m *ExtensionGroup }
|
||||
|
||||
func (m *ExtensionGroup) ProtoReflect() protoreflect.Message {
|
||||
return xxx_ExtensionGroup{m}
|
||||
}
|
||||
func (m xxx_ExtensionGroup) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_ExtensionGroup) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtensionGroup) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtensionGroup) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_ExtensionGroup) ProtoMutable() {}
|
||||
|
||||
func (m *ExtensionGroup) Reset() { *m = ExtensionGroup{} }
|
||||
func (m *ExtensionGroup) String() string { return proto.CompactTextString(m) }
|
||||
func (*ExtensionGroup) ProtoMessage() {}
|
||||
@ -175,6 +247,25 @@ type ExtendingMessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_ExtendingMessage struct{ m *ExtendingMessage }
|
||||
|
||||
func (m *ExtendingMessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_ExtendingMessage{m}
|
||||
}
|
||||
func (m xxx_ExtendingMessage) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[2].Type
|
||||
}
|
||||
func (m xxx_ExtendingMessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[2].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtendingMessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[2].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtendingMessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_ExtendingMessage) ProtoMutable() {}
|
||||
|
||||
func (m *ExtendingMessage) Reset() { *m = ExtendingMessage{} }
|
||||
func (m *ExtendingMessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*ExtendingMessage) ProtoMessage() {}
|
||||
@ -224,6 +315,27 @@ type ExtendingMessage_ExtendingMessageSubmessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_ExtendingMessage_ExtendingMessageSubmessage struct {
|
||||
m *ExtendingMessage_ExtendingMessageSubmessage
|
||||
}
|
||||
|
||||
func (m *ExtendingMessage_ExtendingMessageSubmessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_ExtendingMessage_ExtendingMessageSubmessage{m}
|
||||
}
|
||||
func (m xxx_ExtendingMessage_ExtendingMessageSubmessage) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[7].Type
|
||||
}
|
||||
func (m xxx_ExtendingMessage_ExtendingMessageSubmessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[7].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtendingMessage_ExtendingMessageSubmessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[7].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtendingMessage_ExtendingMessageSubmessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_ExtendingMessage_ExtendingMessageSubmessage) ProtoMutable() {}
|
||||
|
||||
func (m *ExtendingMessage_ExtendingMessageSubmessage) Reset() {
|
||||
*m = ExtendingMessage_ExtendingMessageSubmessage{}
|
||||
}
|
||||
@ -260,6 +372,25 @@ type RepeatedGroup struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_RepeatedGroup struct{ m *RepeatedGroup }
|
||||
|
||||
func (m *RepeatedGroup) ProtoReflect() protoreflect.Message {
|
||||
return xxx_RepeatedGroup{m}
|
||||
}
|
||||
func (m xxx_RepeatedGroup) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[3].Type
|
||||
}
|
||||
func (m xxx_RepeatedGroup) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[3].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_RepeatedGroup) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[3].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_RepeatedGroup) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_RepeatedGroup) ProtoMutable() {}
|
||||
|
||||
func (m *RepeatedGroup) Reset() { *m = RepeatedGroup{} }
|
||||
func (m *RepeatedGroup) String() string { return proto.CompactTextString(m) }
|
||||
func (*RepeatedGroup) ProtoMessage() {}
|
||||
@ -300,6 +431,25 @@ type Extendable struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Extendable struct{ m *Extendable }
|
||||
|
||||
func (m *Extendable) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Extendable{m}
|
||||
}
|
||||
func (m xxx_Extendable) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[4].Type
|
||||
}
|
||||
func (m xxx_Extendable) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[4].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Extendable) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[4].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Extendable) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Extendable) ProtoMutable() {}
|
||||
|
||||
func (m *Extendable) Reset() { *m = Extendable{} }
|
||||
func (m *Extendable) String() string { return proto.CompactTextString(m) }
|
||||
func (*Extendable) ProtoMessage() {}
|
||||
@ -340,6 +490,27 @@ type MessageSetWireFormatExtension struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_MessageSetWireFormatExtension struct {
|
||||
m *MessageSetWireFormatExtension
|
||||
}
|
||||
|
||||
func (m *MessageSetWireFormatExtension) ProtoReflect() protoreflect.Message {
|
||||
return xxx_MessageSetWireFormatExtension{m}
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatExtension) Type() protoreflect.MessageType {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[5].Type
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatExtension) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[5].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatExtension) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext_ProtoFile_MessageTypes[5].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatExtension) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_MessageSetWireFormatExtension) ProtoMutable() {}
|
||||
|
||||
func (m *MessageSetWireFormatExtension) Reset() { *m = MessageSetWireFormatExtension{} }
|
||||
func (m *MessageSetWireFormatExtension) String() string { return proto.CompactTextString(m) }
|
||||
func (*MessageSetWireFormatExtension) ProtoMessage() {}
|
||||
@ -874,3 +1045,149 @@ var fileDescriptor_bf470ef4907b23cb = []byte{
|
||||
0xc5, 0x5d, 0x9b, 0xb8, 0x77, 0x6d, 0xaf, 0x1f, 0x92, 0x20, 0xb4, 0xcc, 0x90, 0xbd, 0x0e, 0x13,
|
||||
0xde, 0x8f, 0x3d, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x33, 0x5c, 0xd7, 0x84, 0x13, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Ext_ProtoFile_FileDesc.Enums = xxx_Ext_ProtoFile_EnumDescs[0:1]
|
||||
xxx_Ext_ProtoFile_FileDesc.Messages = xxx_Ext_ProtoFile_MessageDescs[0:6]
|
||||
xxx_Ext_ProtoFile_MessageDescs[0].Messages = xxx_Ext_ProtoFile_MessageDescs[6:7]
|
||||
xxx_Ext_ProtoFile_MessageDescs[2].Messages = xxx_Ext_ProtoFile_MessageDescs[7:8]
|
||||
var err error
|
||||
Ext_ProtoFile, err = prototype.NewFile(&xxx_Ext_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Ext_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Ext_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "extensions/ext/ext.proto",
|
||||
Package: "goproto.protoc.extension.ext",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("extensions/base/base.proto", "goproto.protoc.extension.base")},
|
||||
{FileDescriptor: prototype.PlaceholderFile("extensions/extra/extra.proto", "goproto.protoc.extension.extra")},
|
||||
},
|
||||
}
|
||||
var xxx_Ext_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Ext_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return Enum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Ext_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "Enum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_Ext_ProtoFile_MessageTypes = [8]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(ExtensionGroup)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[2].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(ExtendingMessage)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[3].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(RepeatedGroup)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[4].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Extendable)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[5].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(MessageSetWireFormatExtension)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[6].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message_M)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext_ProtoFile_MessageDescs[7].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(ExtendingMessage_ExtendingMessageSubmessage)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Ext_ProtoFile_MessageDescs = [8]prototype.Message{
|
||||
{
|
||||
Name: "Message",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "data",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.BytesKind,
|
||||
JSONName: "data",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "ExtensionGroup",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "extension_group",
|
||||
Number: 120,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "extensionGroup",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "ExtendingMessage",
|
||||
},
|
||||
{
|
||||
Name: "RepeatedGroup",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "repeated_x_group",
|
||||
Number: 319,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "repeatedXGroup",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "Extendable",
|
||||
ExtensionRanges: [][2]protoreflect.FieldNumber{{1, 536870912}},
|
||||
},
|
||||
{
|
||||
Name: "MessageSetWireFormatExtension",
|
||||
},
|
||||
{
|
||||
Name: "M",
|
||||
},
|
||||
{
|
||||
Name: "ExtendingMessageSubmessage",
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package extra
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -27,6 +30,25 @@ type ExtraMessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_ExtraMessage struct{ m *ExtraMessage }
|
||||
|
||||
func (m *ExtraMessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_ExtraMessage{m}
|
||||
}
|
||||
func (m xxx_ExtraMessage) Type() protoreflect.MessageType {
|
||||
return xxx_Extra_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_ExtraMessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Extra_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtraMessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Extra_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_ExtraMessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_ExtraMessage) ProtoMutable() {}
|
||||
|
||||
func (m *ExtraMessage) Reset() { *m = ExtraMessage{} }
|
||||
func (m *ExtraMessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*ExtraMessage) ProtoMessage() {}
|
||||
@ -78,3 +100,44 @@ var fileDescriptor_496c2a5e9c1e8739 = []byte{
|
||||
0xe2, 0x12, 0x90, 0x5e, 0x7d, 0x74, 0xc7, 0x01, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xfb, 0x31,
|
||||
0xfc, 0xaf, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Extra_ProtoFile_FileDesc.Messages = xxx_Extra_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
Extra_ProtoFile, err = prototype.NewFile(&xxx_Extra_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Extra_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Extra_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "extensions/extra/extra.proto",
|
||||
Package: "goproto.protoc.extension.extra",
|
||||
}
|
||||
var xxx_Extra_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Extra_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(ExtraMessage)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Extra_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "ExtraMessage",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "data",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.BytesKind,
|
||||
JSONName: "data",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
@ -7,6 +7,9 @@ import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -27,6 +30,18 @@ const (
|
||||
Enum_ZERO Enum = 0
|
||||
)
|
||||
|
||||
type xxx_Enum Enum
|
||||
|
||||
func (e Enum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_Enum)(e)
|
||||
}
|
||||
func (e xxx_Enum) Type() protoreflect.EnumType {
|
||||
return xxx_Ext3_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_Enum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var Enum_name = map[int32]string{
|
||||
0: "ZERO",
|
||||
}
|
||||
@ -49,6 +64,25 @@ type Message struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message struct{ m *Message }
|
||||
|
||||
func (m *Message) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message{m}
|
||||
}
|
||||
func (m xxx_Message) Type() protoreflect.MessageType {
|
||||
return xxx_Ext3_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Message) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Ext3_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Ext3_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message) ProtoMutable() {}
|
||||
|
||||
func (m *Message) Reset() { *m = Message{} }
|
||||
func (m *Message) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message) ProtoMessage() {}
|
||||
@ -472,3 +506,55 @@ var fileDescriptor_3db31bb248c8865e = []byte{
|
||||
0x2d, 0x35, 0xf3, 0xc9, 0x62, 0x8d, 0x8a, 0xbf, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x65, 0x92,
|
||||
0xaa, 0xed, 0xce, 0x0c, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Ext3_ProtoFile_FileDesc.Enums = xxx_Ext3_ProtoFile_EnumDescs[0:1]
|
||||
xxx_Ext3_ProtoFile_FileDesc.Messages = xxx_Ext3_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
Ext3_ProtoFile, err = prototype.NewFile(&xxx_Ext3_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Ext3_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Ext3_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "extensions/proto3/ext3.proto",
|
||||
Package: "goproto.protoc.extension.proto3",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("google/protobuf/descriptor.proto", "google.protobuf")},
|
||||
},
|
||||
}
|
||||
var xxx_Ext3_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Ext3_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return Enum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Ext3_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "Enum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_Ext3_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Ext3_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Ext3_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "Message",
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package fieldnames
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -65,6 +68,25 @@ type Message struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message struct{ m *Message }
|
||||
|
||||
func (m *Message) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message{m}
|
||||
}
|
||||
func (m xxx_Message) Type() protoreflect.MessageType {
|
||||
return xxx_Fieldnames_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Message) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Fieldnames_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Fieldnames_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message) ProtoMutable() {}
|
||||
|
||||
func (m *Message) Reset() { *m = Message{} }
|
||||
func (m *Message) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message) ProtoMessage() {}
|
||||
@ -289,6 +311,25 @@ type Message_OneofMessageConflict struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message_OneofMessageConflict struct{ m *Message_OneofMessageConflict }
|
||||
|
||||
func (m *Message_OneofMessageConflict) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message_OneofMessageConflict{m}
|
||||
}
|
||||
func (m xxx_Message_OneofMessageConflict) Type() protoreflect.MessageType {
|
||||
return xxx_Fieldnames_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_Message_OneofMessageConflict) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Fieldnames_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message_OneofMessageConflict) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Fieldnames_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message_OneofMessageConflict) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message_OneofMessageConflict) ProtoMutable() {}
|
||||
|
||||
func (m *Message_OneofMessageConflict) Reset() { *m = Message_OneofMessageConflict{} }
|
||||
func (m *Message_OneofMessageConflict) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message_OneofMessageConflict) ProtoMessage() {}
|
||||
@ -351,3 +392,182 @@ var fileDescriptor_6bbe3f70febb9403 = []byte{
|
||||
0xfd, 0xe8, 0x2f, 0xf2, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xee, 0x38, 0xe6, 0x3a, 0x03, 0x00,
|
||||
0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Fieldnames_ProtoFile_FileDesc.Messages = xxx_Fieldnames_ProtoFile_MessageDescs[0:1]
|
||||
xxx_Fieldnames_ProtoFile_MessageDescs[0].Messages = xxx_Fieldnames_ProtoFile_MessageDescs[1:2]
|
||||
var err error
|
||||
Fieldnames_ProtoFile, err = prototype.NewFile(&xxx_Fieldnames_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Fieldnames_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Fieldnames_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "fieldnames/fieldnames.proto",
|
||||
Package: "goproto.protoc.fieldnames",
|
||||
}
|
||||
var xxx_Fieldnames_ProtoFile_MessageTypes = [2]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Fieldnames_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Fieldnames_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message_OneofMessageConflict)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Fieldnames_ProtoFile_MessageDescs = [2]prototype.Message{
|
||||
{
|
||||
Name: "Message",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "field_one",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "fieldOne",
|
||||
},
|
||||
{
|
||||
Name: "FieldTwo",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "FieldTwo",
|
||||
},
|
||||
{
|
||||
Name: "fieldThree",
|
||||
Number: 3,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "fieldThree",
|
||||
},
|
||||
{
|
||||
Name: "field__four",
|
||||
Number: 4,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "fieldFour",
|
||||
},
|
||||
{
|
||||
Name: "descriptor",
|
||||
Number: 10,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "descriptor",
|
||||
},
|
||||
{
|
||||
Name: "marshal",
|
||||
Number: 11,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "marshal",
|
||||
},
|
||||
{
|
||||
Name: "unmarshal",
|
||||
Number: 12,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "unmarshal",
|
||||
},
|
||||
{
|
||||
Name: "proto_message",
|
||||
Number: 13,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "protoMessage",
|
||||
},
|
||||
{
|
||||
Name: "CamelCase",
|
||||
Number: 20,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "CamelCase",
|
||||
},
|
||||
{
|
||||
Name: "CamelCase_",
|
||||
Number: 21,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "CamelCase",
|
||||
},
|
||||
{
|
||||
Name: "camel_case",
|
||||
Number: 22,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "camelCase",
|
||||
},
|
||||
{
|
||||
Name: "CamelCase__",
|
||||
Number: 23,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "CamelCase",
|
||||
},
|
||||
{
|
||||
Name: "get_name",
|
||||
Number: 30,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "getName",
|
||||
},
|
||||
{
|
||||
Name: "name",
|
||||
Number: 31,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "name",
|
||||
},
|
||||
{
|
||||
Name: "OneofConflictA",
|
||||
Number: 40,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "OneofConflictA",
|
||||
OneofName: "oneof_conflict_a",
|
||||
},
|
||||
{
|
||||
Name: "oneof_no_conflict",
|
||||
Number: 50,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "oneofNoConflict",
|
||||
OneofName: "oneof_conflict_b",
|
||||
},
|
||||
{
|
||||
Name: "OneofConflictB",
|
||||
Number: 51,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "OneofConflictB",
|
||||
OneofName: "oneof_conflict_b",
|
||||
},
|
||||
{
|
||||
Name: "oneof_message_conflict",
|
||||
Number: 60,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "oneofMessageConflict",
|
||||
OneofName: "oneof_conflict_c",
|
||||
},
|
||||
},
|
||||
Oneofs: []prototype.Oneof{
|
||||
{Name: "oneof_conflict_a"},
|
||||
{Name: "oneof_conflict_b"},
|
||||
{Name: "oneof_conflict_c"},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "OneofMessageConflict",
|
||||
},
|
||||
}
|
||||
|
||||
84
cmd/protoc-gen-go/testdata/import_public/a.pb.go
vendored
84
cmd/protoc-gen-go/testdata/import_public/a.pb.go
vendored
@ -7,6 +7,9 @@ import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
sub "github.com/golang/protobuf/v2/cmd/protoc-gen-go/testdata/import_public/sub"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -71,6 +74,25 @@ type Public struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Public struct{ m *Public }
|
||||
|
||||
func (m *Public) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Public{m}
|
||||
}
|
||||
func (m xxx_Public) Type() protoreflect.MessageType {
|
||||
return xxx_A_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Public) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_A_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Public) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_A_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Public) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Public) ProtoMutable() {}
|
||||
|
||||
func (m *Public) Reset() { *m = Public{} }
|
||||
func (m *Public) String() string { return proto.CompactTextString(m) }
|
||||
func (*Public) ProtoMessage() {}
|
||||
@ -139,3 +161,65 @@ var fileDescriptor_73b7577c95fa6b70 = []byte{
|
||||
0x97, 0xa4, 0x24, 0x96, 0x24, 0xea, 0xa3, 0x18, 0x1b, 0xc0, 0x10, 0xc0, 0x08, 0x08, 0x00, 0x00,
|
||||
0xff, 0xff, 0xfa, 0x3e, 0xda, 0xad, 0x61, 0x01, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_A_ProtoFile_FileDesc.Messages = xxx_A_ProtoFile_MessageDescs[0:1]
|
||||
xxx_A_ProtoFile_MessageDescs[0].Fields[0].MessageType = protoimpl.X.MessageTypeOf((*sub.M)(nil))
|
||||
xxx_A_ProtoFile_MessageDescs[0].Fields[1].EnumType = protoimpl.X.EnumTypeOf(sub.E(0))
|
||||
xxx_A_ProtoFile_MessageDescs[0].Fields[2].MessageType = protoimpl.X.MessageTypeOf((*Local)(nil))
|
||||
var err error
|
||||
A_ProtoFile, err = prototype.NewFile(&xxx_A_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var A_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_A_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "import_public/a.proto",
|
||||
Package: "goproto.protoc.import_public",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("import_public/sub/a.proto", "goproto.protoc.import_public.sub"), IsPublic: true},
|
||||
{FileDescriptor: prototype.PlaceholderFile("import_public/b.proto", "goproto.protoc.import_public"), IsPublic: true},
|
||||
},
|
||||
}
|
||||
var xxx_A_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_A_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Public)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_A_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "Public",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "m",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "m",
|
||||
},
|
||||
{
|
||||
Name: "e",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "e",
|
||||
},
|
||||
{
|
||||
Name: "local",
|
||||
Number: 3,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "local",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
75
cmd/protoc-gen-go/testdata/import_public/b.pb.go
vendored
75
cmd/protoc-gen-go/testdata/import_public/b.pb.go
vendored
@ -7,6 +7,9 @@ import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
sub "github.com/golang/protobuf/v2/cmd/protoc-gen-go/testdata/import_public/sub"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -29,6 +32,25 @@ type Local struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Local struct{ m *Local }
|
||||
|
||||
func (m *Local) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Local{m}
|
||||
}
|
||||
func (m xxx_Local) Type() protoreflect.MessageType {
|
||||
return xxx_B_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Local) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_B_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Local) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_B_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Local) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Local) ProtoMutable() {}
|
||||
|
||||
func (m *Local) Reset() { *m = Local{} }
|
||||
func (m *Local) String() string { return proto.CompactTextString(m) }
|
||||
func (*Local) ProtoMessage() {}
|
||||
@ -88,3 +110,56 @@ var fileDescriptor_84995586b3d09710 = []byte{
|
||||
0x3d, 0x35, 0x4f, 0x37, 0x3d, 0x5f, 0xbf, 0x24, 0xb5, 0xb8, 0x24, 0x25, 0xb1, 0x24, 0x51, 0x1f,
|
||||
0xc5, 0x48, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x34, 0xb9, 0xda, 0x09, 0x01, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_B_ProtoFile_FileDesc.Messages = xxx_B_ProtoFile_MessageDescs[0:1]
|
||||
xxx_B_ProtoFile_MessageDescs[0].Fields[0].MessageType = protoimpl.X.MessageTypeOf((*sub.M)(nil))
|
||||
xxx_B_ProtoFile_MessageDescs[0].Fields[1].EnumType = protoimpl.X.EnumTypeOf(sub.E(0))
|
||||
var err error
|
||||
B_ProtoFile, err = prototype.NewFile(&xxx_B_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var B_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_B_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "import_public/b.proto",
|
||||
Package: "goproto.protoc.import_public",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("import_public/sub/a.proto", "goproto.protoc.import_public.sub")},
|
||||
},
|
||||
}
|
||||
var xxx_B_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_B_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Local)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_B_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "Local",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "m",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "m",
|
||||
},
|
||||
{
|
||||
Name: "e",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "e",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
240
cmd/protoc-gen-go/testdata/import_public/sub/a.pb.go
vendored
240
cmd/protoc-gen-go/testdata/import_public/sub/a.pb.go
vendored
@ -6,6 +6,9 @@ package sub
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,18 @@ const (
|
||||
E_ZERO E = 0
|
||||
)
|
||||
|
||||
type xxx_E E
|
||||
|
||||
func (e E) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_E)(e)
|
||||
}
|
||||
func (e xxx_E) Type() protoreflect.EnumType {
|
||||
return xxx_A_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_E) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var E_name = map[int32]string{
|
||||
0: "ZERO",
|
||||
}
|
||||
@ -63,6 +78,18 @@ const (
|
||||
M_M_ZERO M_Subenum = 0
|
||||
)
|
||||
|
||||
type xxx_M_Subenum M_Subenum
|
||||
|
||||
func (e M_Subenum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_M_Subenum)(e)
|
||||
}
|
||||
func (e xxx_M_Subenum) Type() protoreflect.EnumType {
|
||||
return xxx_A_ProtoFile_EnumTypes[1]
|
||||
}
|
||||
func (e xxx_M_Subenum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var M_Subenum_name = map[int32]string{
|
||||
0: "M_ZERO",
|
||||
}
|
||||
@ -100,6 +127,18 @@ const (
|
||||
M_Submessage_M_SUBMESSAGE_ZERO M_Submessage_Submessage_Subenum = 0
|
||||
)
|
||||
|
||||
type xxx_M_Submessage_Submessage_Subenum M_Submessage_Submessage_Subenum
|
||||
|
||||
func (e M_Submessage_Submessage_Subenum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_M_Submessage_Submessage_Subenum)(e)
|
||||
}
|
||||
func (e xxx_M_Submessage_Submessage_Subenum) Type() protoreflect.EnumType {
|
||||
return xxx_A_ProtoFile_EnumTypes[2]
|
||||
}
|
||||
func (e xxx_M_Submessage_Submessage_Subenum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var M_Submessage_Submessage_Subenum_name = map[int32]string{
|
||||
0: "M_SUBMESSAGE_ZERO",
|
||||
}
|
||||
@ -147,6 +186,25 @@ type M struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M struct{ m *M }
|
||||
|
||||
func (m *M) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M{m}
|
||||
}
|
||||
func (m xxx_M) Type() protoreflect.MessageType {
|
||||
return xxx_A_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_A_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_A_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M) ProtoMutable() {}
|
||||
|
||||
func (m *M) Reset() { *m = M{} }
|
||||
func (m *M) String() string { return proto.CompactTextString(m) }
|
||||
func (*M) ProtoMessage() {}
|
||||
@ -268,6 +326,25 @@ type M_Submessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M_Submessage struct{ m *M_Submessage }
|
||||
|
||||
func (m *M_Submessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M_Submessage{m}
|
||||
}
|
||||
func (m xxx_M_Submessage) Type() protoreflect.MessageType {
|
||||
return xxx_A_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_M_Submessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_A_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M_Submessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_A_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M_Submessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M_Submessage) ProtoMutable() {}
|
||||
|
||||
func (m *M_Submessage) Reset() { *m = M_Submessage{} }
|
||||
func (m *M_Submessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*M_Submessage) ProtoMessage() {}
|
||||
@ -387,3 +464,166 @@ var fileDescriptor_382f7805394b5c4e = []byte{
|
||||
0xe4, 0xec, 0xaf, 0xbb, 0xf6, 0x27, 0x00, 0x00, 0xff, 0xff, 0xfb, 0xa9, 0x17, 0xb5, 0xbc, 0x02,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_A_ProtoFile_FileDesc.Enums = xxx_A_ProtoFile_EnumDescs[0:1]
|
||||
xxx_A_ProtoFile_FileDesc.Messages = xxx_A_ProtoFile_MessageDescs[0:1]
|
||||
xxx_A_ProtoFile_MessageDescs[0].Enums = xxx_A_ProtoFile_EnumDescs[1:2]
|
||||
xxx_A_ProtoFile_MessageDescs[0].Messages = xxx_A_ProtoFile_MessageDescs[1:2]
|
||||
xxx_A_ProtoFile_MessageDescs[1].Enums = xxx_A_ProtoFile_EnumDescs[2:3]
|
||||
xxx_A_ProtoFile_MessageDescs[0].Fields[0].MessageType = protoimpl.X.MessageTypeOf((*M2)(nil))
|
||||
var err error
|
||||
A_ProtoFile, err = prototype.NewFile(&xxx_A_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var A_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_A_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "import_public/sub/a.proto",
|
||||
Package: "goproto.protoc.import_public.sub",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("import_public/sub/b.proto", "goproto.protoc.import_public.sub")},
|
||||
},
|
||||
}
|
||||
var xxx_A_ProtoFile_EnumTypes = [3]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_A_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return E(n)
|
||||
},
|
||||
),
|
||||
prototype.GoEnum(
|
||||
xxx_A_ProtoFile_EnumDescs[1].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return M_Subenum(n)
|
||||
},
|
||||
),
|
||||
prototype.GoEnum(
|
||||
xxx_A_ProtoFile_EnumDescs[2].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return M_Submessage_Submessage_Subenum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_A_ProtoFile_EnumDescs = [3]prototype.Enum{
|
||||
{
|
||||
Name: "E",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "Subenum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "M_ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "Submessage_Subenum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "M_SUBMESSAGE_ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_A_ProtoFile_MessageTypes = [2]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_A_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_A_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M_Submessage)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_A_ProtoFile_MessageDescs = [2]prototype.Message{
|
||||
{
|
||||
Name: "M",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "m2",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "m2",
|
||||
},
|
||||
{
|
||||
Name: "s",
|
||||
Number: 4,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "s",
|
||||
Default: protoreflect.ValueOf(string("default")),
|
||||
},
|
||||
{
|
||||
Name: "b",
|
||||
Number: 5,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.BytesKind,
|
||||
JSONName: "b",
|
||||
Default: protoreflect.ValueOf(("default")),
|
||||
},
|
||||
{
|
||||
Name: "f",
|
||||
Number: 6,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.DoubleKind,
|
||||
JSONName: "f",
|
||||
Default: protoreflect.ValueOf(float64(math.NaN())),
|
||||
},
|
||||
{
|
||||
Name: "oneof_int32",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int32Kind,
|
||||
JSONName: "oneofInt32",
|
||||
OneofName: "oneof_field",
|
||||
},
|
||||
{
|
||||
Name: "oneof_int64",
|
||||
Number: 3,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int64Kind,
|
||||
JSONName: "oneofInt64",
|
||||
OneofName: "oneof_field",
|
||||
},
|
||||
},
|
||||
Oneofs: []prototype.Oneof{
|
||||
{Name: "oneof_field"},
|
||||
},
|
||||
ExtensionRanges: [][2]protoreflect.FieldNumber{{100, 536870912}},
|
||||
},
|
||||
{
|
||||
Name: "Submessage",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "submessage_oneof_int32",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int32Kind,
|
||||
JSONName: "submessageOneofInt32",
|
||||
OneofName: "submessage_oneof_field",
|
||||
},
|
||||
{
|
||||
Name: "submessage_oneof_int64",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int64Kind,
|
||||
JSONName: "submessageOneofInt64",
|
||||
OneofName: "submessage_oneof_field",
|
||||
},
|
||||
},
|
||||
Oneofs: []prototype.Oneof{
|
||||
{Name: "submessage_oneof_field"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package sub
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type M2 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M2 struct{ m *M2 }
|
||||
|
||||
func (m *M2) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M2{m}
|
||||
}
|
||||
func (m xxx_M2) Type() protoreflect.MessageType {
|
||||
return xxx_B_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M2) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_B_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M2) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_B_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M2) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M2) ProtoMutable() {}
|
||||
|
||||
func (m *M2) Reset() { *m = M2{} }
|
||||
func (m *M2) String() string { return proto.CompactTextString(m) }
|
||||
func (*M2) ProtoMessage() {}
|
||||
@ -69,3 +91,35 @@ var fileDescriptor_fc66afda3d7c2232 = []byte{
|
||||
0x3e, 0x86, 0xed, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc7, 0x2d, 0x0b, 0x52, 0x91, 0x00, 0x00,
|
||||
0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_B_ProtoFile_FileDesc.Messages = xxx_B_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
B_ProtoFile, err = prototype.NewFile(&xxx_B_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var B_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_B_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "import_public/sub/b.proto",
|
||||
Package: "goproto.protoc.import_public.sub",
|
||||
}
|
||||
var xxx_B_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_B_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M2)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_B_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "M2",
|
||||
},
|
||||
}
|
||||
|
||||
54
cmd/protoc-gen-go/testdata/imports/fmt/m.pb.go
vendored
54
cmd/protoc-gen-go/testdata/imports/fmt/m.pb.go
vendored
@ -6,6 +6,9 @@ package fmt
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type M struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M struct{ m *M }
|
||||
|
||||
func (m *M) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M{m}
|
||||
}
|
||||
func (m xxx_M) Type() protoreflect.MessageType {
|
||||
return xxx_M_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M) ProtoMutable() {}
|
||||
|
||||
func (m *M) Reset() { *m = M{} }
|
||||
func (m *M) String() string { return proto.CompactTextString(m) }
|
||||
func (*M) ProtoMessage() {}
|
||||
@ -67,3 +89,35 @@ var fileDescriptor_72c126fcd452e392 = []byte{
|
||||
0x52, 0x8b, 0x4b, 0x52, 0x12, 0x4b, 0x12, 0xf5, 0x91, 0x8c, 0x4c, 0x62, 0x03, 0xab, 0x31, 0x06,
|
||||
0x04, 0x00, 0x00, 0xff, 0xff, 0xc4, 0xc9, 0xee, 0xbe, 0x68, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_M_ProtoFile_FileDesc.Messages = xxx_M_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
M_ProtoFile, err = prototype.NewFile(&xxx_M_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var M_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_M_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/fmt/m.proto",
|
||||
Package: "fmt",
|
||||
}
|
||||
var xxx_M_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_M_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "M",
|
||||
},
|
||||
}
|
||||
|
||||
121
cmd/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go
vendored
121
cmd/protoc-gen-go/testdata/imports/test_a_1/m1.pb.go
vendored
@ -6,6 +6,9 @@ package test_a_1
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,18 @@ const (
|
||||
E1_E1_ZERO E1 = 0
|
||||
)
|
||||
|
||||
type xxx_E1 E1
|
||||
|
||||
func (e E1) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_E1)(e)
|
||||
}
|
||||
func (e xxx_E1) Type() protoreflect.EnumType {
|
||||
return xxx_M1_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_E1) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var E1_name = map[int32]string{
|
||||
0: "E1_ZERO",
|
||||
}
|
||||
@ -48,6 +63,25 @@ type M1 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M1 struct{ m *M1 }
|
||||
|
||||
func (m *M1) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M1{m}
|
||||
}
|
||||
func (m xxx_M1) Type() protoreflect.MessageType {
|
||||
return xxx_M1_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M1) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M1_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M1) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M1_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M1) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M1) ProtoMutable() {}
|
||||
|
||||
func (m *M1) Reset() { *m = M1{} }
|
||||
func (m *M1) String() string { return proto.CompactTextString(m) }
|
||||
func (*M1) ProtoMessage() {}
|
||||
@ -80,6 +114,25 @@ type M1_1 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M1_1 struct{ m *M1_1 }
|
||||
|
||||
func (m *M1_1) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M1_1{m}
|
||||
}
|
||||
func (m xxx_M1_1) Type() protoreflect.MessageType {
|
||||
return xxx_M1_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_M1_1) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M1_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M1_1) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M1_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M1_1) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M1_1) ProtoMutable() {}
|
||||
|
||||
func (m *M1_1) Reset() { *m = M1_1{} }
|
||||
func (m *M1_1) String() string { return proto.CompactTextString(m) }
|
||||
func (*M1_1) ProtoMessage() {}
|
||||
@ -134,3 +187,71 @@ var fileDescriptor_c1091de3fa870a14 = []byte{
|
||||
0x47, 0x77, 0x53, 0x12, 0x1b, 0x58, 0xa1, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xcc, 0xae, 0xc9,
|
||||
0xcd, 0xae, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_M1_ProtoFile_FileDesc.Enums = xxx_M1_ProtoFile_EnumDescs[0:1]
|
||||
xxx_M1_ProtoFile_FileDesc.Messages = xxx_M1_ProtoFile_MessageDescs[0:2]
|
||||
xxx_M1_ProtoFile_MessageDescs[1].Fields[0].MessageType = xxx_M1_ProtoFile_MessageTypes[0].Type
|
||||
var err error
|
||||
M1_ProtoFile, err = prototype.NewFile(&xxx_M1_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var M1_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_M1_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_a_1/m1.proto",
|
||||
Package: "test.a",
|
||||
}
|
||||
var xxx_M1_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_M1_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return E1(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_M1_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "E1",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "E1_ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_M1_ProtoFile_MessageTypes = [2]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M1_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M1)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M1_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M1_1)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_M1_ProtoFile_MessageDescs = [2]prototype.Message{
|
||||
{
|
||||
Name: "M1",
|
||||
},
|
||||
{
|
||||
Name: "M1_1",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "m1",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "m1",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package test_a_1
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type M2 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M2 struct{ m *M2 }
|
||||
|
||||
func (m *M2) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M2{m}
|
||||
}
|
||||
func (m xxx_M2) Type() protoreflect.MessageType {
|
||||
return xxx_M2_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M2) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M2_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M2) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M2_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M2) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M2) ProtoMutable() {}
|
||||
|
||||
func (m *M2) Reset() { *m = M2{} }
|
||||
func (m *M2) String() string { return proto.CompactTextString(m) }
|
||||
func (*M2) ProtoMessage() {}
|
||||
@ -68,3 +90,35 @@ var fileDescriptor_20cf27515c0d621c = []byte{
|
||||
0x62, 0x03, 0x2b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xe3, 0xe0, 0x7e, 0xc0, 0x77, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_M2_ProtoFile_FileDesc.Messages = xxx_M2_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
M2_ProtoFile, err = prototype.NewFile(&xxx_M2_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var M2_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_M2_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_a_1/m2.proto",
|
||||
Package: "test.a",
|
||||
}
|
||||
var xxx_M2_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M2_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M2)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_M2_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "M2",
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package test_a_2
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type M3 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M3 struct{ m *M3 }
|
||||
|
||||
func (m *M3) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M3{m}
|
||||
}
|
||||
func (m xxx_M3) Type() protoreflect.MessageType {
|
||||
return xxx_M3_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M3) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M3_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M3) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M3_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M3) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M3) ProtoMutable() {}
|
||||
|
||||
func (m *M3) Reset() { *m = M3{} }
|
||||
func (m *M3) String() string { return proto.CompactTextString(m) }
|
||||
func (*M3) ProtoMessage() {}
|
||||
@ -68,3 +90,35 @@ var fileDescriptor_ff9d8f834875c9c5 = []byte{
|
||||
0x62, 0x03, 0x2b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x23, 0x86, 0x27, 0x47, 0x77, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_M3_ProtoFile_FileDesc.Messages = xxx_M3_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
M3_ProtoFile, err = prototype.NewFile(&xxx_M3_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var M3_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_M3_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_a_2/m3.proto",
|
||||
Package: "test.a",
|
||||
}
|
||||
var xxx_M3_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M3_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M3)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_M3_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "M3",
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package test_a_2
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type M4 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M4 struct{ m *M4 }
|
||||
|
||||
func (m *M4) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M4{m}
|
||||
}
|
||||
func (m xxx_M4) Type() protoreflect.MessageType {
|
||||
return xxx_M4_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M4) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M4_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M4) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M4_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M4) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M4) ProtoMutable() {}
|
||||
|
||||
func (m *M4) Reset() { *m = M4{} }
|
||||
func (m *M4) String() string { return proto.CompactTextString(m) }
|
||||
func (*M4) ProtoMessage() {}
|
||||
@ -68,3 +90,35 @@ var fileDescriptor_fdd24f82f6c5a786 = []byte{
|
||||
0x62, 0x03, 0x2b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x58, 0xcb, 0x10, 0xc8, 0x77, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_M4_ProtoFile_FileDesc.Messages = xxx_M4_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
M4_ProtoFile, err = prototype.NewFile(&xxx_M4_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var M4_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_M4_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_a_2/m4.proto",
|
||||
Package: "test.a",
|
||||
}
|
||||
var xxx_M4_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M4_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M4)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_M4_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "M4",
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package beta
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type M1 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M1 struct{ m *M1 }
|
||||
|
||||
func (m *M1) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M1{m}
|
||||
}
|
||||
func (m xxx_M1) Type() protoreflect.MessageType {
|
||||
return xxx_M1_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M1) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M1_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M1) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M1_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M1) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M1) ProtoMutable() {}
|
||||
|
||||
func (m *M1) Reset() { *m = M1{} }
|
||||
func (m *M1) String() string { return proto.CompactTextString(m) }
|
||||
func (*M1) ProtoMessage() {}
|
||||
@ -68,3 +90,35 @@ var fileDescriptor_7f49573d035512a8 = []byte{
|
||||
0x4b, 0x12, 0xf5, 0xd1, 0xad, 0xb0, 0x4e, 0x4a, 0x2d, 0x49, 0x4c, 0x62, 0x03, 0xab, 0x36, 0x06,
|
||||
0x04, 0x00, 0x00, 0xff, 0xff, 0x4a, 0xf1, 0x3b, 0x7f, 0x82, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_M1_ProtoFile_FileDesc.Messages = xxx_M1_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
M1_ProtoFile, err = prototype.NewFile(&xxx_M1_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var M1_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_M1_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_b_1/m1.proto",
|
||||
Package: "test.b.part1",
|
||||
}
|
||||
var xxx_M1_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M1_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M1)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_M1_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "M1",
|
||||
},
|
||||
}
|
||||
|
||||
@ -6,6 +6,9 @@ package beta
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,25 @@ type M2 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_M2 struct{ m *M2 }
|
||||
|
||||
func (m *M2) ProtoReflect() protoreflect.Message {
|
||||
return xxx_M2{m}
|
||||
}
|
||||
func (m xxx_M2) Type() protoreflect.MessageType {
|
||||
return xxx_M2_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_M2) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_M2_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M2) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_M2_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_M2) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_M2) ProtoMutable() {}
|
||||
|
||||
func (m *M2) Reset() { *m = M2{} }
|
||||
func (m *M2) String() string { return proto.CompactTextString(m) }
|
||||
func (*M2) ProtoMessage() {}
|
||||
@ -68,3 +90,35 @@ var fileDescriptor_a1becddceeb586f2 = []byte{
|
||||
0x4b, 0x12, 0xf5, 0xd1, 0xad, 0xb0, 0x4e, 0x4a, 0x2d, 0x49, 0x4c, 0x62, 0x03, 0xab, 0x36, 0x06,
|
||||
0x04, 0x00, 0x00, 0xff, 0xff, 0x44, 0x29, 0xbe, 0x6d, 0x82, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_M2_ProtoFile_FileDesc.Messages = xxx_M2_ProtoFile_MessageDescs[0:1]
|
||||
var err error
|
||||
M2_ProtoFile, err = prototype.NewFile(&xxx_M2_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var M2_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_M2_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_b_1/m2.proto",
|
||||
Package: "test.b.part2",
|
||||
}
|
||||
var xxx_M2_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_M2_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(M2)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_M2_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "M2",
|
||||
},
|
||||
}
|
||||
|
||||
@ -7,6 +7,9 @@ import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
test_a_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -28,6 +31,25 @@ type A1M1 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_A1M1 struct{ m *A1M1 }
|
||||
|
||||
func (m *A1M1) ProtoReflect() protoreflect.Message {
|
||||
return xxx_A1M1{m}
|
||||
}
|
||||
func (m xxx_A1M1) Type() protoreflect.MessageType {
|
||||
return xxx_TestImportA1M1_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_A1M1) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_TestImportA1M1_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_A1M1) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_TestImportA1M1_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_A1M1) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_A1M1) ProtoMutable() {}
|
||||
|
||||
func (m *A1M1) Reset() { *m = A1M1{} }
|
||||
func (m *A1M1) String() string { return proto.CompactTextString(m) }
|
||||
func (*A1M1) ProtoMessage() {}
|
||||
@ -79,3 +101,48 @@ var fileDescriptor_3b904a47327455f3 = []byte{
|
||||
0x50, 0x0b, 0x93, 0xd8, 0xc0, 0xf2, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x84, 0x2f, 0x18,
|
||||
0x23, 0xa8, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_TestImportA1M1_ProtoFile_FileDesc.Messages = xxx_TestImportA1M1_ProtoFile_MessageDescs[0:1]
|
||||
xxx_TestImportA1M1_ProtoFile_MessageDescs[0].Fields[0].MessageType = protoimpl.X.MessageTypeOf((*test_a_1.M1)(nil))
|
||||
var err error
|
||||
TestImportA1M1_ProtoFile, err = prototype.NewFile(&xxx_TestImportA1M1_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var TestImportA1M1_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_TestImportA1M1_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_import_a1m1.proto",
|
||||
Package: "test",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_a_1/m1.proto", "test.a")},
|
||||
},
|
||||
}
|
||||
var xxx_TestImportA1M1_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_TestImportA1M1_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(A1M1)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_TestImportA1M1_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "A1M1",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "f",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "f",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
@ -7,6 +7,9 @@ import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
test_a_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -28,6 +31,25 @@ type A1M2 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_A1M2 struct{ m *A1M2 }
|
||||
|
||||
func (m *A1M2) ProtoReflect() protoreflect.Message {
|
||||
return xxx_A1M2{m}
|
||||
}
|
||||
func (m xxx_A1M2) Type() protoreflect.MessageType {
|
||||
return xxx_TestImportA1M2_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_A1M2) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_TestImportA1M2_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_A1M2) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_TestImportA1M2_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_A1M2) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_A1M2) ProtoMutable() {}
|
||||
|
||||
func (m *A1M2) Reset() { *m = A1M2{} }
|
||||
func (m *A1M2) String() string { return proto.CompactTextString(m) }
|
||||
func (*A1M2) ProtoMessage() {}
|
||||
@ -79,3 +101,48 @@ var fileDescriptor_bdb27b114687957d = []byte{
|
||||
0x50, 0x0b, 0x93, 0xd8, 0xc0, 0xf2, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x88, 0xfb,
|
||||
0xea, 0xa8, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_TestImportA1M2_ProtoFile_FileDesc.Messages = xxx_TestImportA1M2_ProtoFile_MessageDescs[0:1]
|
||||
xxx_TestImportA1M2_ProtoFile_MessageDescs[0].Fields[0].MessageType = protoimpl.X.MessageTypeOf((*test_a_1.M2)(nil))
|
||||
var err error
|
||||
TestImportA1M2_ProtoFile, err = prototype.NewFile(&xxx_TestImportA1M2_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var TestImportA1M2_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_TestImportA1M2_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_import_a1m2.proto",
|
||||
Package: "test",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_a_1/m2.proto", "test.a")},
|
||||
},
|
||||
}
|
||||
var xxx_TestImportA1M2_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_TestImportA1M2_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(A1M2)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_TestImportA1M2_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "A1M2",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "f",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "f",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
@ -10,6 +10,9 @@ import (
|
||||
test_a_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_1"
|
||||
_ "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_a_2"
|
||||
test_b_1 "github.com/golang/protobuf/protoc-gen-go/testdata/imports/test_b_1"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -35,6 +38,25 @@ type All struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_All struct{ m *All }
|
||||
|
||||
func (m *All) ProtoReflect() protoreflect.Message {
|
||||
return xxx_All{m}
|
||||
}
|
||||
func (m xxx_All) Type() protoreflect.MessageType {
|
||||
return xxx_TestImportAll_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_All) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_TestImportAll_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_All) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_TestImportAll_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_All) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_All) ProtoMutable() {}
|
||||
|
||||
func (m *All) Reset() { *m = All{} }
|
||||
func (m *All) String() string { return proto.CompactTextString(m) }
|
||||
func (*All) ProtoMessage() {}
|
||||
@ -120,3 +142,86 @@ var fileDescriptor_324466f0afc16f77 = []byte{
|
||||
0xb9, 0xd8, 0x64, 0x5f, 0x7c, 0x05, 0x00, 0x00, 0xff, 0xff, 0x88, 0x0e, 0xe2, 0x9f, 0xc7, 0x01,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_TestImportAll_ProtoFile_FileDesc.Messages = xxx_TestImportAll_ProtoFile_MessageDescs[0:1]
|
||||
xxx_TestImportAll_ProtoFile_MessageDescs[0].Fields[0].MessageType = protoimpl.X.MessageTypeOf((*test_a_1.M1)(nil))
|
||||
xxx_TestImportAll_ProtoFile_MessageDescs[0].Fields[1].MessageType = protoimpl.X.MessageTypeOf((*test_a_1.M2)(nil))
|
||||
xxx_TestImportAll_ProtoFile_MessageDescs[0].Fields[2].MessageType = protoimpl.X.MessageTypeOf((*test_b_1.M1)(nil))
|
||||
xxx_TestImportAll_ProtoFile_MessageDescs[0].Fields[3].MessageType = protoimpl.X.MessageTypeOf((*test_b_1.M2)(nil))
|
||||
xxx_TestImportAll_ProtoFile_MessageDescs[0].Fields[4].MessageType = protoimpl.X.MessageTypeOf((*fmt1.M)(nil))
|
||||
var err error
|
||||
TestImportAll_ProtoFile, err = prototype.NewFile(&xxx_TestImportAll_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var TestImportAll_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_TestImportAll_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "imports/test_import_all.proto",
|
||||
Package: "test",
|
||||
Imports: []protoreflect.FileImport{
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_a_1/m1.proto", "test.a")},
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_a_1/m2.proto", "test.a")},
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_a_2/m3.proto", "test.a")},
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_a_2/m4.proto", "test.a")},
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_b_1/m1.proto", "test.b.part1")},
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/test_b_1/m2.proto", "test.b.part2")},
|
||||
{FileDescriptor: prototype.PlaceholderFile("imports/fmt/m.proto", "fmt")},
|
||||
},
|
||||
}
|
||||
var xxx_TestImportAll_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_TestImportAll_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(All)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_TestImportAll_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "All",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "am1",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "am1",
|
||||
},
|
||||
{
|
||||
Name: "am2",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "am2",
|
||||
},
|
||||
{
|
||||
Name: "bm1",
|
||||
Number: 5,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "bm1",
|
||||
},
|
||||
{
|
||||
Name: "bm2",
|
||||
Number: 6,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "bm2",
|
||||
},
|
||||
{
|
||||
Name: "fmt",
|
||||
Number: 7,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "fmt",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
101
cmd/protoc-gen-go/testdata/nopackage/nopackage.pb.go
vendored
101
cmd/protoc-gen-go/testdata/nopackage/nopackage.pb.go
vendored
@ -6,6 +6,9 @@ package nopackage
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,18 @@ const (
|
||||
Enum_ZERO Enum = 0
|
||||
)
|
||||
|
||||
type xxx_Enum Enum
|
||||
|
||||
func (e Enum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_Enum)(e)
|
||||
}
|
||||
func (e xxx_Enum) Type() protoreflect.EnumType {
|
||||
return xxx_Nopackage_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_Enum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var Enum_name = map[int32]string{
|
||||
0: "ZERO",
|
||||
}
|
||||
@ -65,6 +80,25 @@ type Message struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message struct{ m *Message }
|
||||
|
||||
func (m *Message) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message{m}
|
||||
}
|
||||
func (m xxx_Message) Type() protoreflect.MessageType {
|
||||
return xxx_Nopackage_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Message) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Nopackage_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Nopackage_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message) ProtoMutable() {}
|
||||
|
||||
func (m *Message) Reset() { *m = Message{} }
|
||||
func (m *Message) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message) ProtoMessage() {}
|
||||
@ -125,3 +159,70 @@ var fileDescriptor_f33a1d5d178c43c9 = []byte{
|
||||
0x0b, 0x2c, 0x25, 0xc0, 0x00, 0x08, 0x00, 0x00, 0xff, 0xff, 0x31, 0x29, 0xe4, 0xb2, 0x87, 0x00,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Nopackage_ProtoFile_FileDesc.Enums = xxx_Nopackage_ProtoFile_EnumDescs[0:1]
|
||||
xxx_Nopackage_ProtoFile_FileDesc.Messages = xxx_Nopackage_ProtoFile_MessageDescs[0:1]
|
||||
xxx_Nopackage_ProtoFile_MessageDescs[0].Fields[1].EnumType = xxx_Nopackage_ProtoFile_EnumTypes[0]
|
||||
var err error
|
||||
Nopackage_ProtoFile, err = prototype.NewFile(&xxx_Nopackage_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Nopackage_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Nopackage_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "nopackage/nopackage.proto",
|
||||
Package: "",
|
||||
}
|
||||
var xxx_Nopackage_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Nopackage_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return Enum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Nopackage_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "Enum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_Nopackage_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Nopackage_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Nopackage_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "Message",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "string_field",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "stringField",
|
||||
},
|
||||
{
|
||||
Name: "enum_field",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "enumField",
|
||||
Default: protoreflect.ValueOf(string("ZERO")),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
258
cmd/protoc-gen-go/testdata/proto2/enum.pb.go
vendored
258
cmd/protoc-gen-go/testdata/proto2/enum.pb.go
vendored
@ -6,6 +6,9 @@ package proto2
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -30,6 +33,18 @@ const (
|
||||
EnumType1_TWO EnumType1 = 2
|
||||
)
|
||||
|
||||
type xxx_EnumType1 EnumType1
|
||||
|
||||
func (e EnumType1) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_EnumType1)(e)
|
||||
}
|
||||
func (e xxx_EnumType1) Type() protoreflect.EnumType {
|
||||
return xxx_Enum_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_EnumType1) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var EnumType1_name = map[int32]string{
|
||||
1: "ONE",
|
||||
2: "TWO",
|
||||
@ -70,6 +85,18 @@ const (
|
||||
EnumType2_duplicate2 EnumType2 = 1
|
||||
)
|
||||
|
||||
type xxx_EnumType2 EnumType2
|
||||
|
||||
func (e EnumType2) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_EnumType2)(e)
|
||||
}
|
||||
func (e xxx_EnumType2) Type() protoreflect.EnumType {
|
||||
return xxx_Enum_ProtoFile_EnumTypes[1]
|
||||
}
|
||||
func (e xxx_EnumType2) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var EnumType2_name = map[int32]string{
|
||||
1: "duplicate1",
|
||||
// Duplicate value: 1: "duplicate2",
|
||||
@ -111,6 +138,18 @@ const (
|
||||
EnumContainerMessage1_NESTED_1A_VALUE EnumContainerMessage1_NestedEnumType1A = 0
|
||||
)
|
||||
|
||||
type xxx_EnumContainerMessage1_NestedEnumType1A EnumContainerMessage1_NestedEnumType1A
|
||||
|
||||
func (e EnumContainerMessage1_NestedEnumType1A) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_EnumContainerMessage1_NestedEnumType1A)(e)
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_NestedEnumType1A) Type() protoreflect.EnumType {
|
||||
return xxx_Enum_ProtoFile_EnumTypes[2]
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_NestedEnumType1A) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var EnumContainerMessage1_NestedEnumType1A_name = map[int32]string{
|
||||
0: "NESTED_1A_VALUE",
|
||||
}
|
||||
@ -148,6 +187,18 @@ const (
|
||||
EnumContainerMessage1_NESTED_1B_VALUE EnumContainerMessage1_NestedEnumType1B = 0
|
||||
)
|
||||
|
||||
type xxx_EnumContainerMessage1_NestedEnumType1B EnumContainerMessage1_NestedEnumType1B
|
||||
|
||||
func (e EnumContainerMessage1_NestedEnumType1B) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_EnumContainerMessage1_NestedEnumType1B)(e)
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_NestedEnumType1B) Type() protoreflect.EnumType {
|
||||
return xxx_Enum_ProtoFile_EnumTypes[3]
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_NestedEnumType1B) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var EnumContainerMessage1_NestedEnumType1B_name = map[int32]string{
|
||||
0: "NESTED_1B_VALUE",
|
||||
}
|
||||
@ -187,6 +238,18 @@ const (
|
||||
EnumContainerMessage1_EnumContainerMessage2_NESTED_2A_VALUE EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A = 0
|
||||
)
|
||||
|
||||
type xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A
|
||||
|
||||
func (e EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A)(e)
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) Type() protoreflect.EnumType {
|
||||
return xxx_Enum_ProtoFile_EnumTypes[4]
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A_name = map[int32]string{
|
||||
0: "NESTED_2A_VALUE",
|
||||
}
|
||||
@ -224,6 +287,18 @@ const (
|
||||
EnumContainerMessage1_EnumContainerMessage2_NESTED_2B_VALUE EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B = 0
|
||||
)
|
||||
|
||||
type xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B
|
||||
|
||||
func (e EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B)(e)
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) Type() protoreflect.EnumType {
|
||||
return xxx_Enum_ProtoFile_EnumTypes[5]
|
||||
}
|
||||
func (e xxx_EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B_name = map[int32]string{
|
||||
0: "NESTED_2B_VALUE",
|
||||
}
|
||||
@ -263,6 +338,25 @@ type EnumContainerMessage1 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_EnumContainerMessage1 struct{ m *EnumContainerMessage1 }
|
||||
|
||||
func (m *EnumContainerMessage1) ProtoReflect() protoreflect.Message {
|
||||
return xxx_EnumContainerMessage1{m}
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1) Type() protoreflect.MessageType {
|
||||
return xxx_Enum_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Enum_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Enum_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1) ProtoMutable() {}
|
||||
|
||||
func (m *EnumContainerMessage1) Reset() { *m = EnumContainerMessage1{} }
|
||||
func (m *EnumContainerMessage1) String() string { return proto.CompactTextString(m) }
|
||||
func (*EnumContainerMessage1) ProtoMessage() {}
|
||||
@ -311,6 +405,27 @@ type EnumContainerMessage1_EnumContainerMessage2 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_EnumContainerMessage1_EnumContainerMessage2 struct {
|
||||
m *EnumContainerMessage1_EnumContainerMessage2
|
||||
}
|
||||
|
||||
func (m *EnumContainerMessage1_EnumContainerMessage2) ProtoReflect() protoreflect.Message {
|
||||
return xxx_EnumContainerMessage1_EnumContainerMessage2{m}
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1_EnumContainerMessage2) Type() protoreflect.MessageType {
|
||||
return xxx_Enum_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1_EnumContainerMessage2) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Enum_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1_EnumContainerMessage2) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Enum_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1_EnumContainerMessage2) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_EnumContainerMessage1_EnumContainerMessage2) ProtoMutable() {}
|
||||
|
||||
func (m *EnumContainerMessage1_EnumContainerMessage2) Reset() {
|
||||
*m = EnumContainerMessage1_EnumContainerMessage2{}
|
||||
}
|
||||
@ -375,3 +490,146 @@ var fileDescriptor_de9f68860d540858 = []byte{
|
||||
0x33, 0x65, 0x98, 0x95, 0x85, 0x8d, 0x85, 0x15, 0xd5, 0x18, 0x3e, 0x02, 0x00, 0x00, 0xff, 0xff,
|
||||
0x26, 0xf5, 0x57, 0x52, 0x4e, 0x02, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Enum_ProtoFile_FileDesc.Enums = xxx_Enum_ProtoFile_EnumDescs[0:2]
|
||||
xxx_Enum_ProtoFile_FileDesc.Messages = xxx_Enum_ProtoFile_MessageDescs[0:1]
|
||||
xxx_Enum_ProtoFile_MessageDescs[0].Enums = xxx_Enum_ProtoFile_EnumDescs[2:4]
|
||||
xxx_Enum_ProtoFile_MessageDescs[0].Messages = xxx_Enum_ProtoFile_MessageDescs[1:2]
|
||||
xxx_Enum_ProtoFile_MessageDescs[1].Enums = xxx_Enum_ProtoFile_EnumDescs[4:6]
|
||||
xxx_Enum_ProtoFile_MessageDescs[0].Fields[0].EnumType = xxx_Enum_ProtoFile_EnumTypes[1]
|
||||
xxx_Enum_ProtoFile_MessageDescs[0].Fields[1].EnumType = xxx_Enum_ProtoFile_EnumTypes[1]
|
||||
var err error
|
||||
Enum_ProtoFile, err = prototype.NewFile(&xxx_Enum_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Enum_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Enum_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "proto2/enum.proto",
|
||||
Package: "goproto.protoc.proto2",
|
||||
}
|
||||
var xxx_Enum_ProtoFile_EnumTypes = [6]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Enum_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return EnumType1(n)
|
||||
},
|
||||
),
|
||||
prototype.GoEnum(
|
||||
xxx_Enum_ProtoFile_EnumDescs[1].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return EnumType2(n)
|
||||
},
|
||||
),
|
||||
prototype.GoEnum(
|
||||
xxx_Enum_ProtoFile_EnumDescs[2].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return EnumContainerMessage1_NestedEnumType1A(n)
|
||||
},
|
||||
),
|
||||
prototype.GoEnum(
|
||||
xxx_Enum_ProtoFile_EnumDescs[3].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return EnumContainerMessage1_NestedEnumType1B(n)
|
||||
},
|
||||
),
|
||||
prototype.GoEnum(
|
||||
xxx_Enum_ProtoFile_EnumDescs[4].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2A(n)
|
||||
},
|
||||
),
|
||||
prototype.GoEnum(
|
||||
xxx_Enum_ProtoFile_EnumDescs[5].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return EnumContainerMessage1_EnumContainerMessage2_NestedEnumType2B(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Enum_ProtoFile_EnumDescs = [6]prototype.Enum{
|
||||
{
|
||||
Name: "EnumType1",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ONE", Number: 1},
|
||||
{Name: "TWO", Number: 2},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "EnumType2",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "duplicate1", Number: 1},
|
||||
{Name: "duplicate2", Number: 1},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "NestedEnumType1A",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "NESTED_1A_VALUE", Number: 0},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "NestedEnumType1B",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "NESTED_1B_VALUE", Number: 0},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "NestedEnumType2A",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "NESTED_2A_VALUE", Number: 0},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "NestedEnumType2B",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "NESTED_2B_VALUE", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_Enum_ProtoFile_MessageTypes = [2]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Enum_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(EnumContainerMessage1)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Enum_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(EnumContainerMessage1_EnumContainerMessage2)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Enum_ProtoFile_MessageDescs = [2]prototype.Message{
|
||||
{
|
||||
Name: "EnumContainerMessage1",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "default_duplicate1",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "defaultDuplicate1",
|
||||
Default: protoreflect.ValueOf(string("duplicate1")),
|
||||
},
|
||||
{
|
||||
Name: "default_duplicate2",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "defaultDuplicate2",
|
||||
Default: protoreflect.ValueOf(string("duplicate2")),
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "EnumContainerMessage2",
|
||||
},
|
||||
}
|
||||
|
||||
1110
cmd/protoc-gen-go/testdata/proto2/fields.pb.go
vendored
1110
cmd/protoc-gen-go/testdata/proto2/fields.pb.go
vendored
File diff suppressed because it is too large
Load Diff
@ -6,6 +6,9 @@ package proto2
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -28,6 +31,25 @@ type Layer1 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Layer1 struct{ m *Layer1 }
|
||||
|
||||
func (m *Layer1) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Layer1{m}
|
||||
}
|
||||
func (m xxx_Layer1) Type() protoreflect.MessageType {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Layer1) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Layer1) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Layer1) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Layer1) ProtoMutable() {}
|
||||
|
||||
func (m *Layer1) Reset() { *m = Layer1{} }
|
||||
func (m *Layer1) String() string { return proto.CompactTextString(m) }
|
||||
func (*Layer1) ProtoMessage() {}
|
||||
@ -74,6 +96,25 @@ type Layer1_Layer2 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Layer1_Layer2 struct{ m *Layer1_Layer2 }
|
||||
|
||||
func (m *Layer1_Layer2) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Layer1_Layer2{m}
|
||||
}
|
||||
func (m xxx_Layer1_Layer2) Type() protoreflect.MessageType {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[1].Type
|
||||
}
|
||||
func (m xxx_Layer1_Layer2) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[1].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Layer1_Layer2) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[1].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Layer1_Layer2) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Layer1_Layer2) ProtoMutable() {}
|
||||
|
||||
func (m *Layer1_Layer2) Reset() { *m = Layer1_Layer2{} }
|
||||
func (m *Layer1_Layer2) String() string { return proto.CompactTextString(m) }
|
||||
func (*Layer1_Layer2) ProtoMessage() {}
|
||||
@ -112,6 +153,25 @@ type Layer1_Layer2_Layer3 struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Layer1_Layer2_Layer3 struct{ m *Layer1_Layer2_Layer3 }
|
||||
|
||||
func (m *Layer1_Layer2_Layer3) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Layer1_Layer2_Layer3{m}
|
||||
}
|
||||
func (m xxx_Layer1_Layer2_Layer3) Type() protoreflect.MessageType {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[2].Type
|
||||
}
|
||||
func (m xxx_Layer1_Layer2_Layer3) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[2].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Layer1_Layer2_Layer3) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_NestedMessages_ProtoFile_MessageTypes[2].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Layer1_Layer2_Layer3) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Layer1_Layer2_Layer3) ProtoMutable() {}
|
||||
|
||||
func (m *Layer1_Layer2_Layer3) Reset() { *m = Layer1_Layer2_Layer3{} }
|
||||
func (m *Layer1_Layer2_Layer3) String() string { return proto.CompactTextString(m) }
|
||||
func (*Layer1_Layer2_Layer3) ProtoMessage() {}
|
||||
@ -160,3 +220,83 @@ var fileDescriptor_7417ee157699d191 = []byte{
|
||||
0x79, 0xba, 0xe9, 0xf9, 0xfa, 0x25, 0xa9, 0xc5, 0x25, 0x29, 0x89, 0x25, 0x89, 0x10, 0x61, 0x23,
|
||||
0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x11, 0x21, 0xb0, 0x06, 0x47, 0x01, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_NestedMessages_ProtoFile_FileDesc.Messages = xxx_NestedMessages_ProtoFile_MessageDescs[0:1]
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[0].Messages = xxx_NestedMessages_ProtoFile_MessageDescs[1:2]
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[1].Messages = xxx_NestedMessages_ProtoFile_MessageDescs[2:3]
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[0].Fields[0].MessageType = xxx_NestedMessages_ProtoFile_MessageTypes[1].Type
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[0].Fields[1].MessageType = xxx_NestedMessages_ProtoFile_MessageTypes[2].Type
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[1].Fields[0].MessageType = xxx_NestedMessages_ProtoFile_MessageTypes[2].Type
|
||||
var err error
|
||||
NestedMessages_ProtoFile, err = prototype.NewFile(&xxx_NestedMessages_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var NestedMessages_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_NestedMessages_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "proto2/nested_messages.proto",
|
||||
Package: "goproto.protoc.proto2",
|
||||
}
|
||||
var xxx_NestedMessages_ProtoFile_MessageTypes = [3]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Layer1)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[1].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Layer1_Layer2)
|
||||
},
|
||||
)},
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_NestedMessages_ProtoFile_MessageDescs[2].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Layer1_Layer2_Layer3)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_NestedMessages_ProtoFile_MessageDescs = [3]prototype.Message{
|
||||
{
|
||||
Name: "Layer1",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "l2",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "l2",
|
||||
},
|
||||
{
|
||||
Name: "l3",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "l3",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "Layer2",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "l3",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "l3",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "Layer3",
|
||||
},
|
||||
}
|
||||
|
||||
71
cmd/protoc-gen-go/testdata/proto2/proto2.pb.go
vendored
71
cmd/protoc-gen-go/testdata/proto2/proto2.pb.go
vendored
@ -6,6 +6,9 @@ package proto2
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -28,6 +31,25 @@ type Message struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_Message struct{ m *Message }
|
||||
|
||||
func (m *Message) ProtoReflect() protoreflect.Message {
|
||||
return xxx_Message{m}
|
||||
}
|
||||
func (m xxx_Message) Type() protoreflect.MessageType {
|
||||
return xxx_Proto2_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_Message) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Proto2_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Proto2_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_Message) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_Message) ProtoMutable() {}
|
||||
|
||||
func (m *Message) Reset() { *m = Message{} }
|
||||
func (m *Message) String() string { return proto.CompactTextString(m) }
|
||||
func (*Message) ProtoMessage() {}
|
||||
@ -86,3 +108,52 @@ var fileDescriptor_d756bbe8817c03c1 = []byte{
|
||||
0x49, 0x6a, 0x71, 0x49, 0x4a, 0x62, 0x49, 0x22, 0xd4, 0xa9, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff,
|
||||
0x85, 0x42, 0x0d, 0x5f, 0xba, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Proto2_ProtoFile_FileDesc.Messages = xxx_Proto2_ProtoFile_MessageDescs[0:1]
|
||||
xxx_Proto2_ProtoFile_MessageDescs[0].Fields[1].MessageType = xxx_Proto2_ProtoFile_MessageTypes[0].Type
|
||||
var err error
|
||||
Proto2_ProtoFile, err = prototype.NewFile(&xxx_Proto2_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Proto2_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Proto2_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto2,
|
||||
Path: "proto2/proto2.proto",
|
||||
Package: "goproto.protoc.proto2",
|
||||
}
|
||||
var xxx_Proto2_ProtoFile_MessageTypes = [1]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Proto2_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(Message)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Proto2_ProtoFile_MessageDescs = [1]prototype.Message{
|
||||
{
|
||||
Name: "Message",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "i32",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int32Kind,
|
||||
JSONName: "i32",
|
||||
},
|
||||
{
|
||||
Name: "m",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "m",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
52
cmd/protoc-gen-go/testdata/proto3/enum.pb.go
vendored
52
cmd/protoc-gen-go/testdata/proto3/enum.pb.go
vendored
@ -6,6 +6,9 @@ package proto3
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -28,6 +31,18 @@ const (
|
||||
Enum_TWO Enum = 2
|
||||
)
|
||||
|
||||
type xxx_Enum Enum
|
||||
|
||||
func (e Enum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_Enum)(e)
|
||||
}
|
||||
func (e xxx_Enum) Type() protoreflect.EnumType {
|
||||
return xxx_Enum_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_Enum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var Enum_name = map[int32]string{
|
||||
0: "ZERO",
|
||||
1: "ONE",
|
||||
@ -66,3 +81,40 @@ var fileDescriptor_b4b9b1e8d161a9a6 = []byte{
|
||||
0x6e, 0x7a, 0xbe, 0x7e, 0x49, 0x6a, 0x71, 0x49, 0x4a, 0x62, 0x49, 0x22, 0x44, 0xd8, 0x38, 0x89,
|
||||
0x0d, 0x42, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x96, 0x4a, 0x7d, 0xc7, 0x99, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Enum_ProtoFile_FileDesc.Enums = xxx_Enum_ProtoFile_EnumDescs[0:1]
|
||||
var err error
|
||||
Enum_ProtoFile, err = prototype.NewFile(&xxx_Enum_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Enum_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Enum_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "proto3/enum.proto",
|
||||
Package: "goproto.protoc.proto3",
|
||||
}
|
||||
var xxx_Enum_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Enum_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return Enum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Enum_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "Enum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ZERO", Number: 0},
|
||||
{Name: "ONE", Number: 1},
|
||||
{Name: "TWO", Number: 2},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
442
cmd/protoc-gen-go/testdata/proto3/fields.pb.go
vendored
442
cmd/protoc-gen-go/testdata/proto3/fields.pb.go
vendored
@ -6,6 +6,9 @@ package proto3
|
||||
import (
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
|
||||
prototype "github.com/golang/protobuf/v2/reflect/prototype"
|
||||
protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -26,6 +29,18 @@ const (
|
||||
FieldTestMessage_ZERO FieldTestMessage_Enum = 0
|
||||
)
|
||||
|
||||
type xxx_FieldTestMessage_Enum FieldTestMessage_Enum
|
||||
|
||||
func (e FieldTestMessage_Enum) ProtoReflect() protoreflect.Enum {
|
||||
return (xxx_FieldTestMessage_Enum)(e)
|
||||
}
|
||||
func (e xxx_FieldTestMessage_Enum) Type() protoreflect.EnumType {
|
||||
return xxx_Fields_ProtoFile_EnumTypes[0]
|
||||
}
|
||||
func (e xxx_FieldTestMessage_Enum) Number() protoreflect.EnumNumber {
|
||||
return protoreflect.EnumNumber(e)
|
||||
}
|
||||
|
||||
var FieldTestMessage_Enum_name = map[int32]string{
|
||||
0: "ZERO",
|
||||
}
|
||||
@ -85,6 +100,25 @@ type FieldTestMessage struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_FieldTestMessage struct{ m *FieldTestMessage }
|
||||
|
||||
func (m *FieldTestMessage) ProtoReflect() protoreflect.Message {
|
||||
return xxx_FieldTestMessage{m}
|
||||
}
|
||||
func (m xxx_FieldTestMessage) Type() protoreflect.MessageType {
|
||||
return xxx_Fields_ProtoFile_MessageTypes[0].Type
|
||||
}
|
||||
func (m xxx_FieldTestMessage) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Fields_ProtoFile_MessageTypes[0].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_FieldTestMessage) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Fields_ProtoFile_MessageTypes[0].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_FieldTestMessage) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_FieldTestMessage) ProtoMutable() {}
|
||||
|
||||
func (m *FieldTestMessage) Reset() { *m = FieldTestMessage{} }
|
||||
func (m *FieldTestMessage) String() string { return proto.CompactTextString(m) }
|
||||
func (*FieldTestMessage) ProtoMessage() {}
|
||||
@ -375,6 +409,25 @@ type FieldTestMessage_Message struct {
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
type xxx_FieldTestMessage_Message struct{ m *FieldTestMessage_Message }
|
||||
|
||||
func (m *FieldTestMessage_Message) ProtoReflect() protoreflect.Message {
|
||||
return xxx_FieldTestMessage_Message{m}
|
||||
}
|
||||
func (m xxx_FieldTestMessage_Message) Type() protoreflect.MessageType {
|
||||
return xxx_Fields_ProtoFile_MessageTypes[4].Type
|
||||
}
|
||||
func (m xxx_FieldTestMessage_Message) KnownFields() protoreflect.KnownFields {
|
||||
return xxx_Fields_ProtoFile_MessageTypes[4].KnownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_FieldTestMessage_Message) UnknownFields() protoreflect.UnknownFields {
|
||||
return xxx_Fields_ProtoFile_MessageTypes[4].UnknownFieldsOf(m.m)
|
||||
}
|
||||
func (m xxx_FieldTestMessage_Message) Interface() protoreflect.ProtoMessage {
|
||||
return m.m
|
||||
}
|
||||
func (m xxx_FieldTestMessage_Message) ProtoMutable() {}
|
||||
|
||||
func (m *FieldTestMessage_Message) Reset() { *m = FieldTestMessage_Message{} }
|
||||
func (m *FieldTestMessage_Message) String() string { return proto.CompactTextString(m) }
|
||||
func (*FieldTestMessage_Message) ProtoMessage() {}
|
||||
@ -466,3 +519,392 @@ var fileDescriptor_f1e3ea068187307c = []byte{
|
||||
0x3a, 0xb6, 0x7f, 0xe8, 0x04, 0xdd, 0xd0, 0x5e, 0x86, 0x13, 0x2b, 0xb4, 0x78, 0xb9, 0x3f, 0xaa,
|
||||
0xf0, 0xeb, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x1c, 0x0b, 0xbf, 0x4a, 0x09, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func init() {
|
||||
xxx_Fields_ProtoFile_FileDesc.Messages = xxx_Fields_ProtoFile_MessageDescs[0:1]
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Enums = xxx_Fields_ProtoFile_EnumDescs[0:1]
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Messages = xxx_Fields_ProtoFile_MessageDescs[1:5]
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Fields[1].EnumType = xxx_Fields_ProtoFile_EnumTypes[0]
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Fields[16].MessageType = xxx_Fields_ProtoFile_MessageTypes[4].Type
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Fields[18].EnumType = xxx_Fields_ProtoFile_EnumTypes[0]
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Fields[33].MessageType = xxx_Fields_ProtoFile_MessageTypes[4].Type
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Fields[34].MessageType = xxx_Fields_ProtoFile_MessageDescs[1].Reference()
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Fields[35].MessageType = xxx_Fields_ProtoFile_MessageDescs[2].Reference()
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Fields[36].MessageType = xxx_Fields_ProtoFile_MessageDescs[3].Reference()
|
||||
xxx_Fields_ProtoFile_MessageDescs[2].Fields[1].MessageType = xxx_Fields_ProtoFile_MessageTypes[4].Type
|
||||
xxx_Fields_ProtoFile_MessageDescs[3].Fields[1].EnumType = xxx_Fields_ProtoFile_EnumTypes[0]
|
||||
var err error
|
||||
Fields_ProtoFile, err = prototype.NewFile(&xxx_Fields_ProtoFile_FileDesc)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)
|
||||
|
||||
var Fields_ProtoFile protoreflect.FileDescriptor
|
||||
|
||||
var xxx_Fields_ProtoFile_FileDesc = prototype.File{
|
||||
Syntax: protoreflect.Proto3,
|
||||
Path: "proto3/fields.proto",
|
||||
Package: "goproto.protoc.proto3",
|
||||
}
|
||||
var xxx_Fields_ProtoFile_EnumTypes = [1]protoreflect.EnumType{
|
||||
prototype.GoEnum(
|
||||
xxx_Fields_ProtoFile_EnumDescs[0].Reference(),
|
||||
func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.ProtoEnum {
|
||||
return FieldTestMessage_Enum(n)
|
||||
},
|
||||
),
|
||||
}
|
||||
var xxx_Fields_ProtoFile_EnumDescs = [1]prototype.Enum{
|
||||
{
|
||||
Name: "Enum",
|
||||
Values: []prototype.EnumValue{
|
||||
{Name: "ZERO", Number: 0},
|
||||
},
|
||||
},
|
||||
}
|
||||
var xxx_Fields_ProtoFile_MessageTypes = [5]protoimpl.MessageType{
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Fields_ProtoFile_MessageDescs[0].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(FieldTestMessage)
|
||||
},
|
||||
)},
|
||||
{ /* no message type for FieldTestMessage_MapInt32Int64Entry */ },
|
||||
{ /* no message type for FieldTestMessage_MapStringMessageEntry */ },
|
||||
{ /* no message type for FieldTestMessage_MapFixed64EnumEntry */ },
|
||||
{Type: prototype.GoMessage(
|
||||
xxx_Fields_ProtoFile_MessageDescs[4].Reference(),
|
||||
func(protoreflect.MessageType) protoreflect.ProtoMessage {
|
||||
return new(FieldTestMessage_Message)
|
||||
},
|
||||
)},
|
||||
}
|
||||
var xxx_Fields_ProtoFile_MessageDescs = [5]prototype.Message{
|
||||
{
|
||||
Name: "FieldTestMessage",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "optional_bool",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "optionalBool",
|
||||
},
|
||||
{
|
||||
Name: "optional_enum",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "optionalEnum",
|
||||
},
|
||||
{
|
||||
Name: "optional_int32",
|
||||
Number: 3,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int32Kind,
|
||||
JSONName: "optionalInt32",
|
||||
},
|
||||
{
|
||||
Name: "optional_sint32",
|
||||
Number: 4,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Sint32Kind,
|
||||
JSONName: "optionalSint32",
|
||||
},
|
||||
{
|
||||
Name: "optional_uint32",
|
||||
Number: 5,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Uint32Kind,
|
||||
JSONName: "optionalUint32",
|
||||
},
|
||||
{
|
||||
Name: "optional_int64",
|
||||
Number: 6,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int64Kind,
|
||||
JSONName: "optionalInt64",
|
||||
},
|
||||
{
|
||||
Name: "optional_sint64",
|
||||
Number: 7,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Sint64Kind,
|
||||
JSONName: "optionalSint64",
|
||||
},
|
||||
{
|
||||
Name: "optional_uint64",
|
||||
Number: 8,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Uint64Kind,
|
||||
JSONName: "optionalUint64",
|
||||
},
|
||||
{
|
||||
Name: "optional_sfixed32",
|
||||
Number: 9,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Sfixed32Kind,
|
||||
JSONName: "optionalSfixed32",
|
||||
},
|
||||
{
|
||||
Name: "optional_fixed32",
|
||||
Number: 10,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Fixed32Kind,
|
||||
JSONName: "optionalFixed32",
|
||||
},
|
||||
{
|
||||
Name: "optional_float",
|
||||
Number: 11,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.FloatKind,
|
||||
JSONName: "optionalFloat",
|
||||
},
|
||||
{
|
||||
Name: "optional_sfixed64",
|
||||
Number: 12,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Sfixed64Kind,
|
||||
JSONName: "optionalSfixed64",
|
||||
},
|
||||
{
|
||||
Name: "optional_fixed64",
|
||||
Number: 13,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Fixed64Kind,
|
||||
JSONName: "optionalFixed64",
|
||||
},
|
||||
{
|
||||
Name: "optional_double",
|
||||
Number: 14,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.DoubleKind,
|
||||
JSONName: "optionalDouble",
|
||||
},
|
||||
{
|
||||
Name: "optional_string",
|
||||
Number: 15,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "optionalString",
|
||||
},
|
||||
{
|
||||
Name: "optional_bytes",
|
||||
Number: 16,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.BytesKind,
|
||||
JSONName: "optionalBytes",
|
||||
},
|
||||
{
|
||||
Name: "optional_Message",
|
||||
Number: 17,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "optionalMessage",
|
||||
},
|
||||
{
|
||||
Name: "repeated_bool",
|
||||
Number: 201,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.BoolKind,
|
||||
JSONName: "repeatedBool",
|
||||
},
|
||||
{
|
||||
Name: "repeated_enum",
|
||||
Number: 202,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "repeatedEnum",
|
||||
},
|
||||
{
|
||||
Name: "repeated_int32",
|
||||
Number: 203,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Int32Kind,
|
||||
JSONName: "repeatedInt32",
|
||||
},
|
||||
{
|
||||
Name: "repeated_sint32",
|
||||
Number: 204,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Sint32Kind,
|
||||
JSONName: "repeatedSint32",
|
||||
},
|
||||
{
|
||||
Name: "repeated_uint32",
|
||||
Number: 205,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Uint32Kind,
|
||||
JSONName: "repeatedUint32",
|
||||
},
|
||||
{
|
||||
Name: "repeated_int64",
|
||||
Number: 206,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Int64Kind,
|
||||
JSONName: "repeatedInt64",
|
||||
},
|
||||
{
|
||||
Name: "repeated_sint64",
|
||||
Number: 207,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Sint64Kind,
|
||||
JSONName: "repeatedSint64",
|
||||
},
|
||||
{
|
||||
Name: "repeated_uint64",
|
||||
Number: 208,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Uint64Kind,
|
||||
JSONName: "repeatedUint64",
|
||||
},
|
||||
{
|
||||
Name: "repeated_sfixed32",
|
||||
Number: 209,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Sfixed32Kind,
|
||||
JSONName: "repeatedSfixed32",
|
||||
},
|
||||
{
|
||||
Name: "repeated_fixed32",
|
||||
Number: 210,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Fixed32Kind,
|
||||
JSONName: "repeatedFixed32",
|
||||
},
|
||||
{
|
||||
Name: "repeated_float",
|
||||
Number: 211,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.FloatKind,
|
||||
JSONName: "repeatedFloat",
|
||||
},
|
||||
{
|
||||
Name: "repeated_sfixed64",
|
||||
Number: 212,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Sfixed64Kind,
|
||||
JSONName: "repeatedSfixed64",
|
||||
},
|
||||
{
|
||||
Name: "repeated_fixed64",
|
||||
Number: 213,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.Fixed64Kind,
|
||||
JSONName: "repeatedFixed64",
|
||||
},
|
||||
{
|
||||
Name: "repeated_double",
|
||||
Number: 214,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.DoubleKind,
|
||||
JSONName: "repeatedDouble",
|
||||
},
|
||||
{
|
||||
Name: "repeated_string",
|
||||
Number: 215,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "repeatedString",
|
||||
},
|
||||
{
|
||||
Name: "repeated_bytes",
|
||||
Number: 216,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.BytesKind,
|
||||
JSONName: "repeatedBytes",
|
||||
},
|
||||
{
|
||||
Name: "repeated_Message",
|
||||
Number: 217,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "repeatedMessage",
|
||||
},
|
||||
{
|
||||
Name: "map_int32_int64",
|
||||
Number: 500,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "mapInt32Int64",
|
||||
},
|
||||
{
|
||||
Name: "map_string_message",
|
||||
Number: 501,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "mapStringMessage",
|
||||
},
|
||||
{
|
||||
Name: "map_fixed64_enum",
|
||||
Number: 502,
|
||||
Cardinality: protoreflect.Repeated,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "mapFixed64Enum",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "MapInt32Int64Entry",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "key",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int32Kind,
|
||||
JSONName: "key",
|
||||
},
|
||||
{
|
||||
Name: "value",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Int64Kind,
|
||||
JSONName: "value",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "MapStringMessageEntry",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "key",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.StringKind,
|
||||
JSONName: "key",
|
||||
},
|
||||
{
|
||||
Name: "value",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.MessageKind,
|
||||
JSONName: "value",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "MapFixed64EnumEntry",
|
||||
Fields: []prototype.Field{
|
||||
{
|
||||
Name: "key",
|
||||
Number: 1,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.Fixed64Kind,
|
||||
JSONName: "key",
|
||||
},
|
||||
{
|
||||
Name: "value",
|
||||
Number: 2,
|
||||
Cardinality: protoreflect.Optional,
|
||||
Kind: protoreflect.EnumKind,
|
||||
JSONName: "value",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "Message",
|
||||
},
|
||||
}
|
||||
|
||||
@ -46,18 +46,36 @@ func (p GoImportPath) Ident(s string) GoIdent {
|
||||
// A GoPackageName is the name of a Go package. e.g., "protobuf".
|
||||
type GoPackageName string
|
||||
|
||||
// cleanPacakgeName converts a string to a valid Go package name.
|
||||
// cleanPackageName converts a string to a valid Go package name.
|
||||
func cleanPackageName(name string) GoPackageName {
|
||||
name = strings.Map(badToUnderscore, name)
|
||||
// Identifier must not be keyword: insert _.
|
||||
if token.Lookup(name).IsKeyword() {
|
||||
name = "_" + name
|
||||
return GoPackageName(cleanGoName(name, false))
|
||||
}
|
||||
|
||||
// cleanGoName converts a string to a valid Go identifier.
|
||||
// If mustExport, then the returned identifier is exported if not already.
|
||||
func cleanGoName(name string, mustExport bool) string {
|
||||
name = strings.Map(func(r rune) rune {
|
||||
if unicode.IsLetter(r) || unicode.IsDigit(r) {
|
||||
return r
|
||||
}
|
||||
return '_'
|
||||
}, name)
|
||||
prefix := "_"
|
||||
if mustExport {
|
||||
prefix = "X"
|
||||
}
|
||||
// Identifier must not begin with digit: insert _.
|
||||
if r, _ := utf8.DecodeRuneInString(name); unicode.IsDigit(r) {
|
||||
name = "_" + name
|
||||
switch r, n := utf8.DecodeRuneInString(name); {
|
||||
case token.Lookup(name).IsKeyword():
|
||||
return prefix + name
|
||||
case unicode.IsDigit(r):
|
||||
return prefix + name
|
||||
case mustExport && !unicode.IsUpper(r):
|
||||
if unicode.IsLower(r) {
|
||||
return string(unicode.ToUpper(r)) + name[n:]
|
||||
}
|
||||
return prefix + name
|
||||
}
|
||||
return GoPackageName(name)
|
||||
return name
|
||||
}
|
||||
|
||||
var isGoPredeclaredIdentifier = map[string]bool{
|
||||
@ -102,16 +120,6 @@ var isGoPredeclaredIdentifier = map[string]bool{
|
||||
"uintptr": true,
|
||||
}
|
||||
|
||||
// badToUnderscore is the mapping function used to generate Go names from package names,
|
||||
// which can be dotted in the input .proto file. It replaces non-identifier characters such as
|
||||
// dot or dash with underscore.
|
||||
func badToUnderscore(r rune) rune {
|
||||
if unicode.IsLetter(r) || unicode.IsDigit(r) || r == '_' {
|
||||
return r
|
||||
}
|
||||
return '_'
|
||||
}
|
||||
|
||||
// baseName returns the last path element of the name, with the last dotted suffix removed.
|
||||
func baseName(name string) string {
|
||||
// First, find the last element
|
||||
|
||||
@ -25,6 +25,11 @@ func TestCamelCase(t *testing.T) {
|
||||
{"_one._two", "XOne_XTwo"},
|
||||
{"SCREAMING_SNAKE_CASE", "SCREAMING_SNAKE_CASE"},
|
||||
{"double__underscore", "Double_Underscore"},
|
||||
{"camelCase", "CamelCase"},
|
||||
{"go2proto", "Go2Proto"},
|
||||
{"世界", "世界"},
|
||||
{"x世界", "X世界"},
|
||||
{"foo_bar世界", "FooBar世界"},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
if got := camelCase(tc.in); got != tc.want {
|
||||
@ -32,3 +37,24 @@ func TestCamelCase(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCleanGoName(t *testing.T) {
|
||||
tests := []struct {
|
||||
in, want, wantExported string
|
||||
}{
|
||||
{"", "", "X"},
|
||||
{"hello", "hello", "Hello"},
|
||||
{"hello-world!!", "hello_world__", "Hello_world__"},
|
||||
{"hello-\xde\xad\xbe\xef\x00", "hello_____", "Hello_____"},
|
||||
{"hello 世界", "hello_世界", "Hello_世界"},
|
||||
{"世界", "世界", "X世界"},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
if got := cleanGoName(tc.in, false); got != tc.want {
|
||||
t.Errorf("cleanGoName(%q, false) = %q, want %q", tc.in, got, tc.want)
|
||||
}
|
||||
if got := cleanGoName(tc.in, true); got != tc.wantExported {
|
||||
t.Errorf("cleanGoName(%q, true) = %q, want %q", tc.in, got, tc.wantExported)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -379,13 +379,14 @@ type File struct {
|
||||
Desc protoreflect.FileDescriptor
|
||||
Proto *descriptorpb.FileDescriptorProto
|
||||
|
||||
GoPackageName GoPackageName // name of this file's Go package
|
||||
GoImportPath GoImportPath // import path of this file's Go package
|
||||
Messages []*Message // top-level message declarations
|
||||
Enums []*Enum // top-level enum declarations
|
||||
Extensions []*Extension // top-level extension declarations
|
||||
Services []*Service // top-level service declarations
|
||||
Generate bool // true if we should generate code for this file
|
||||
GoDescriptorIdent GoIdent // name of Go variable for the file descriptor
|
||||
GoPackageName GoPackageName // name of this file's Go package
|
||||
GoImportPath GoImportPath // import path of this file's Go package
|
||||
Messages []*Message // top-level message declarations
|
||||
Enums []*Enum // top-level enum declarations
|
||||
Extensions []*Extension // top-level extension declarations
|
||||
Services []*Service // top-level service declarations
|
||||
Generate bool // true if we should generate code for this file
|
||||
|
||||
// GeneratedFilenamePrefix is used to construct filenames for generated
|
||||
// files associated with this source file.
|
||||
@ -429,6 +430,10 @@ func newFile(gen *Plugin, p *descriptorpb.FileDescriptorProto, packageName GoPac
|
||||
prefix = path.Join(string(importPath), path.Base(prefix))
|
||||
}
|
||||
}
|
||||
f.GoDescriptorIdent = GoIdent{
|
||||
GoName: camelCase(cleanGoName(path.Base(prefix), true)) + "_ProtoFile",
|
||||
GoImportPath: f.GoImportPath,
|
||||
}
|
||||
f.GeneratedFilenamePrefix = prefix
|
||||
|
||||
for _, loc := range p.GetSourceCodeInfo().GetLocation() {
|
||||
|
||||
@ -65,6 +65,8 @@ func (s Syntax) IsValid() bool {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// String returns s as a proto source identifier.
|
||||
func (s Syntax) String() string {
|
||||
switch s {
|
||||
case Proto2:
|
||||
@ -76,6 +78,18 @@ func (s Syntax) String() string {
|
||||
}
|
||||
}
|
||||
|
||||
// GoString returns s as a Go source identifier.
|
||||
func (s Syntax) GoString() string {
|
||||
switch s {
|
||||
case Proto2:
|
||||
return "Proto2"
|
||||
case Proto3:
|
||||
return "Proto3"
|
||||
default:
|
||||
return "<unknown>"
|
||||
}
|
||||
}
|
||||
|
||||
// Cardinality determines whether a field is optional, required, or repeated.
|
||||
type Cardinality cardinality
|
||||
|
||||
@ -97,6 +111,8 @@ func (c Cardinality) IsValid() bool {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// String returns c as a proto source identifier.
|
||||
func (c Cardinality) String() string {
|
||||
switch c {
|
||||
case Optional:
|
||||
@ -110,6 +126,20 @@ func (c Cardinality) String() string {
|
||||
}
|
||||
}
|
||||
|
||||
// GoString returns c as a Go source identifier.
|
||||
func (c Cardinality) GoString() string {
|
||||
switch c {
|
||||
case Optional:
|
||||
return "Optional"
|
||||
case Required:
|
||||
return "Required"
|
||||
case Repeated:
|
||||
return "Repeated"
|
||||
default:
|
||||
return "<unknown>"
|
||||
}
|
||||
}
|
||||
|
||||
// Kind indicates the basic proto kind of a field.
|
||||
type Kind kind
|
||||
|
||||
@ -151,6 +181,8 @@ func (k Kind) IsValid() bool {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// String returns k as a proto source identifier.
|
||||
func (k Kind) String() string {
|
||||
switch k {
|
||||
case BoolKind:
|
||||
@ -194,6 +226,50 @@ func (k Kind) String() string {
|
||||
}
|
||||
}
|
||||
|
||||
// GoString returns k as a Go source identifier.
|
||||
func (k Kind) GoString() string {
|
||||
switch k {
|
||||
case BoolKind:
|
||||
return "BoolKind"
|
||||
case EnumKind:
|
||||
return "EnumKind"
|
||||
case Int32Kind:
|
||||
return "Int32Kind"
|
||||
case Sint32Kind:
|
||||
return "Sint32Kind"
|
||||
case Uint32Kind:
|
||||
return "Uint32Kind"
|
||||
case Int64Kind:
|
||||
return "Int64Kind"
|
||||
case Sint64Kind:
|
||||
return "Sint64Kind"
|
||||
case Uint64Kind:
|
||||
return "Uint64Kind"
|
||||
case Sfixed32Kind:
|
||||
return "Sfixed32Kind"
|
||||
case Fixed32Kind:
|
||||
return "Fixed32Kind"
|
||||
case FloatKind:
|
||||
return "FloatKind"
|
||||
case Sfixed64Kind:
|
||||
return "Sfixed64Kind"
|
||||
case Fixed64Kind:
|
||||
return "Fixed64Kind"
|
||||
case DoubleKind:
|
||||
return "DoubleKind"
|
||||
case StringKind:
|
||||
return "StringKind"
|
||||
case BytesKind:
|
||||
return "BytesKind"
|
||||
case MessageKind:
|
||||
return "MessageKind"
|
||||
case GroupKind:
|
||||
return "GroupKind"
|
||||
default:
|
||||
return "<unknown>"
|
||||
}
|
||||
}
|
||||
|
||||
// FieldNumber is the field number in a message.
|
||||
type FieldNumber = wire.Number
|
||||
|
||||
|
||||
@ -182,23 +182,9 @@ type FileImports interface {
|
||||
|
||||
// FileImport is the declaration for a proto file import.
|
||||
type FileImport struct {
|
||||
// TODO: For FileDescriptor to be resolved, we must assume that there is
|
||||
// a way to obtain the FileDescriptor for some dependency.
|
||||
// How does this work for old dependencies that have not been regenerated
|
||||
// and lack a FileDescriptor in a variable we can reference?
|
||||
//
|
||||
// A similar problem exists for FieldDescriptor.MessageDescriptor and
|
||||
// FieldDescriptor.EnumDescriptor where a reference to external types
|
||||
// is only possible if we assume that the dependency has
|
||||
// reflection support available.
|
||||
//
|
||||
// Is it reasonable to assume that your dependencies have to be regenerated
|
||||
// to have proto reflection support before you can depend on them?
|
||||
//
|
||||
// The decision here also affects Descriptor.IsPlaceholder
|
||||
|
||||
// FileDescriptor is the file type for the given import.
|
||||
// It is a placeholder type if IsWeak is set.
|
||||
// It is a placeholder descriptor if IsWeak is set or if a dependency has
|
||||
// not been regenerated to implement the new reflection APIs.
|
||||
FileDescriptor
|
||||
|
||||
// IsPublic reports whether this is a public import, which causes this file
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user