podman

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 filedesc
6

7
import (
8
	"reflect"
9
	"sync"
10

11
	"google.golang.org/protobuf/encoding/protowire"
12
	"google.golang.org/protobuf/internal/descopts"
13
	"google.golang.org/protobuf/internal/genid"
14
	"google.golang.org/protobuf/internal/strs"
15
	"google.golang.org/protobuf/proto"
16
	"google.golang.org/protobuf/reflect/protoreflect"
17
)
18

19
func (fd *File) lazyRawInit() {
20
	fd.unmarshalFull(fd.builder.RawDescriptor)
21
	fd.resolveMessages()
22
	fd.resolveExtensions()
23
	fd.resolveServices()
24
}
25

26
func (file *File) resolveMessages() {
27
	var depIdx int32
28
	for i := range file.allMessages {
29
		md := &file.allMessages[i]
30

31
		// Resolve message field dependencies.
32
		for j := range md.L2.Fields.List {
33
			fd := &md.L2.Fields.List[j]
34

35
			// Weak fields are resolved upon actual use.
36
			if fd.L1.IsWeak {
37
				continue
38
			}
39

40
			// Resolve message field dependency.
41
			switch fd.L1.Kind {
42
			case protoreflect.EnumKind:
43
				fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)
44
				depIdx++
45
			case protoreflect.MessageKind, protoreflect.GroupKind:
46
				fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)
47
				depIdx++
48
			}
49

50
			// Default is resolved here since it depends on Enum being resolved.
51
			if v := fd.L1.Default.val; v.IsValid() {
52
				fd.L1.Default = unmarshalDefault(v.Bytes(), fd.L1.Kind, file, fd.L1.Enum)
53
			}
54
		}
55
	}
56
}
57

58
func (file *File) resolveExtensions() {
59
	var depIdx int32
60
	for i := range file.allExtensions {
61
		xd := &file.allExtensions[i]
62

63
		// Resolve extension field dependency.
64
		switch xd.L1.Kind {
65
		case protoreflect.EnumKind:
66
			xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)
67
			depIdx++
68
		case protoreflect.MessageKind, protoreflect.GroupKind:
69
			xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)
70
			depIdx++
71
		}
72

73
		// Default is resolved here since it depends on Enum being resolved.
74
		if v := xd.L2.Default.val; v.IsValid() {
75
			xd.L2.Default = unmarshalDefault(v.Bytes(), xd.L1.Kind, file, xd.L2.Enum)
76
		}
77
	}
78
}
79

80
func (file *File) resolveServices() {
81
	var depIdx int32
82
	for i := range file.allServices {
83
		sd := &file.allServices[i]
84

85
		// Resolve method dependencies.
86
		for j := range sd.L2.Methods.List {
87
			md := &sd.L2.Methods.List[j]
88
			md.L1.Input = file.resolveMessageDependency(md.L1.Input, listMethInDeps, depIdx)
89
			md.L1.Output = file.resolveMessageDependency(md.L1.Output, listMethOutDeps, depIdx)
90
			depIdx++
91
		}
92
	}
93
}
94

95
func (file *File) resolveEnumDependency(ed protoreflect.EnumDescriptor, i, j int32) protoreflect.EnumDescriptor {
96
	r := file.builder.FileRegistry
97
	if r, ok := r.(resolverByIndex); ok {
98
		if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {
99
			return ed2
100
		}
101
	}
102
	for i := range file.allEnums {
103
		if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() {
104
			return ed2
105
		}
106
	}
107
	if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {
108
		return d.(protoreflect.EnumDescriptor)
109
	}
110
	return ed
111
}
112

113
func (file *File) resolveMessageDependency(md protoreflect.MessageDescriptor, i, j int32) protoreflect.MessageDescriptor {
114
	r := file.builder.FileRegistry
115
	if r, ok := r.(resolverByIndex); ok {
116
		if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {
117
			return md2
118
		}
119
	}
120
	for i := range file.allMessages {
121
		if md2 := &file.allMessages[i]; md2.L0.FullName == md.FullName() {
122
			return md2
123
		}
124
	}
125
	if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {
126
		return d.(protoreflect.MessageDescriptor)
127
	}
128
	return md
129
}
130

