11 "google.golang.org/protobuf/encoding/protowire" |
11 "google.golang.org/protobuf/encoding/protowire" |
12 "google.golang.org/protobuf/internal/descopts" |
12 "google.golang.org/protobuf/internal/descopts" |
13 "google.golang.org/protobuf/internal/genid" |
13 "google.golang.org/protobuf/internal/genid" |
14 "google.golang.org/protobuf/internal/strs" |
14 "google.golang.org/protobuf/internal/strs" |
15 "google.golang.org/protobuf/proto" |
15 "google.golang.org/protobuf/proto" |
16 pref "google.golang.org/protobuf/reflect/protoreflect" |
16 "google.golang.org/protobuf/reflect/protoreflect" |
17 ) |
17 ) |
18 |
18 |
19 func (fd *File) lazyRawInit() { |
19 func (fd *File) lazyRawInit() { |
20 fd.unmarshalFull(fd.builder.RawDescriptor) |
20 fd.unmarshalFull(fd.builder.RawDescriptor) |
21 fd.resolveMessages() |
21 fd.resolveMessages() |
37 continue |
37 continue |
38 } |
38 } |
39 |
39 |
40 // Resolve message field dependency. |
40 // Resolve message field dependency. |
41 switch fd.L1.Kind { |
41 switch fd.L1.Kind { |
42 case pref.EnumKind: |
42 case protoreflect.EnumKind: |
43 fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx) |
43 fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx) |
44 depIdx++ |
44 depIdx++ |
45 case pref.MessageKind, pref.GroupKind: |
45 case protoreflect.MessageKind, protoreflect.GroupKind: |
46 fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx) |
46 fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx) |
47 depIdx++ |
47 depIdx++ |
48 } |
48 } |
49 |
49 |
50 // Default is resolved here since it depends on Enum being resolved. |
50 // Default is resolved here since it depends on Enum being resolved. |
60 for i := range file.allExtensions { |
60 for i := range file.allExtensions { |
61 xd := &file.allExtensions[i] |
61 xd := &file.allExtensions[i] |
62 |
62 |
63 // Resolve extension field dependency. |
63 // Resolve extension field dependency. |
64 switch xd.L1.Kind { |
64 switch xd.L1.Kind { |
65 case pref.EnumKind: |
65 case protoreflect.EnumKind: |
66 xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx) |
66 xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx) |
67 depIdx++ |
67 depIdx++ |
68 case pref.MessageKind, pref.GroupKind: |
68 case protoreflect.MessageKind, protoreflect.GroupKind: |
69 xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx) |
69 xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx) |
70 depIdx++ |
70 depIdx++ |
71 } |
71 } |
72 |
72 |
73 // Default is resolved here since it depends on Enum being resolved. |
73 // Default is resolved here since it depends on Enum being resolved. |
90 depIdx++ |
90 depIdx++ |
91 } |
91 } |
92 } |
92 } |
93 } |
93 } |
94 |
94 |
95 func (file *File) resolveEnumDependency(ed pref.EnumDescriptor, i, j int32) pref.EnumDescriptor { |
95 func (file *File) resolveEnumDependency(ed protoreflect.EnumDescriptor, i, j int32) protoreflect.EnumDescriptor { |
96 r := file.builder.FileRegistry |
96 r := file.builder.FileRegistry |
97 if r, ok := r.(resolverByIndex); ok { |
97 if r, ok := r.(resolverByIndex); ok { |
98 if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil { |
98 if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil { |
99 return ed2 |
99 return ed2 |
100 } |
100 } |
103 if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() { |
103 if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() { |
104 return ed2 |
104 return ed2 |
105 } |
105 } |
106 } |
106 } |
107 if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil { |
107 if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil { |
108 return d.(pref.EnumDescriptor) |
108 return d.(protoreflect.EnumDescriptor) |
109 } |
109 } |
110 return ed |
110 return ed |
111 } |
111 } |
112 |
112 |
113 func (file *File) resolveMessageDependency(md pref.MessageDescriptor, i, j int32) pref.MessageDescriptor { |
113 func (file *File) resolveMessageDependency(md protoreflect.MessageDescriptor, i, j int32) protoreflect.MessageDescriptor { |
114 r := file.builder.FileRegistry |
114 r := file.builder.FileRegistry |
115 if r, ok := r.(resolverByIndex); ok { |
115 if r, ok := r.(resolverByIndex); ok { |
116 if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil { |
116 if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil { |
117 return md2 |
117 return md2 |
118 } |
118 } |
156 path := sb.MakeString(v) |
156 path := sb.MakeString(v) |
157 imp, _ := fd.builder.FileRegistry.FindFileByPath(path) |
157 imp, _ := fd.builder.FileRegistry.FindFileByPath(path) |
158 if imp == nil { |
158 if imp == nil { |
159 imp = PlaceholderFile(path) |
159 imp = PlaceholderFile(path) |
160 } |
160 } |
161 fd.L2.Imports = append(fd.L2.Imports, pref.FileImport{FileDescriptor: imp}) |
161 fd.L2.Imports = append(fd.L2.Imports, protoreflect.FileImport{FileDescriptor: imp}) |
162 case genid.FileDescriptorProto_EnumType_field_number: |
162 case genid.FileDescriptorProto_EnumType_field_number: |
163 fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb) |
163 fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb) |
164 enumIdx++ |
164 enumIdx++ |
165 case genid.FileDescriptorProto_MessageType_field_number: |
165 case genid.FileDescriptorProto_MessageType_field_number: |
166 fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb) |
166 fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb) |
197 b = b[m:] |
197 b = b[m:] |
198 switch num { |
198 switch num { |
199 case genid.EnumDescriptorProto_Value_field_number: |
199 case genid.EnumDescriptorProto_Value_field_number: |
200 rawValues = append(rawValues, v) |
200 rawValues = append(rawValues, v) |
201 case genid.EnumDescriptorProto_ReservedName_field_number: |
201 case genid.EnumDescriptorProto_ReservedName_field_number: |
202 ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, pref.Name(sb.MakeString(v))) |
202 ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v))) |
203 case genid.EnumDescriptorProto_ReservedRange_field_number: |
203 case genid.EnumDescriptorProto_ReservedRange_field_number: |
204 ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v)) |
204 ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v)) |
205 case genid.EnumDescriptorProto_Options_field_number: |
205 case genid.EnumDescriptorProto_Options_field_number: |
206 rawOptions = appendOptions(rawOptions, v) |
206 rawOptions = appendOptions(rawOptions, v) |
207 } |
207 } |
217 } |
217 } |
218 } |
218 } |
219 ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions) |
219 ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions) |
220 } |
220 } |
221 |
221 |
222 func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) { |
222 func unmarshalEnumReservedRange(b []byte) (r [2]protoreflect.EnumNumber) { |
223 for len(b) > 0 { |
223 for len(b) > 0 { |
224 num, typ, n := protowire.ConsumeTag(b) |
224 num, typ, n := protowire.ConsumeTag(b) |
225 b = b[n:] |
225 b = b[n:] |
226 switch typ { |
226 switch typ { |
227 case protowire.VarintType: |
227 case protowire.VarintType: |
228 v, m := protowire.ConsumeVarint(b) |
228 v, m := protowire.ConsumeVarint(b) |
229 b = b[m:] |
229 b = b[m:] |
230 switch num { |
230 switch num { |
231 case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number: |
231 case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number: |
232 r[0] = pref.EnumNumber(v) |
232 r[0] = protoreflect.EnumNumber(v) |
233 case genid.EnumDescriptorProto_EnumReservedRange_End_field_number: |
233 case genid.EnumDescriptorProto_EnumReservedRange_End_field_number: |
234 r[1] = pref.EnumNumber(v) |
234 r[1] = protoreflect.EnumNumber(v) |
235 } |
235 } |
236 default: |
236 default: |
237 m := protowire.ConsumeFieldValue(num, typ, b) |
237 m := protowire.ConsumeFieldValue(num, typ, b) |
238 b = b[m:] |
238 b = b[m:] |
239 } |
239 } |
240 } |
240 } |
241 return r |
241 return r |
242 } |
242 } |
243 |
243 |
244 func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { |
244 func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) { |
245 vd.L0.ParentFile = pf |
245 vd.L0.ParentFile = pf |
246 vd.L0.Parent = pd |
246 vd.L0.Parent = pd |
247 vd.L0.Index = i |
247 vd.L0.Index = i |
248 |
248 |
249 var rawOptions []byte |
249 var rawOptions []byte |
254 case protowire.VarintType: |
254 case protowire.VarintType: |
255 v, m := protowire.ConsumeVarint(b) |
255 v, m := protowire.ConsumeVarint(b) |
256 b = b[m:] |
256 b = b[m:] |
257 switch num { |
257 switch num { |
258 case genid.EnumValueDescriptorProto_Number_field_number: |
258 case genid.EnumValueDescriptorProto_Number_field_number: |
259 vd.L1.Number = pref.EnumNumber(v) |
259 vd.L1.Number = protoreflect.EnumNumber(v) |
260 } |
260 } |
261 case protowire.BytesType: |
261 case protowire.BytesType: |
262 v, m := protowire.ConsumeBytes(b) |
262 v, m := protowire.ConsumeBytes(b) |
263 b = b[m:] |
263 b = b[m:] |
264 switch num { |
264 switch num { |
292 case genid.DescriptorProto_Field_field_number: |
292 case genid.DescriptorProto_Field_field_number: |
293 rawFields = append(rawFields, v) |
293 rawFields = append(rawFields, v) |
294 case genid.DescriptorProto_OneofDecl_field_number: |
294 case genid.DescriptorProto_OneofDecl_field_number: |
295 rawOneofs = append(rawOneofs, v) |
295 rawOneofs = append(rawOneofs, v) |
296 case genid.DescriptorProto_ReservedName_field_number: |
296 case genid.DescriptorProto_ReservedName_field_number: |
297 md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, pref.Name(sb.MakeString(v))) |
297 md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v))) |
298 case genid.DescriptorProto_ReservedRange_field_number: |
298 case genid.DescriptorProto_ReservedRange_field_number: |
299 md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v)) |
299 md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v)) |
300 case genid.DescriptorProto_ExtensionRange_field_number: |
300 case genid.DescriptorProto_ExtensionRange_field_number: |
301 r, rawOptions := unmarshalMessageExtensionRange(v) |
301 r, rawOptions := unmarshalMessageExtensionRange(v) |
302 opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions) |
302 opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions) |
324 md.L2.Fields.List = make([]Field, len(rawFields)) |
324 md.L2.Fields.List = make([]Field, len(rawFields)) |
325 md.L2.Oneofs.List = make([]Oneof, len(rawOneofs)) |
325 md.L2.Oneofs.List = make([]Oneof, len(rawOneofs)) |
326 for i, b := range rawFields { |
326 for i, b := range rawFields { |
327 fd := &md.L2.Fields.List[i] |
327 fd := &md.L2.Fields.List[i] |
328 fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i) |
328 fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i) |
329 if fd.L1.Cardinality == pref.Required { |
329 if fd.L1.Cardinality == protoreflect.Required { |
330 md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number) |
330 md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number) |
331 } |
331 } |
332 } |
332 } |
333 for i, b := range rawOneofs { |
333 for i, b := range rawOneofs { |
334 od := &md.L2.Oneofs.List[i] |
334 od := &md.L2.Oneofs.List[i] |
357 b = b[m:] |
357 b = b[m:] |
358 } |
358 } |
359 } |
359 } |
360 } |
360 } |
361 |
361 |
362 func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) { |
362 func unmarshalMessageReservedRange(b []byte) (r [2]protoreflect.FieldNumber) { |
363 for len(b) > 0 { |
363 for len(b) > 0 { |
364 num, typ, n := protowire.ConsumeTag(b) |
364 num, typ, n := protowire.ConsumeTag(b) |
365 b = b[n:] |
365 b = b[n:] |
366 switch typ { |
366 switch typ { |
367 case protowire.VarintType: |
367 case protowire.VarintType: |
368 v, m := protowire.ConsumeVarint(b) |
368 v, m := protowire.ConsumeVarint(b) |
369 b = b[m:] |
369 b = b[m:] |
370 switch num { |
370 switch num { |
371 case genid.DescriptorProto_ReservedRange_Start_field_number: |
371 case genid.DescriptorProto_ReservedRange_Start_field_number: |
372 r[0] = pref.FieldNumber(v) |
372 r[0] = protoreflect.FieldNumber(v) |
373 case genid.DescriptorProto_ReservedRange_End_field_number: |
373 case genid.DescriptorProto_ReservedRange_End_field_number: |
374 r[1] = pref.FieldNumber(v) |
374 r[1] = protoreflect.FieldNumber(v) |
375 } |
375 } |
376 default: |
376 default: |
377 m := protowire.ConsumeFieldValue(num, typ, b) |
377 m := protowire.ConsumeFieldValue(num, typ, b) |
378 b = b[m:] |
378 b = b[m:] |
379 } |
379 } |
380 } |
380 } |
381 return r |
381 return r |
382 } |
382 } |
383 |
383 |
384 func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions []byte) { |
384 func unmarshalMessageExtensionRange(b []byte) (r [2]protoreflect.FieldNumber, rawOptions []byte) { |
385 for len(b) > 0 { |
385 for len(b) > 0 { |
386 num, typ, n := protowire.ConsumeTag(b) |
386 num, typ, n := protowire.ConsumeTag(b) |
387 b = b[n:] |
387 b = b[n:] |
388 switch typ { |
388 switch typ { |
389 case protowire.VarintType: |
389 case protowire.VarintType: |
390 v, m := protowire.ConsumeVarint(b) |
390 v, m := protowire.ConsumeVarint(b) |
391 b = b[m:] |
391 b = b[m:] |
392 switch num { |
392 switch num { |
393 case genid.DescriptorProto_ExtensionRange_Start_field_number: |
393 case genid.DescriptorProto_ExtensionRange_Start_field_number: |
394 r[0] = pref.FieldNumber(v) |
394 r[0] = protoreflect.FieldNumber(v) |
395 case genid.DescriptorProto_ExtensionRange_End_field_number: |
395 case genid.DescriptorProto_ExtensionRange_End_field_number: |
396 r[1] = pref.FieldNumber(v) |
396 r[1] = protoreflect.FieldNumber(v) |
397 } |
397 } |
398 case protowire.BytesType: |
398 case protowire.BytesType: |
399 v, m := protowire.ConsumeBytes(b) |
399 v, m := protowire.ConsumeBytes(b) |
400 b = b[m:] |
400 b = b[m:] |
401 switch num { |
401 switch num { |
424 case protowire.VarintType: |
424 case protowire.VarintType: |
425 v, m := protowire.ConsumeVarint(b) |
425 v, m := protowire.ConsumeVarint(b) |
426 b = b[m:] |
426 b = b[m:] |
427 switch num { |
427 switch num { |
428 case genid.FieldDescriptorProto_Number_field_number: |
428 case genid.FieldDescriptorProto_Number_field_number: |
429 fd.L1.Number = pref.FieldNumber(v) |
429 fd.L1.Number = protoreflect.FieldNumber(v) |
430 case genid.FieldDescriptorProto_Label_field_number: |
430 case genid.FieldDescriptorProto_Label_field_number: |
431 fd.L1.Cardinality = pref.Cardinality(v) |
431 fd.L1.Cardinality = protoreflect.Cardinality(v) |
432 case genid.FieldDescriptorProto_Type_field_number: |
432 case genid.FieldDescriptorProto_Type_field_number: |
433 fd.L1.Kind = pref.Kind(v) |
433 fd.L1.Kind = protoreflect.Kind(v) |
434 case genid.FieldDescriptorProto_OneofIndex_field_number: |
434 case genid.FieldDescriptorProto_OneofIndex_field_number: |
435 // In Message.unmarshalFull, we allocate slices for both |
435 // In Message.unmarshalFull, we allocate slices for both |
436 // the field and oneof descriptors before unmarshaling either |
436 // the field and oneof descriptors before unmarshaling either |
437 // of them. This ensures pointers to slice elements are stable. |
437 // of them. This ensures pointers to slice elements are stable. |
438 od := &pd.(*Message).L2.Oneofs.List[v] |
438 od := &pd.(*Message).L2.Oneofs.List[v] |
451 case genid.FieldDescriptorProto_Name_field_number: |
451 case genid.FieldDescriptorProto_Name_field_number: |
452 fd.L0.FullName = appendFullName(sb, pd.FullName(), v) |
452 fd.L0.FullName = appendFullName(sb, pd.FullName(), v) |
453 case genid.FieldDescriptorProto_JsonName_field_number: |
453 case genid.FieldDescriptorProto_JsonName_field_number: |
454 fd.L1.StringName.InitJSON(sb.MakeString(v)) |
454 fd.L1.StringName.InitJSON(sb.MakeString(v)) |
455 case genid.FieldDescriptorProto_DefaultValue_field_number: |
455 case genid.FieldDescriptorProto_DefaultValue_field_number: |
456 fd.L1.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages |
456 fd.L1.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages |
457 case genid.FieldDescriptorProto_TypeName_field_number: |
457 case genid.FieldDescriptorProto_TypeName_field_number: |
458 rawTypeName = v |
458 rawTypeName = v |
459 case genid.FieldDescriptorProto_Options_field_number: |
459 case genid.FieldDescriptorProto_Options_field_number: |
460 fd.unmarshalOptions(v) |
460 fd.unmarshalOptions(v) |
461 rawOptions = appendOptions(rawOptions, v) |
461 rawOptions = appendOptions(rawOptions, v) |
466 } |
466 } |
467 } |
467 } |
468 if rawTypeName != nil { |
468 if rawTypeName != nil { |
469 name := makeFullName(sb, rawTypeName) |
469 name := makeFullName(sb, rawTypeName) |
470 switch fd.L1.Kind { |
470 switch fd.L1.Kind { |
471 case pref.EnumKind: |
471 case protoreflect.EnumKind: |
472 fd.L1.Enum = PlaceholderEnum(name) |
472 fd.L1.Enum = PlaceholderEnum(name) |
473 case pref.MessageKind, pref.GroupKind: |
473 case protoreflect.MessageKind, protoreflect.GroupKind: |
474 fd.L1.Message = PlaceholderMessage(name) |
474 fd.L1.Message = PlaceholderMessage(name) |
475 } |
475 } |
476 } |
476 } |
477 fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions) |
477 fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions) |
478 } |
478 } |
551 b = b[m:] |
551 b = b[m:] |
552 switch num { |
552 switch num { |
553 case genid.FieldDescriptorProto_JsonName_field_number: |
553 case genid.FieldDescriptorProto_JsonName_field_number: |
554 xd.L2.StringName.InitJSON(sb.MakeString(v)) |
554 xd.L2.StringName.InitJSON(sb.MakeString(v)) |
555 case genid.FieldDescriptorProto_DefaultValue_field_number: |
555 case genid.FieldDescriptorProto_DefaultValue_field_number: |
556 xd.L2.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions |
556 xd.L2.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions |
557 case genid.FieldDescriptorProto_TypeName_field_number: |
557 case genid.FieldDescriptorProto_TypeName_field_number: |
558 rawTypeName = v |
558 rawTypeName = v |
559 case genid.FieldDescriptorProto_Options_field_number: |
559 case genid.FieldDescriptorProto_Options_field_number: |
560 xd.unmarshalOptions(v) |
560 xd.unmarshalOptions(v) |
561 rawOptions = appendOptions(rawOptions, v) |
561 rawOptions = appendOptions(rawOptions, v) |
566 } |
566 } |
567 } |
567 } |
568 if rawTypeName != nil { |
568 if rawTypeName != nil { |
569 name := makeFullName(sb, rawTypeName) |
569 name := makeFullName(sb, rawTypeName) |
570 switch xd.L1.Kind { |
570 switch xd.L1.Kind { |
571 case pref.EnumKind: |
571 case protoreflect.EnumKind: |
572 xd.L2.Enum = PlaceholderEnum(name) |
572 xd.L2.Enum = PlaceholderEnum(name) |
573 case pref.MessageKind, pref.GroupKind: |
573 case protoreflect.MessageKind, protoreflect.GroupKind: |
574 xd.L2.Message = PlaceholderMessage(name) |
574 xd.L2.Message = PlaceholderMessage(name) |
575 } |
575 } |
576 } |
576 } |
577 xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions) |
577 xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions) |
578 } |
578 } |
625 } |
625 } |
626 } |
626 } |
627 sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions) |
627 sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions) |
628 } |
628 } |
629 |
629 |
630 func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { |
630 func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) { |
631 md.L0.ParentFile = pf |
631 md.L0.ParentFile = pf |
632 md.L0.Parent = pd |
632 md.L0.Parent = pd |
633 md.L0.Index = i |
633 md.L0.Index = i |
634 |
634 |
635 var rawOptions []byte |
635 var rawOptions []byte |
678 |
678 |
679 // optionsUnmarshaler constructs a lazy unmarshal function for an options message. |
679 // optionsUnmarshaler constructs a lazy unmarshal function for an options message. |
680 // |
680 // |
681 // The type of message to unmarshal to is passed as a pointer since the |
681 // The type of message to unmarshal to is passed as a pointer since the |
682 // vars in descopts may not yet be populated at the time this function is called. |
682 // vars in descopts may not yet be populated at the time this function is called. |
683 func (db *Builder) optionsUnmarshaler(p *pref.ProtoMessage, b []byte) func() pref.ProtoMessage { |
683 func (db *Builder) optionsUnmarshaler(p *protoreflect.ProtoMessage, b []byte) func() protoreflect.ProtoMessage { |
684 if b == nil { |
684 if b == nil { |
685 return nil |
685 return nil |
686 } |
686 } |
687 var opts pref.ProtoMessage |
687 var opts protoreflect.ProtoMessage |
688 var once sync.Once |
688 var once sync.Once |
689 return func() pref.ProtoMessage { |
689 return func() protoreflect.ProtoMessage { |
690 once.Do(func() { |
690 once.Do(func() { |
691 if *p == nil { |
691 if *p == nil { |
692 panic("Descriptor.Options called without importing the descriptor package") |
692 panic("Descriptor.Options called without importing the descriptor package") |
693 } |
693 } |
694 opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(pref.ProtoMessage) |
694 opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(protoreflect.ProtoMessage) |
695 if err := (proto.UnmarshalOptions{ |
695 if err := (proto.UnmarshalOptions{ |
696 AllowPartial: true, |
696 AllowPartial: true, |
697 Resolver: db.TypeResolver, |
697 Resolver: db.TypeResolver, |
698 }).Unmarshal(b, opts); err != nil { |
698 }).Unmarshal(b, opts); err != nil { |
699 panic(err) |
699 panic(err) |