blob: a7c5ceffc9b15dab9b1e8270ccef4ae36f2f9904 [file] [log] [blame]
amit.ghosh258d14c2020-10-02 15:13:38 +02001// Copyright 2019 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package protodesc
6
7import (
8 "fmt"
9 "strings"
10
11 "google.golang.org/protobuf/internal/encoding/defval"
David K. Bainbridgec415efe2021-08-19 13:05:21 +000012 "google.golang.org/protobuf/internal/strs"
amit.ghosh258d14c2020-10-02 15:13:38 +020013 "google.golang.org/protobuf/proto"
14 "google.golang.org/protobuf/reflect/protoreflect"
15
16 "google.golang.org/protobuf/types/descriptorpb"
17)
18
19// ToFileDescriptorProto copies a protoreflect.FileDescriptor into a
20// google.protobuf.FileDescriptorProto message.
21func ToFileDescriptorProto(file protoreflect.FileDescriptor) *descriptorpb.FileDescriptorProto {
22 p := &descriptorpb.FileDescriptorProto{
23 Name: proto.String(file.Path()),
amit.ghosh258d14c2020-10-02 15:13:38 +020024 Options: proto.Clone(file.Options()).(*descriptorpb.FileOptions),
25 }
David K. Bainbridgec415efe2021-08-19 13:05:21 +000026 if file.Package() != "" {
27 p.Package = proto.String(string(file.Package()))
28 }
amit.ghosh258d14c2020-10-02 15:13:38 +020029 for i, imports := 0, file.Imports(); i < imports.Len(); i++ {
30 imp := imports.Get(i)
31 p.Dependency = append(p.Dependency, imp.Path())
32 if imp.IsPublic {
33 p.PublicDependency = append(p.PublicDependency, int32(i))
34 }
35 if imp.IsWeak {
36 p.WeakDependency = append(p.WeakDependency, int32(i))
37 }
38 }
39 for i, locs := 0, file.SourceLocations(); i < locs.Len(); i++ {
40 loc := locs.Get(i)
41 l := &descriptorpb.SourceCodeInfo_Location{}
42 l.Path = append(l.Path, loc.Path...)
43 if loc.StartLine == loc.EndLine {
44 l.Span = []int32{int32(loc.StartLine), int32(loc.StartColumn), int32(loc.EndColumn)}
45 } else {
46 l.Span = []int32{int32(loc.StartLine), int32(loc.StartColumn), int32(loc.EndLine), int32(loc.EndColumn)}
47 }
48 l.LeadingDetachedComments = append([]string(nil), loc.LeadingDetachedComments...)
49 if loc.LeadingComments != "" {
50 l.LeadingComments = proto.String(loc.LeadingComments)
51 }
52 if loc.TrailingComments != "" {
53 l.TrailingComments = proto.String(loc.TrailingComments)
54 }
55 if p.SourceCodeInfo == nil {
56 p.SourceCodeInfo = &descriptorpb.SourceCodeInfo{}
57 }
58 p.SourceCodeInfo.Location = append(p.SourceCodeInfo.Location, l)
59
60 }
61 for i, messages := 0, file.Messages(); i < messages.Len(); i++ {
62 p.MessageType = append(p.MessageType, ToDescriptorProto(messages.Get(i)))
63 }
64 for i, enums := 0, file.Enums(); i < enums.Len(); i++ {
65 p.EnumType = append(p.EnumType, ToEnumDescriptorProto(enums.Get(i)))
66 }
67 for i, services := 0, file.Services(); i < services.Len(); i++ {
68 p.Service = append(p.Service, ToServiceDescriptorProto(services.Get(i)))
69 }
70 for i, exts := 0, file.Extensions(); i < exts.Len(); i++ {
71 p.Extension = append(p.Extension, ToFieldDescriptorProto(exts.Get(i)))
72 }
73 if syntax := file.Syntax(); syntax != protoreflect.Proto2 {
74 p.Syntax = proto.String(file.Syntax().String())
75 }
76 return p
77}
78
79// ToDescriptorProto copies a protoreflect.MessageDescriptor into a
80// google.protobuf.DescriptorProto message.
81func ToDescriptorProto(message protoreflect.MessageDescriptor) *descriptorpb.DescriptorProto {
82 p := &descriptorpb.DescriptorProto{
83 Name: proto.String(string(message.Name())),
84 Options: proto.Clone(message.Options()).(*descriptorpb.MessageOptions),
85 }
86 for i, fields := 0, message.Fields(); i < fields.Len(); i++ {
87 p.Field = append(p.Field, ToFieldDescriptorProto(fields.Get(i)))
88 }
89 for i, exts := 0, message.Extensions(); i < exts.Len(); i++ {
90 p.Extension = append(p.Extension, ToFieldDescriptorProto(exts.Get(i)))
91 }
92 for i, messages := 0, message.Messages(); i < messages.Len(); i++ {
93 p.NestedType = append(p.NestedType, ToDescriptorProto(messages.Get(i)))
94 }
95 for i, enums := 0, message.Enums(); i < enums.Len(); i++ {
96 p.EnumType = append(p.EnumType, ToEnumDescriptorProto(enums.Get(i)))
97 }
98 for i, xranges := 0, message.ExtensionRanges(); i < xranges.Len(); i++ {
99 xrange := xranges.Get(i)
100 p.ExtensionRange = append(p.ExtensionRange, &descriptorpb.DescriptorProto_ExtensionRange{
101 Start: proto.Int32(int32(xrange[0])),
102 End: proto.Int32(int32(xrange[1])),
103 Options: proto.Clone(message.ExtensionRangeOptions(i)).(*descriptorpb.ExtensionRangeOptions),
104 })
105 }
106 for i, oneofs := 0, message.Oneofs(); i < oneofs.Len(); i++ {
107 p.OneofDecl = append(p.OneofDecl, ToOneofDescriptorProto(oneofs.Get(i)))
108 }
109 for i, ranges := 0, message.ReservedRanges(); i < ranges.Len(); i++ {
110 rrange := ranges.Get(i)
111 p.ReservedRange = append(p.ReservedRange, &descriptorpb.DescriptorProto_ReservedRange{
112 Start: proto.Int32(int32(rrange[0])),
113 End: proto.Int32(int32(rrange[1])),
114 })
115 }
116 for i, names := 0, message.ReservedNames(); i < names.Len(); i++ {
117 p.ReservedName = append(p.ReservedName, string(names.Get(i)))
118 }
119 return p
120}
121
122// ToFieldDescriptorProto copies a protoreflect.FieldDescriptor into a
123// google.protobuf.FieldDescriptorProto message.
124func ToFieldDescriptorProto(field protoreflect.FieldDescriptor) *descriptorpb.FieldDescriptorProto {
125 p := &descriptorpb.FieldDescriptorProto{
126 Name: proto.String(string(field.Name())),
127 Number: proto.Int32(int32(field.Number())),
128 Label: descriptorpb.FieldDescriptorProto_Label(field.Cardinality()).Enum(),
129 Options: proto.Clone(field.Options()).(*descriptorpb.FieldOptions),
130 }
131 if field.IsExtension() {
132 p.Extendee = fullNameOf(field.ContainingMessage())
133 }
134 if field.Kind().IsValid() {
135 p.Type = descriptorpb.FieldDescriptorProto_Type(field.Kind()).Enum()
136 }
137 if field.Enum() != nil {
138 p.TypeName = fullNameOf(field.Enum())
139 }
140 if field.Message() != nil {
141 p.TypeName = fullNameOf(field.Message())
142 }
143 if field.HasJSONName() {
David K. Bainbridgec415efe2021-08-19 13:05:21 +0000144 // A bug in older versions of protoc would always populate the
145 // "json_name" option for extensions when it is meaningless.
146 // When it did so, it would always use the camel-cased field name.
147 if field.IsExtension() {
148 p.JsonName = proto.String(strs.JSONCamelCase(string(field.Name())))
149 } else {
150 p.JsonName = proto.String(field.JSONName())
151 }
amit.ghosh258d14c2020-10-02 15:13:38 +0200152 }
153 if field.Syntax() == protoreflect.Proto3 && field.HasOptionalKeyword() {
154 p.Proto3Optional = proto.Bool(true)
155 }
156 if field.HasDefault() {
157 def, err := defval.Marshal(field.Default(), field.DefaultEnumValue(), field.Kind(), defval.Descriptor)
158 if err != nil && field.DefaultEnumValue() != nil {
159 def = string(field.DefaultEnumValue().Name()) // occurs for unresolved enum values
160 } else if err != nil {
161 panic(fmt.Sprintf("%v: %v", field.FullName(), err))
162 }
163 p.DefaultValue = proto.String(def)
164 }
165 if oneof := field.ContainingOneof(); oneof != nil {
166 p.OneofIndex = proto.Int32(int32(oneof.Index()))
167 }
168 return p
169}
170
171// ToOneofDescriptorProto copies a protoreflect.OneofDescriptor into a
172// google.protobuf.OneofDescriptorProto message.
173func ToOneofDescriptorProto(oneof protoreflect.OneofDescriptor) *descriptorpb.OneofDescriptorProto {
174 return &descriptorpb.OneofDescriptorProto{
175 Name: proto.String(string(oneof.Name())),
176 Options: proto.Clone(oneof.Options()).(*descriptorpb.OneofOptions),
177 }
178}
179
180// ToEnumDescriptorProto copies a protoreflect.EnumDescriptor into a
181// google.protobuf.EnumDescriptorProto message.
182func ToEnumDescriptorProto(enum protoreflect.EnumDescriptor) *descriptorpb.EnumDescriptorProto {
183 p := &descriptorpb.EnumDescriptorProto{
184 Name: proto.String(string(enum.Name())),
185 Options: proto.Clone(enum.Options()).(*descriptorpb.EnumOptions),
186 }
187 for i, values := 0, enum.Values(); i < values.Len(); i++ {
188 p.Value = append(p.Value, ToEnumValueDescriptorProto(values.Get(i)))
189 }
190 for i, ranges := 0, enum.ReservedRanges(); i < ranges.Len(); i++ {
191 rrange := ranges.Get(i)
192 p.ReservedRange = append(p.ReservedRange, &descriptorpb.EnumDescriptorProto_EnumReservedRange{
193 Start: proto.Int32(int32(rrange[0])),
194 End: proto.Int32(int32(rrange[1])),
195 })
196 }
197 for i, names := 0, enum.ReservedNames(); i < names.Len(); i++ {
198 p.ReservedName = append(p.ReservedName, string(names.Get(i)))
199 }
200 return p
201}
202
203// ToEnumValueDescriptorProto copies a protoreflect.EnumValueDescriptor into a
204// google.protobuf.EnumValueDescriptorProto message.
205func ToEnumValueDescriptorProto(value protoreflect.EnumValueDescriptor) *descriptorpb.EnumValueDescriptorProto {
206 return &descriptorpb.EnumValueDescriptorProto{
207 Name: proto.String(string(value.Name())),
208 Number: proto.Int32(int32(value.Number())),
209 Options: proto.Clone(value.Options()).(*descriptorpb.EnumValueOptions),
210 }
211}
212
213// ToServiceDescriptorProto copies a protoreflect.ServiceDescriptor into a
214// google.protobuf.ServiceDescriptorProto message.
215func ToServiceDescriptorProto(service protoreflect.ServiceDescriptor) *descriptorpb.ServiceDescriptorProto {
216 p := &descriptorpb.ServiceDescriptorProto{
217 Name: proto.String(string(service.Name())),
218 Options: proto.Clone(service.Options()).(*descriptorpb.ServiceOptions),
219 }
220 for i, methods := 0, service.Methods(); i < methods.Len(); i++ {
221 p.Method = append(p.Method, ToMethodDescriptorProto(methods.Get(i)))
222 }
223 return p
224}
225
226// ToMethodDescriptorProto copies a protoreflect.MethodDescriptor into a
227// google.protobuf.MethodDescriptorProto message.
228func ToMethodDescriptorProto(method protoreflect.MethodDescriptor) *descriptorpb.MethodDescriptorProto {
229 p := &descriptorpb.MethodDescriptorProto{
230 Name: proto.String(string(method.Name())),
231 InputType: fullNameOf(method.Input()),
232 OutputType: fullNameOf(method.Output()),
233 Options: proto.Clone(method.Options()).(*descriptorpb.MethodOptions),
234 }
235 if method.IsStreamingClient() {
236 p.ClientStreaming = proto.Bool(true)
237 }
238 if method.IsStreamingServer() {
239 p.ServerStreaming = proto.Bool(true)
240 }
241 return p
242}
243
244func fullNameOf(d protoreflect.Descriptor) *string {
245 if d == nil {
246 return nil
247 }
248 if strings.HasPrefix(string(d.FullName()), unknownPrefix) {
249 return proto.String(string(d.FullName()[len(unknownPrefix):]))
250 }
251 return proto.String("." + string(d.FullName()))
252}