131
func (fd *File) unmarshalFull(b []byte) {
132
	sb := getBuilder()
133
	defer putBuilder(sb)
134

135
	var enumIdx, messageIdx, extensionIdx, serviceIdx int
136
	var rawOptions []byte
137
	fd.L2 = new(FileL2)
138
	for len(b) > 0 {
139
		num, typ, n := protowire.ConsumeTag(b)
140
		b = b[n:]
141
		switch typ {
142
		case protowire.VarintType:
143
			v, m := protowire.ConsumeVarint(b)
144
			b = b[m:]
145
			switch num {
146
			case genid.FileDescriptorProto_PublicDependency_field_number:
147
				fd.L2.Imports[v].IsPublic = true
148
			case genid.FileDescriptorProto_WeakDependency_field_number:
149
				fd.L2.Imports[v].IsWeak = true
150
			}
151
		case protowire.BytesType:
152
			v, m := protowire.ConsumeBytes(b)
153
			b = b[m:]
154
			switch num {
155
			case genid.FileDescriptorProto_Dependency_field_number:
156
				path := sb.MakeString(v)
157
				imp, _ := fd.builder.FileRegistry.FindFileByPath(path)
158
				if imp == nil {
159
					imp = PlaceholderFile(path)
160
				}
161
				fd.L2.Imports = append(fd.L2.Imports, protoreflect.FileImport{FileDescriptor: imp})
162
			case genid.FileDescriptorProto_EnumType_field_number:
163
				fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
164
				enumIdx++
165
			case genid.FileDescriptorProto_MessageType_field_number:
166
				fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
167
				messageIdx++
168
			case genid.FileDescriptorProto_Extension_field_number:
169
				fd.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
170
				extensionIdx++
171
			case genid.FileDescriptorProto_Service_field_number:
172
				fd.L1.Services.List[serviceIdx].unmarshalFull(v, sb)
173
				serviceIdx++
174
			case genid.FileDescriptorProto_Options_field_number:
175
				rawOptions = appendOptions(rawOptions, v)
176
			}
177
		default:
178
			m := protowire.ConsumeFieldValue(num, typ, b)
179
			b = b[m:]
180
		}
181
	}
182
	fd.L2.Options = fd.builder.optionsUnmarshaler(&descopts.File, rawOptions)
183
}
184

185
func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
186
	var rawValues [][]byte
187
	var rawOptions []byte
188
	if !ed.L1.eagerValues {
189
		ed.L2 = new(EnumL2)
190
	}
191
	for len(b) > 0 {
192
		num, typ, n := protowire.ConsumeTag(b)
193
		b = b[n:]
194
		switch typ {
195
		case protowire.BytesType:
196
			v, m := protowire.ConsumeBytes(b)
197
			b = b[m:]
198
			switch num {
199
			case genid.EnumDescriptorProto_Value_field_number:
200
				rawValues = append(rawValues, v)
201
			case genid.EnumDescriptorProto_ReservedName_field_number:
202
				ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
203
			case genid.EnumDescriptorProto_ReservedRange_field_number:
204
				ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))
205
			case genid.EnumDescriptorProto_Options_field_number:
206
				rawOptions = appendOptions(rawOptions, v)
207
			}
208
		default:
209
			m := protowire.ConsumeFieldValue(num, typ, b)
210
			b = b[m:]
211
		}
212
	}
213
	if !ed.L1.eagerValues && len(rawValues) > 0 {
214
		ed.L2.Values.List = make([]EnumValue, len(rawValues))
215
		for i, b := range rawValues {
216
			ed.L2.Values.List[i].unmarshalFull(b, sb, ed.L0.ParentFile, ed, i)
217
		}
218
	}
219
	ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)
220
}
221

