[chore] remove vendor

1 files changed, 0 insertions, 703 deletions

diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
deleted file mode 100644
index 67a51b327..000000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
+++ /dev/null
@@ -1,703 +0,0 @@
-// Copyright 2019 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 filedesc
-
-import (
-	"reflect"
-	"sync"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/descopts"
-	"google.golang.org/protobuf/internal/genid"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func (fd *File) lazyRawInit() {
-	fd.unmarshalFull(fd.builder.RawDescriptor)
-	fd.resolveMessages()
-	fd.resolveExtensions()
-	fd.resolveServices()
-}
-
-func (file *File) resolveMessages() {
-	var depIdx int32
-	for i := range file.allMessages {
-		md := &file.allMessages[i]
-
-		// Resolve message field dependencies.
-		for j := range md.L2.Fields.List {
-			fd := &md.L2.Fields.List[j]
-
-			// Weak fields are resolved upon actual use.
-			if fd.L1.IsWeak {
-				continue
-			}
-
-			// Resolve message field dependency.
-			switch fd.L1.Kind {
-			case protoreflect.EnumKind:
-				fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)
-				depIdx++
-			case protoreflect.MessageKind, protoreflect.GroupKind:
-				fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)
-				depIdx++
-				if fd.L1.Kind == protoreflect.GroupKind && (fd.IsMap() || fd.IsMapEntry()) {
-					// A map field might inherit delimited encoding from a file-wide default feature.
-					// But maps never actually use delimited encoding. (At least for now...)
-					fd.L1.Kind = protoreflect.MessageKind
-				}
-			}
-
-			// Default is resolved here since it depends on Enum being resolved.
-			if v := fd.L1.Default.val; v.IsValid() {
-				fd.L1.Default = unmarshalDefault(v.Bytes(), fd.L1.Kind, file, fd.L1.Enum)
-			}
-		}
-	}
-}
-
-func (file *File) resolveExtensions() {
-	var depIdx int32
-	for i := range file.allExtensions {
-		xd := &file.allExtensions[i]
-
-		// Resolve extension field dependency.
-		switch xd.L1.Kind {
-		case protoreflect.EnumKind:
-			xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)
-			depIdx++
-		case protoreflect.MessageKind, protoreflect.GroupKind:
-			xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)
-			depIdx++
-		}
-
-		// Default is resolved here since it depends on Enum being resolved.
-		if v := xd.L2.Default.val; v.IsValid() {
-			xd.L2.Default = unmarshalDefault(v.Bytes(), xd.L1.Kind, file, xd.L2.Enum)
-		}
-	}
-}
-
-func (file *File) resolveServices() {
-	var depIdx int32
-	for i := range file.allServices {
-		sd := &file.allServices[i]
-
-		// Resolve method dependencies.
-		for j := range sd.L2.Methods.List {
-			md := &sd.L2.Methods.List[j]
-			md.L1.Input = file.resolveMessageDependency(md.L1.Input, listMethInDeps, depIdx)
-			md.L1.Output = file.resolveMessageDependency(md.L1.Output, listMethOutDeps, depIdx)
-			depIdx++
-		}
-	}
-}
-
-func (file *File) resolveEnumDependency(ed protoreflect.EnumDescriptor, i, j int32) protoreflect.EnumDescriptor {
-	r := file.builder.FileRegistry
-	if r, ok := r.(resolverByIndex); ok {
-		if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {
-			return ed2
-		}
-	}
-	for i := range file.allEnums {
-		if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() {
-			return ed2
-		}
-	}
-	if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {
-		return d.(protoreflect.EnumDescriptor)
-	}
-	return ed
-}
-
-func (file *File) resolveMessageDependency(md protoreflect.MessageDescriptor, i, j int32) protoreflect.MessageDescriptor {
-	r := file.builder.FileRegistry
-	if r, ok := r.(resolverByIndex); ok {
-		if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {
-			return md2
-		}
-	}
-	for i := range file.allMessages {
-		if md2 := &file.allMessages[i]; md2.L0.FullName == md.FullName() {
-			return md2
-		}
-	}
-	if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {
-		return d.(protoreflect.MessageDescriptor)
-	}
-	return md
-}
-
-func (fd *File) unmarshalFull(b []byte) {
-	sb := getBuilder()
-	defer putBuilder(sb)
-
-	var enumIdx, messageIdx, extensionIdx, serviceIdx int
-	var rawOptions []byte
-	fd.L2 = new(FileL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.FileDescriptorProto_PublicDependency_field_number:
-				fd.L2.Imports[v].IsPublic = true
-			case genid.FileDescriptorProto_WeakDependency_field_number:
-				fd.L2.Imports[v].IsWeak = true
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.FileDescriptorProto_Dependency_field_number:
-				path := sb.MakeString(v)
-				imp, _ := fd.builder.FileRegistry.FindFileByPath(path)
-				if imp == nil {
-					imp = PlaceholderFile(path)
-				}
-				fd.L2.Imports = append(fd.L2.Imports, protoreflect.FileImport{FileDescriptor: imp})
-			case genid.FileDescriptorProto_EnumType_field_number:
-				fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
-				enumIdx++
-			case genid.FileDescriptorProto_MessageType_field_number:
-				fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
-				messageIdx++
-			case genid.FileDescriptorProto_Extension_field_number:
-				fd.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
-				extensionIdx++
-			case genid.FileDescriptorProto_Service_field_number:
-				fd.L1.Services.List[serviceIdx].unmarshalFull(v, sb)
-				serviceIdx++
-			case genid.FileDescriptorProto_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	fd.L2.Options = fd.builder.optionsUnmarshaler(&descopts.File, rawOptions)
-}
-
-func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawValues [][]byte
-	var rawOptions []byte
-	if !ed.L1.eagerValues {
-		ed.L2 = new(EnumL2)
-	}
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.EnumDescriptorProto_Value_field_number:
-				rawValues = append(rawValues, v)
-			case genid.EnumDescriptorProto_ReservedName_field_number:
-				ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
-			case genid.EnumDescriptorProto_ReservedRange_field_number:
-				ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))
-			case genid.EnumDescriptorProto_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if !ed.L1.eagerValues && len(rawValues) > 0 {
-		ed.L2.Values.List = make([]EnumValue, len(rawValues))
-		for i, b := range rawValues {
-			ed.L2.Values.List[i].unmarshalFull(b, sb, ed.L0.ParentFile, ed, i)
-		}
-	}
-	ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)
-}
-
-func unmarshalEnumReservedRange(b []byte) (r [2]protoreflect.EnumNumber) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number:
-				r[0] = protoreflect.EnumNumber(v)
-			case genid.EnumDescriptorProto_EnumReservedRange_End_field_number:
-				r[1] = protoreflect.EnumNumber(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	return r
-}
-
-func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
-	vd.L0.ParentFile = pf
-	vd.L0.Parent = pd
-	vd.L0.Index = i
-
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.EnumValueDescriptorProto_Number_field_number:
-				vd.L1.Number = protoreflect.EnumNumber(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.EnumValueDescriptorProto_Name_field_number:
-				// NOTE: Enum values are in the same scope as the enum parent.
-				vd.L0.FullName = appendFullName(sb, pd.Parent().FullName(), v)
-			case genid.EnumValueDescriptorProto_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	vd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.EnumValue, rawOptions)
-}
-
-func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawFields, rawOneofs [][]byte
-	var enumIdx, messageIdx, extensionIdx int
-	var rawOptions []byte
-	md.L2 = new(MessageL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.DescriptorProto_Field_field_number:
-				rawFields = append(rawFields, v)
-			case genid.DescriptorProto_OneofDecl_field_number:
-				rawOneofs = append(rawOneofs, v)
-			case genid.DescriptorProto_ReservedName_field_number:
-				md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
-			case genid.DescriptorProto_ReservedRange_field_number:
-				md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))
-			case genid.DescriptorProto_ExtensionRange_field_number:
-				r, rawOptions := unmarshalMessageExtensionRange(v)
-				opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions)
-				md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, r)
-				md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, opts)
-			case genid.DescriptorProto_EnumType_field_number:
-				md.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
-				enumIdx++
-			case genid.DescriptorProto_NestedType_field_number:
-				md.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
-				messageIdx++
-			case genid.DescriptorProto_Extension_field_number:
-				md.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
-				extensionIdx++
-			case genid.DescriptorProto_Options_field_number:
-				md.unmarshalOptions(v)
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if len(rawFields) > 0 || len(rawOneofs) > 0 {
-		md.L2.Fields.List = make([]Field, len(rawFields))
-		md.L2.Oneofs.List = make([]Oneof, len(rawOneofs))
-		for i, b := range rawFields {
-			fd := &md.L2.Fields.List[i]
-			fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
-			if fd.L1.Cardinality == protoreflect.Required {
-				md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)
-			}
-		}
-		for i, b := range rawOneofs {
-			od := &md.L2.Oneofs.List[i]
-			od.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
-		}
-	}
-	md.L2.Options = md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Message, rawOptions)
-}
-
-func (md *Message) unmarshalOptions(b []byte) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.MessageOptions_MapEntry_field_number:
-				md.L1.IsMapEntry = protowire.DecodeBool(v)
-			case genid.MessageOptions_MessageSetWireFormat_field_number:
-				md.L1.IsMessageSet = protowire.DecodeBool(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func unmarshalMessageReservedRange(b []byte) (r [2]protoreflect.FieldNumber) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.DescriptorProto_ReservedRange_Start_field_number:
-				r[0] = protoreflect.FieldNumber(v)
-			case genid.DescriptorProto_ReservedRange_End_field_number:
-				r[1] = protoreflect.FieldNumber(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	return r
-}
-
-func unmarshalMessageExtensionRange(b []byte) (r [2]protoreflect.FieldNumber, rawOptions []byte) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.DescriptorProto_ExtensionRange_Start_field_number:
-				r[0] = protoreflect.FieldNumber(v)
-			case genid.DescriptorProto_ExtensionRange_End_field_number:
-				r[1] = protoreflect.FieldNumber(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.DescriptorProto_ExtensionRange_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	return r, rawOptions
-}
-
-func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
-	fd.L0.ParentFile = pf
-	fd.L0.Parent = pd
-	fd.L0.Index = i
-	fd.L1.EditionFeatures = featuresFromParentDesc(fd.Parent())
-
-	var rawTypeName []byte
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.FieldDescriptorProto_Number_field_number:
-				fd.L1.Number = protoreflect.FieldNumber(v)
-			case genid.FieldDescriptorProto_Label_field_number:
-				fd.L1.Cardinality = protoreflect.Cardinality(v)
-			case genid.FieldDescriptorProto_Type_field_number:
-				fd.L1.Kind = protoreflect.Kind(v)
-			case genid.FieldDescriptorProto_OneofIndex_field_number:
-				// In Message.unmarshalFull, we allocate slices for both
-				// the field and oneof descriptors before unmarshaling either
-				// of them. This ensures pointers to slice elements are stable.
-				od := &pd.(*Message).L2.Oneofs.List[v]
-				od.L1.Fields.List = append(od.L1.Fields.List, fd)
-				if fd.L1.ContainingOneof != nil {
-					panic("oneof type already set")
-				}
-				fd.L1.ContainingOneof = od
-			case genid.FieldDescriptorProto_Proto3Optional_field_number:
-				fd.L1.IsProto3Optional = protowire.DecodeBool(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.FieldDescriptorProto_Name_field_number:
-				fd.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case genid.FieldDescriptorProto_JsonName_field_number:
-				fd.L1.StringName.InitJSON(sb.MakeString(v))
-			case genid.FieldDescriptorProto_DefaultValue_field_number:
-				fd.L1.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
-			case genid.FieldDescriptorProto_TypeName_field_number:
-				rawTypeName = v
-			case genid.FieldDescriptorProto_Options_field_number:
-				fd.unmarshalOptions(v)
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if fd.L1.Kind == protoreflect.MessageKind && fd.L1.EditionFeatures.IsDelimitedEncoded {
-		fd.L1.Kind = protoreflect.GroupKind
-	}
-	if fd.L1.EditionFeatures.IsLegacyRequired {
-		fd.L1.Cardinality = protoreflect.Required
-	}
-	if rawTypeName != nil {
-		name := makeFullName(sb, rawTypeName)
-		switch fd.L1.Kind {
-		case protoreflect.EnumKind:
-			fd.L1.Enum = PlaceholderEnum(name)
-		case protoreflect.MessageKind, protoreflect.GroupKind:
-			fd.L1.Message = PlaceholderMessage(name)
-		}
-	}
-	fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
-}
-
-func (fd *Field) unmarshalOptions(b []byte) {
-	const FieldOptions_EnforceUTF8 = 13
-
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.FieldOptions_Packed_field_number:
-				fd.L1.EditionFeatures.IsPacked = protowire.DecodeBool(v)
-			case genid.FieldOptions_Weak_field_number:
-				fd.L1.IsWeak = protowire.DecodeBool(v)
-			case genid.FieldOptions_Lazy_field_number:
-				fd.L1.IsLazy = protowire.DecodeBool(v)
-			case FieldOptions_EnforceUTF8:
-				fd.L1.EditionFeatures.IsUTF8Validated = protowire.DecodeBool(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.FieldOptions_Features_field_number:
-				fd.L1.EditionFeatures = unmarshalFeatureSet(v, fd.L1.EditionFeatures)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
-	od.L0.ParentFile = pf
-	od.L0.Parent = pd
-	od.L0.Index = i
-
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.OneofDescriptorProto_Name_field_number:
-				od.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case genid.OneofDescriptorProto_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	od.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Oneof, rawOptions)
-}
-
-func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawTypeName []byte
-	var rawOptions []byte
-	xd.L2 = new(ExtensionL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.FieldDescriptorProto_Proto3Optional_field_number:
-				xd.L2.IsProto3Optional = protowire.DecodeBool(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.FieldDescriptorProto_JsonName_field_number:
-				xd.L2.StringName.InitJSON(sb.MakeString(v))
-			case genid.FieldDescriptorProto_DefaultValue_field_number:
-				xd.L2.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
-			case genid.FieldDescriptorProto_TypeName_field_number:
-				rawTypeName = v
-			case genid.FieldDescriptorProto_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if rawTypeName != nil {
-		name := makeFullName(sb, rawTypeName)
-		switch xd.L1.Kind {
-		case protoreflect.EnumKind:
-			xd.L2.Enum = PlaceholderEnum(name)
-		case protoreflect.MessageKind, protoreflect.GroupKind:
-			xd.L2.Message = PlaceholderMessage(name)
-		}
-	}
-	xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
-}
-
-func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawMethods [][]byte
-	var rawOptions []byte
-	sd.L2 = new(ServiceL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.ServiceDescriptorProto_Method_field_number:
-				rawMethods = append(rawMethods, v)
-			case genid.ServiceDescriptorProto_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if len(rawMethods) > 0 {
-		sd.L2.Methods.List = make([]Method, len(rawMethods))
-		for i, b := range rawMethods {
-			sd.L2.Methods.List[i].unmarshalFull(b, sb, sd.L0.ParentFile, sd, i)
-		}
-	}
-	sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions)
-}
-
-func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
-	md.L0.ParentFile = pf
-	md.L0.Parent = pd
-	md.L0.Index = i
-
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case genid.MethodDescriptorProto_ClientStreaming_field_number:
-				md.L1.IsStreamingClient = protowire.DecodeBool(v)
-			case genid.MethodDescriptorProto_ServerStreaming_field_number:
-				md.L1.IsStreamingServer = protowire.DecodeBool(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case genid.MethodDescriptorProto_Name_field_number:
-				md.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case genid.MethodDescriptorProto_InputType_field_number:
-				md.L1.Input = PlaceholderMessage(makeFullName(sb, v))
-			case genid.MethodDescriptorProto_OutputType_field_number:
-				md.L1.Output = PlaceholderMessage(makeFullName(sb, v))
-			case genid.MethodDescriptorProto_Options_field_number:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	md.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Method, rawOptions)
-}
-
-// appendOptions appends src to dst, where the returned slice is never nil.
-// This is necessary to distinguish between empty and unpopulated options.
-func appendOptions(dst, src []byte) []byte {
-	if dst == nil {
-		dst = []byte{}
-	}
-	return append(dst, src...)
-}
-
-// optionsUnmarshaler constructs a lazy unmarshal function for an options message.
-//
-// The type of message to unmarshal to is passed as a pointer since the
-// vars in descopts may not yet be populated at the time this function is called.
-func (db *Builder) optionsUnmarshaler(p *protoreflect.ProtoMessage, b []byte) func() protoreflect.ProtoMessage {
-	if b == nil {
-		return nil
-	}
-	var opts protoreflect.ProtoMessage
-	var once sync.Once
-	return func() protoreflect.ProtoMessage {
-		once.Do(func() {
-			if *p == nil {
-				panic("Descriptor.Options called without importing the descriptor package")
-			}
-			opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(protoreflect.ProtoMessage)
-			if err := (proto.UnmarshalOptions{
-				AllowPartial: true,
-				Resolver:     db.TypeResolver,
-			}).Unmarshal(b, opts); err != nil {
-				panic(err)
-			}
-		})
-		return opts
-	}
-}