desc_resolve.go raw
1 // 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
5 package protodesc
6
7 import (
8 "google.golang.org/protobuf/internal/encoding/defval"
9 "google.golang.org/protobuf/internal/errors"
10 "google.golang.org/protobuf/internal/filedesc"
11 "google.golang.org/protobuf/reflect/protoreflect"
12 "google.golang.org/protobuf/reflect/protoregistry"
13
14 "google.golang.org/protobuf/types/descriptorpb"
15 )
16
17 // resolver is a wrapper around a local registry of declarations within the file
18 // and the remote resolver. The remote resolver is restricted to only return
19 // descriptors that have been imported.
20 type resolver struct {
21 local descsByName
22 remote Resolver
23 imports importSet
24
25 allowUnresolvable bool
26 }
27
28 func (r *resolver) resolveMessageDependencies(ms []filedesc.Message, mds []*descriptorpb.DescriptorProto) (err error) {
29 for i, md := range mds {
30 m := &ms[i]
31 for j, fd := range md.GetField() {
32 f := &m.L2.Fields.List[j]
33 if f.L1.Cardinality == protoreflect.Required {
34 m.L2.RequiredNumbers.List = append(m.L2.RequiredNumbers.List, f.L1.Number)
35 }
36 if fd.OneofIndex != nil {
37 k := int(fd.GetOneofIndex())
38 if !(0 <= k && k < len(md.GetOneofDecl())) {
39 return errors.New("message field %q has an invalid oneof index: %d", f.FullName(), k)
40 }
41 o := &m.L2.Oneofs.List[k]
42 f.L1.ContainingOneof = o
43 o.L1.Fields.List = append(o.L1.Fields.List, f)
44 }
45
46 if f.L1.Kind, f.L1.Enum, f.L1.Message, err = r.findTarget(f.Kind(), f.Parent().FullName(), partialName(fd.GetTypeName())); err != nil {
47 return errors.New("message field %q cannot resolve type: %v", f.FullName(), err)
48 }
49 if f.L1.Kind == protoreflect.GroupKind && (f.IsMap() || f.IsMapEntry()) {
50 // A map field might inherit delimited encoding from a file-wide default feature.
51 // But maps never actually use delimited encoding. (At least for now...)
52 f.L1.Kind = protoreflect.MessageKind
53 }
54 if fd.DefaultValue != nil {
55 v, ev, err := unmarshalDefault(fd.GetDefaultValue(), f, r.allowUnresolvable)
56 if err != nil {
57 return errors.New("message field %q has invalid default: %v", f.FullName(), err)
58 }
59 f.L1.Default = filedesc.DefaultValue(v, ev)
60 }
61 }
62
63 if err := r.resolveMessageDependencies(m.L1.Messages.List, md.GetNestedType()); err != nil {
64 return err
65 }
66 if err := r.resolveExtensionDependencies(m.L1.Extensions.List, md.GetExtension()); err != nil {
67 return err
68 }
69 }
70 return nil
71 }
72
73 func (r *resolver) resolveExtensionDependencies(xs []filedesc.Extension, xds []*descriptorpb.FieldDescriptorProto) (err error) {
74 for i, xd := range xds {
75 x := &xs[i]
76 if x.L1.Extendee, err = r.findMessageDescriptor(x.Parent().FullName(), partialName(xd.GetExtendee())); err != nil {
77 return errors.New("extension field %q cannot resolve extendee: %v", x.FullName(), err)
78 }
79 if x.L1.Kind, x.L2.Enum, x.L2.Message, err = r.findTarget(x.Kind(), x.Parent().FullName(), partialName(xd.GetTypeName())); err != nil {
80 return errors.New("extension field %q cannot resolve type: %v", x.FullName(), err)
81 }
82 if xd.DefaultValue != nil {
83 v, ev, err := unmarshalDefault(xd.GetDefaultValue(), x, r.allowUnresolvable)
84 if err != nil {
85 return errors.New("extension field %q has invalid default: %v", x.FullName(), err)
86 }
87 x.L2.Default = filedesc.DefaultValue(v, ev)
88 }
89 }
90 return nil
91 }
92
93 func (r *resolver) resolveServiceDependencies(ss []filedesc.Service, sds []*descriptorpb.ServiceDescriptorProto) (err error) {
94 for i, sd := range sds {
95 s := &ss[i]
96 for j, md := range sd.GetMethod() {
97 m := &s.L2.Methods.List[j]
98 m.L1.Input, err = r.findMessageDescriptor(m.Parent().FullName(), partialName(md.GetInputType()))
99 if err != nil {
100 return errors.New("service method %q cannot resolve input: %v", m.FullName(), err)
101 }
102 m.L1.Output, err = r.findMessageDescriptor(s.FullName(), partialName(md.GetOutputType()))
103 if err != nil {
104 return errors.New("service method %q cannot resolve output: %v", m.FullName(), err)
105 }
106 }
107 }
108 return nil
109 }
110
111 // findTarget finds an enum or message descriptor if k is an enum, message,
112 // group, or unknown. If unknown, and the name could be resolved, the kind
113 // returned kind is set based on the type of the resolved descriptor.
114 func (r *resolver) findTarget(k protoreflect.Kind, scope protoreflect.FullName, ref partialName) (protoreflect.Kind, protoreflect.EnumDescriptor, protoreflect.MessageDescriptor, error) {
115 switch k {
116 case protoreflect.EnumKind:
117 ed, err := r.findEnumDescriptor(scope, ref)
118 if err != nil {
119 return 0, nil, nil, err
120 }
121 return k, ed, nil, nil
122 case protoreflect.MessageKind, protoreflect.GroupKind:
123 md, err := r.findMessageDescriptor(scope, ref)
124 if err != nil {
125 return 0, nil, nil, err
126 }
127 return k, nil, md, nil
128 case 0:
129 // Handle unspecified kinds (possible with parsers that operate
130 // on a per-file basis without knowledge of dependencies).
131 d, err := r.findDescriptor(scope, ref)
132 if err == protoregistry.NotFound && r.allowUnresolvable {
133 return k, filedesc.PlaceholderEnum(ref.FullName()), filedesc.PlaceholderMessage(ref.FullName()), nil
134 } else if err == protoregistry.NotFound {
135 return 0, nil, nil, errors.New("%q not found", ref.FullName())
136 } else if err != nil {
137 return 0, nil, nil, err
138 }
139 switch d := d.(type) {
140 case protoreflect.EnumDescriptor:
141 return protoreflect.EnumKind, d, nil, nil
142 case protoreflect.MessageDescriptor:
143 return protoreflect.MessageKind, nil, d, nil
144 default:
145 return 0, nil, nil, errors.New("unknown kind")
146 }
147 default:
148 if ref != "" {
149 return 0, nil, nil, errors.New("target name cannot be specified for %v", k)
150 }
151 if !k.IsValid() {
152 return 0, nil, nil, errors.New("invalid kind: %d", k)
153 }
154 return k, nil, nil, nil
155 }
156 }
157
158 // findDescriptor finds the descriptor by name,
159 // which may be a relative name within some scope.
160 //
161 // Suppose the scope was "fizz.buzz" and the reference was "Foo.Bar",
162 // then the following full names are searched:
163 // - fizz.buzz.Foo.Bar
164 // - fizz.Foo.Bar
165 // - Foo.Bar
166 func (r *resolver) findDescriptor(scope protoreflect.FullName, ref partialName) (protoreflect.Descriptor, error) {
167 if !ref.IsValid() {
168 return nil, errors.New("invalid name reference: %q", ref)
169 }
170 if ref.IsFull() {
171 scope, ref = "", ref[1:]
172 }
173 var foundButNotImported protoreflect.Descriptor
174 for {
175 // Derive the full name to search.
176 s := protoreflect.FullName(ref)
177 if scope != "" {
178 s = scope + "." + s
179 }
180
181 // Check the current file for the descriptor.
182 if d, ok := r.local[s]; ok {
183 return d, nil
184 }
185
186 // Check the remote registry for the descriptor.
187 d, err := r.remote.FindDescriptorByName(s)
188 if err == nil {
189 // Only allow descriptors covered by one of the imports.
190 if r.imports[d.ParentFile().Path()] {
191 return d, nil
192 }
193 foundButNotImported = d
194 } else if err != protoregistry.NotFound {
195 return nil, errors.Wrap(err, "%q", s)
196 }
197
198 // Continue on at a higher level of scoping.
199 if scope == "" {
200 if d := foundButNotImported; d != nil {
201 return nil, errors.New("resolved %q, but %q is not imported", d.FullName(), d.ParentFile().Path())
202 }
203 return nil, protoregistry.NotFound
204 }
205 scope = scope.Parent()
206 }
207 }
208
209 func (r *resolver) findEnumDescriptor(scope protoreflect.FullName, ref partialName) (protoreflect.EnumDescriptor, error) {
210 d, err := r.findDescriptor(scope, ref)
211 if err == protoregistry.NotFound && r.allowUnresolvable {
212 return filedesc.PlaceholderEnum(ref.FullName()), nil
213 } else if err == protoregistry.NotFound {
214 return nil, errors.New("%q not found", ref.FullName())
215 } else if err != nil {
216 return nil, err
217 }
218 ed, ok := d.(protoreflect.EnumDescriptor)
219 if !ok {
220 return nil, errors.New("resolved %q, but it is not an enum", d.FullName())
221 }
222 return ed, nil
223 }
224
225 func (r *resolver) findMessageDescriptor(scope protoreflect.FullName, ref partialName) (protoreflect.MessageDescriptor, error) {
226 d, err := r.findDescriptor(scope, ref)
227 if err == protoregistry.NotFound && r.allowUnresolvable {
228 return filedesc.PlaceholderMessage(ref.FullName()), nil
229 } else if err == protoregistry.NotFound {
230 return nil, errors.New("%q not found", ref.FullName())
231 } else if err != nil {
232 return nil, err
233 }
234 md, ok := d.(protoreflect.MessageDescriptor)
235 if !ok {
236 return nil, errors.New("resolved %q, but it is not an message", d.FullName())
237 }
238 return md, nil
239 }
240
241 // partialName is the partial name. A leading dot means that the name is full,
242 // otherwise the name is relative to some current scope.
243 // See google.protobuf.FieldDescriptorProto.type_name.
244 type partialName string
245
246 func (s partialName) IsFull() bool {
247 return len(s) > 0 && s[0] == '.'
248 }
249
250 func (s partialName) IsValid() bool {
251 if s.IsFull() {
252 return protoreflect.FullName(s[1:]).IsValid()
253 }
254 return protoreflect.FullName(s).IsValid()
255 }
256
257 const unknownPrefix = "*."
258
259 // FullName converts the partial name to a full name on a best-effort basis.
260 // If relative, it creates an invalid full name, using a "*." prefix
261 // to indicate that the start of the full name is unknown.
262 func (s partialName) FullName() protoreflect.FullName {
263 if s.IsFull() {
264 return protoreflect.FullName(s[1:])
265 }
266 return protoreflect.FullName(unknownPrefix + s)
267 }
268
269 func unmarshalDefault(s string, fd protoreflect.FieldDescriptor, allowUnresolvable bool) (protoreflect.Value, protoreflect.EnumValueDescriptor, error) {
270 var evs protoreflect.EnumValueDescriptors
271 if fd.Enum() != nil {
272 evs = fd.Enum().Values()
273 }
274 v, ev, err := defval.Unmarshal(s, fd.Kind(), evs, defval.Descriptor)
275 if err != nil && allowUnresolvable && evs != nil && protoreflect.Name(s).IsValid() {
276 v = protoreflect.ValueOfEnum(0)
277 if evs.Len() > 0 {
278 v = protoreflect.ValueOfEnum(evs.Get(0).Number())
279 }
280 ev = filedesc.PlaceholderEnumValue(fd.Enum().FullName().Parent().Append(protoreflect.Name(s)))
281 } else if err != nil {
282 return v, ev, err
283 }
284 if !fd.HasPresence() {
285 return v, ev, errors.New("cannot be specified with implicit field presence")
286 }
287 if fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind || fd.Cardinality() == protoreflect.Repeated {
288 return v, ev, errors.New("cannot be specified on composite types")
289 }
290 return v, ev, nil
291 }
292