222
func unmarshalEnumReservedRange(b []byte) (r [2]protoreflect.EnumNumber) {
223
	for len(b) > 0 {
224
		num, typ, n := protowire.ConsumeTag(b)
225
		b = b[n:]
226
		switch typ {
227
		case protowire.VarintType:
228
			v, m := protowire.ConsumeVarint(b)
229
			b = b[m:]
230
			switch num {
231
			case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number:
232
				r[0] = protoreflect.EnumNumber(v)
233
			case genid.EnumDescriptorProto_EnumReservedRange_End_field_number:
234
				r[1] = protoreflect.EnumNumber(v)
235
			}
236
		default:
237
			m := protowire.ConsumeFieldValue(num, typ, b)
238
			b = b[m:]
239
		}
240
	}
241
	return r
242
}
243

244
func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
245
	vd.L0.ParentFile = pf
246
	vd.L0.Parent = pd
247
	vd.L0.Index = i
248

249
	var rawOptions []byte
250
	for len(b) > 0 {
251
		num, typ, n := protowire.ConsumeTag(b)
252
		b = b[n:]
253
		switch typ {
254
		case protowire.VarintType:
255
			v, m := protowire.ConsumeVarint(b)
256
			b = b[m:]
257
			switch num {
258
			case genid.EnumValueDescriptorProto_Number_field_number:
259
				vd.L1.Number = protoreflect.EnumNumber(v)
260
			}
261
		case protowire.BytesType:
262
			v, m := protowire.ConsumeBytes(b)
263
			b = b[m:]
264
			switch num {
265
			case genid.EnumValueDescriptorProto_Name_field_number:
266
				// NOTE: Enum values are in the same scope as the enum parent.
267
				vd.L0.FullName = appendFullName(sb, pd.Parent().FullName(), v)
268
			case genid.EnumValueDescriptorProto_Options_field_number:
269
				rawOptions = appendOptions(rawOptions, v)
270
			}
271
		default:
272
			m := protowire.ConsumeFieldValue(num, typ, b)
273
			b = b[m:]
274
		}
275
	}
276
	vd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.EnumValue, rawOptions)
277
}
278

279
func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
280
	var rawFields, rawOneofs [][]byte
281
	var enumIdx, messageIdx, extensionIdx int
282
	var rawOptions []byte
283
	md.L2 = new(MessageL2)
284
	for len(b) > 0 {
285
		num, typ, n := protowire.ConsumeTag(b)
286
		b = b[n:]
287
		switch typ {
288
		case protowire.BytesType:
289
			v, m := protowire.ConsumeBytes(b)
290
			b = b[m:]
291
			switch num {
292
			case genid.DescriptorProto_Field_field_number:
293
				rawFields = append(rawFields, v)
294
			case genid.DescriptorProto_OneofDecl_field_number:
295
				rawOneofs = append(rawOneofs, v)
296
			case genid.DescriptorProto_ReservedName_field_number:
297
				md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
298
			case genid.DescriptorProto_ReservedRange_field_number:
299
				md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))
300
			case genid.DescriptorProto_ExtensionRange_field_number:
301
				r, rawOptions := unmarshalMessageExtensionRange(v)
302
				opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions)
303
				md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, r)
304
				md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, opts)
305
			case genid.DescriptorProto_EnumType_field_number:
306
				md.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
307
				enumIdx++
308
			case genid.DescriptorProto_NestedType_field_number:
309
				md.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
310
				messageIdx++
311
			case genid.DescriptorProto_Extension_field_number:
312
				md.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
313
				extensionIdx++
314
			case genid.DescriptorProto_Options_field_number:
315
				md.unmarshalOptions(v)
316
				rawOptions = appendOptions(rawOptions, v)
317
			}
318
		default:
319
			m := protowire.ConsumeFieldValue(num, typ, b)
320
			b = b[m:]
321
		}
322
	}
323
	if len(rawFields) > 0 || len(rawOneofs) > 0 {
324
		md.L2.Fields.List = make([]Field, len(rawFields))
325
		md.L2.Oneofs.List = make([]Oneof, len(rawOneofs))
326
		for i, b := range rawFields {
327
			fd := &md.L2.Fields.List[i]
328
			fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
329
			if fd.L1.Cardinality == protoreflect.Required {
330
				md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)
331
			}
332
		}
333
		for i, b := range rawOneofs {
334
			od := &md.L2.Oneofs.List[i]
335
			od.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
336
		}
337
	}
338
	md.L2.Options = md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Message, rawOptions)
339
}
340

341
func (md *Message) unmarshalOptions(b []byte) {
342
	for len(b) > 0 {
343
		num, typ, n := protowire.ConsumeTag(b)
344
		b = b[n:]
345
		switch typ {
346
		case protowire.VarintType:
347
			v, m := protowire.ConsumeVarint(b)
348
			b = b[m:]
349
			switch num {
350
			case genid.MessageOptions_MapEntry_field_number:
351
				md.L1.IsMapEntry = protowire.DecodeBool(v)
352
			case genid.MessageOptions_MessageSetWireFormat_field_number:
353
				md.L1.IsMessageSet = protowire.DecodeBool(v)
354
			}
355
		default:
356
			m := protowire.ConsumeFieldValue(num, typ, b)
357
			b = b[m:]
358
		}
359
	}
360
}
361

362
func unmarshalMessageReservedRange(b []byte) (r [2]protoreflect.FieldNumber) {
363
	for len(b) > 0 {
364
		num, typ, n := protowire.ConsumeTag(b)
365
		b = b[n:]
366
		switch typ {
367
		case protowire.VarintType:
368
			v, m := protowire.ConsumeVarint(b)
369
			b = b[m:]
370
			switch num {
371
			case genid.DescriptorProto_ReservedRange_Start_field_number:
372
				r[0] = protoreflect.FieldNumber(v)
373
			case genid.DescriptorProto_ReservedRange_End_field_number:
374
				r[1] = protoreflect.FieldNumber(v)
375
			}
376
		default:
377
			m := protowire.ConsumeFieldValue(num, typ, b)
378
			b = b[m:]
379
		}
380
	}
381
	return r
382
}
383

384
func unmarshalMessageExtensionRange(b []byte) (r [2]protoreflect.FieldNumber, rawOptions []byte) {
385
	for len(b) > 0 {
386
		num, typ, n := protowire.ConsumeTag(b)
387
		b = b[n:]
388
		switch typ {
389
		case protowire.VarintType:
390
			v, m := protowire.ConsumeVarint(b)
391
			b = b[m:]
392
			switch num {
393
			case genid.DescriptorProto_ExtensionRange_Start_field_number:
394
				r[0] = protoreflect.FieldNumber(v)
395
			case genid.DescriptorProto_ExtensionRange_End_field_number:
396
				r[1] = protoreflect.FieldNumber(v)
397
			}
398
		case protowire.BytesType:
399
			v, m := protowire.ConsumeBytes(b)
400
			b = b[m:]
401
			switch num {
402
			case genid.DescriptorProto_ExtensionRange_Options_field_number:
403
				rawOptions = appendOptions(rawOptions, v)
404
			}
405
		default:
406
			m := protowire.ConsumeFieldValue(num, typ, b)
407
			b = b[m:]
408
		}
409
	}
410
	return r, rawOptions
411
}
412

413
func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
414
	fd.L0.ParentFile = pf
415
	fd.L0.Parent = pd
416
	fd.L0.Index = i
417
	fd.L1.EditionFeatures = featuresFromParentDesc(fd.Parent())
418

419
	var rawTypeName []byte
420
	var rawOptions []byte
421
	for len(b) > 0 {
422
		num, typ, n := protowire.ConsumeTag(b)
423
		b = b[n:]
424
		switch typ {
425
		case protowire.VarintType:
426
			v, m := protowire.ConsumeVarint(b)
427
			b = b[m:]
428
			switch num {
429
			case genid.FieldDescriptorProto_Number_field_number:
430
				fd.L1.Number = protoreflect.FieldNumber(v)
431
			case genid.FieldDescriptorProto_Label_field_number:
432
				fd.L1.Cardinality = protoreflect.Cardinality(v)
433
			case genid.FieldDescriptorProto_Type_field_number:
434
				fd.L1.Kind = protoreflect.Kind(v)
435
			case genid.FieldDescriptorProto_OneofIndex_field_number:
436
				// In Message.unmarshalFull, we allocate slices for both
437
				// the field and oneof descriptors before unmarshaling either
438
				// of them. This ensures pointers to slice elements are stable.
439
				od := &pd.(*Message).L2.Oneofs.List[v]
440
				od.L1.Fields.List = append(od.L1.Fields.List, fd)
441
				if fd.L1.ContainingOneof != nil {
442
					panic("oneof type already set")
443
				}
444
				fd.L1.ContainingOneof = od
445
			case genid.FieldDescriptorProto_Proto3Optional_field_number:
446
				fd.L1.IsProto3Optional = protowire.DecodeBool(v)
447
			}
448
		case protowire.BytesType:
449
			v, m := protowire.ConsumeBytes(b)
450
			b = b[m:]
451
			switch num {
452
			case genid.FieldDescriptorProto_Name_field_number:
453
				fd.L0.FullName = appendFullName(sb, pd.FullName(), v)
454
			case genid.FieldDescriptorProto_JsonName_field_number:
455
				fd.L1.StringName.InitJSON(sb.MakeString(v))
456
			case genid.FieldDescriptorProto_DefaultValue_field_number:
457
				fd.L1.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
458
			case genid.FieldDescriptorProto_TypeName_field_number:
459
				rawTypeName = v
460
			case genid.FieldDescriptorProto_Options_field_number:
461
				fd.unmarshalOptions(v)
462
				rawOptions = appendOptions(rawOptions, v)
463
			}
464
		default:
465
			m := protowire.ConsumeFieldValue(num, typ, b)
466
			b = b[m:]
467
		}
468
	}
469
	if fd.Syntax() == protoreflect.Editions && fd.L1.Kind == protoreflect.MessageKind && fd.L1.EditionFeatures.IsDelimitedEncoded {
470
		fd.L1.Kind = protoreflect.GroupKind
471
	}
472
	if fd.Syntax() == protoreflect.Editions && fd.L1.EditionFeatures.IsLegacyRequired {
473
		fd.L1.Cardinality = protoreflect.Required
474
	}
475
	if rawTypeName != nil {
476
		name := makeFullName(sb, rawTypeName)
477
		switch fd.L1.Kind {
478
		case protoreflect.EnumKind:
479
			fd.L1.Enum = PlaceholderEnum(name)
480
		case protoreflect.MessageKind, protoreflect.GroupKind:
481
			fd.L1.Message = PlaceholderMessage(name)
482
		}
483
	}
484
	fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
485
}
486

487
func (fd *Field) unmarshalOptions(b []byte) {
488
	const FieldOptions_EnforceUTF8 = 13
489

490
	for len(b) > 0 {
491
		num, typ, n := protowire.ConsumeTag(b)
492
		b = b[n:]
493
		switch typ {
494
		case protowire.VarintType:
495
			v, m := protowire.ConsumeVarint(b)
496
			b = b[m:]
497
			switch num {
498
			case genid.FieldOptions_Packed_field_number:
499
				fd.L1.HasPacked = true
500
				fd.L1.IsPacked = protowire.DecodeBool(v)
501
			case genid.FieldOptions_Weak_field_number:
502
				fd.L1.IsWeak = protowire.DecodeBool(v)
503
			case FieldOptions_EnforceUTF8:
504
				fd.L1.HasEnforceUTF8 = true
505
				fd.L1.EnforceUTF8 = protowire.DecodeBool(v)
506
			}
507
		case protowire.BytesType:
508
			v, m := protowire.ConsumeBytes(b)
509
			b = b[m:]
510
			switch num {
511
			case genid.FieldOptions_Features_field_number:
512
				fd.L1.EditionFeatures = unmarshalFeatureSet(v, fd.L1.EditionFeatures)
513
			}
514
		default:
515
			m := protowire.ConsumeFieldValue(num, typ, b)
516
			b = b[m:]
517
		}
518
	}
519
}
520

521
func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
522
	od.L0.ParentFile = pf
523
	od.L0.Parent = pd
524
	od.L0.Index = i
525

526
	var rawOptions []byte
527
	for len(b) > 0 {
528
		num, typ, n := protowire.ConsumeTag(b)
529
		b = b[n:]
530
		switch typ {
531
		case protowire.BytesType:
532
			v, m := protowire.ConsumeBytes(b)
533
			b = b[m:]
534
			switch num {
535
			case genid.OneofDescriptorProto_Name_field_number:
536
				od.L0.FullName = appendFullName(sb, pd.FullName(), v)
537
			case genid.OneofDescriptorProto_Options_field_number:
538
				rawOptions = appendOptions(rawOptions, v)
539
			}
540
		default:
541
			m := protowire.ConsumeFieldValue(num, typ, b)
542
			b = b[m:]
543
		}
544
	}
545
	od.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Oneof, rawOptions)
546
}
547

548
func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
549
	var rawTypeName []byte
550
	var rawOptions []byte
551
	xd.L1.EditionFeatures = featuresFromParentDesc(xd.L1.Extendee)
552
	xd.L2 = new(ExtensionL2)
553
	for len(b) > 0 {
554
		num, typ, n := protowire.ConsumeTag(b)
555
		b = b[n:]
556
		switch typ {
557
		case protowire.VarintType:
558
			v, m := protowire.ConsumeVarint(b)
559
			b = b[m:]
560
			switch num {
561
			case genid.FieldDescriptorProto_Proto3Optional_field_number:
562
				xd.L2.IsProto3Optional = protowire.DecodeBool(v)
563
			}
564
		case protowire.BytesType:
565
			v, m := protowire.ConsumeBytes(b)
566
			b = b[m:]
567
			switch num {
568
			case genid.FieldDescriptorProto_JsonName_field_number:
569
				xd.L2.StringName.InitJSON(sb.MakeString(v))
570
			case genid.FieldDescriptorProto_DefaultValue_field_number:
571
				xd.L2.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
572
			case genid.FieldDescriptorProto_TypeName_field_number:
573
				rawTypeName = v
574
			case genid.FieldDescriptorProto_Options_field_number:
575
				xd.unmarshalOptions(v)
576
				rawOptions = appendOptions(rawOptions, v)
577
			}
578
		default:
579
			m := protowire.ConsumeFieldValue(num, typ, b)
580
			b = b[m:]
581
		}
582
	}
583
	if xd.Syntax() == protoreflect.Editions && xd.L1.Kind == protoreflect.MessageKind && xd.L1.EditionFeatures.IsDelimitedEncoded {
584
		xd.L1.Kind = protoreflect.GroupKind
585
	}
586
	if xd.Syntax() == protoreflect.Editions && xd.L1.EditionFeatures.IsLegacyRequired {
587
		xd.L1.Cardinality = protoreflect.Required
588
	}
589
	if rawTypeName != nil {
590
		name := makeFullName(sb, rawTypeName)
591
		switch xd.L1.Kind {
592
		case protoreflect.EnumKind:
593
			xd.L2.Enum = PlaceholderEnum(name)
594
		case protoreflect.MessageKind, protoreflect.GroupKind:
595
			xd.L2.Message = PlaceholderMessage(name)
596
		}
597
	}
598
	xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
599
}
600

601
func (xd *Extension) unmarshalOptions(b []byte) {
602
	for len(b) > 0 {
603
		num, typ, n := protowire.ConsumeTag(b)
604
		b = b[n:]
605
		switch typ {
606
		case protowire.VarintType:
607
			v, m := protowire.ConsumeVarint(b)
608
			b = b[m:]
609
			switch num {
610
			case genid.FieldOptions_Packed_field_number:
611
				xd.L2.IsPacked = protowire.DecodeBool(v)
612
			}
613
		case protowire.BytesType:
614
			v, m := protowire.ConsumeBytes(b)
615
			b = b[m:]
616
			switch num {
617
			case genid.FieldOptions_Features_field_number:
618
				xd.L1.EditionFeatures = unmarshalFeatureSet(v, xd.L1.EditionFeatures)
619
			}
620
		default:
621
			m := protowire.ConsumeFieldValue(num, typ, b)
622
			b = b[m:]
623
		}
624
	}
625
}
626

627
func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) {
628
	var rawMethods [][]byte
629
	var rawOptions []byte
630
	sd.L2 = new(ServiceL2)
631
	for len(b) > 0 {
632
		num, typ, n := protowire.ConsumeTag(b)
633
		b = b[n:]
634
		switch typ {
635
		case protowire.BytesType:
636
			v, m := protowire.ConsumeBytes(b)
637
			b = b[m:]
638
			switch num {
639
			case genid.ServiceDescriptorProto_Method_field_number:
640
				rawMethods = append(rawMethods, v)
641
			case genid.ServiceDescriptorProto_Options_field_number:
642
				rawOptions = appendOptions(rawOptions, v)
643
			}
644
		default:
645
			m := protowire.ConsumeFieldValue(num, typ, b)
646
			b = b[m:]
647
		}
648
	}
649
	if len(rawMethods) > 0 {
650
		sd.L2.Methods.List = make([]Method, len(rawMethods))
651
		for i, b := range rawMethods {
652
			sd.L2.Methods.List[i].unmarshalFull(b, sb, sd.L0.ParentFile, sd, i)
653
		}
654
	}
655
	sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions)
656
}
657

658
func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
659
	md.L0.ParentFile = pf
660
	md.L0.Parent = pd
661
	md.L0.Index = i
662

663
	var rawOptions []byte
664
	for len(b) > 0 {
665
		num, typ, n := protowire.ConsumeTag(b)
666
		b = b[n:]
667
		switch typ {
668
		case protowire.VarintType:
669
			v, m := protowire.ConsumeVarint(b)
670
			b = b[m:]
671
			switch num {
672
			case genid.MethodDescriptorProto_ClientStreaming_field_number:
673
				md.L1.IsStreamingClient = protowire.DecodeBool(v)
674
			case genid.MethodDescriptorProto_ServerStreaming_field_number:
675
				md.L1.IsStreamingServer = protowire.DecodeBool(v)
676
			}
677
		case protowire.BytesType:
678
			v, m := protowire.ConsumeBytes(b)
679
			b = b[m:]
680
			switch num {
681
			case genid.MethodDescriptorProto_Name_field_number:
682
				md.L0.FullName = appendFullName(sb, pd.FullName(), v)
683
			case genid.MethodDescriptorProto_InputType_field_number:
684
				md.L1.Input = PlaceholderMessage(makeFullName(sb, v))
685
			case genid.MethodDescriptorProto_OutputType_field_number:
686
				md.L1.Output = PlaceholderMessage(makeFullName(sb, v))
687
			case genid.MethodDescriptorProto_Options_field_number:
688
				rawOptions = appendOptions(rawOptions, v)
689
			}
690
		default:
691
			m := protowire.ConsumeFieldValue(num, typ, b)
692
			b = b[m:]
693
		}
694
	}
695
	md.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Method, rawOptions)
696
}
697

698
// appendOptions appends src to dst, where the returned slice is never nil.
699
// This is necessary to distinguish between empty and unpopulated options.
700
func appendOptions(dst, src []byte) []byte {
701
	if dst == nil {
702
		dst = []byte{}
703
	}
704
	return append(dst, src...)
705
}
706

707
// optionsUnmarshaler constructs a lazy unmarshal function for an options message.
708
//
709
// The type of message to unmarshal to is passed as a pointer since the
710
// vars in descopts may not yet be populated at the time this function is called.
711
func (db *Builder) optionsUnmarshaler(p *protoreflect.ProtoMessage, b []byte) func() protoreflect.ProtoMessage {
712
	if b == nil {
713
		return nil
714
	}
715
	var opts protoreflect.ProtoMessage
716
	var once sync.Once
717
	return func() protoreflect.ProtoMessage {
718
		once.Do(func() {
719
			if *p == nil {
720
				panic("Descriptor.Options called without importing the descriptor package")
721
			}
722
			opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(protoreflect.ProtoMessage)
723
			if err := (proto.UnmarshalOptions{
724
				AllowPartial: true,
725
				Resolver:     db.TypeResolver,
726
			}).Unmarshal(b, opts); err != nil {
727
				panic(err)
728
			}
729
		})
730
		return opts
731
	}
732
}
733