diff --git a/vendor/github.com/jhump/protoreflect/codec/buffer.go b/vendor/github.com/jhump/protoreflect/codec/buffer.go
new file mode 100644
index 0000000..b9de99c
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/codec/buffer.go
@@ -0,0 +1,112 @@
+package codec
+
+import (
+	"fmt"
+	"io"
+)
+
+// Buffer is a reader and a writer that wraps a slice of bytes and also
+// provides API for decoding and encoding the protobuf binary format.
+//
+// Its operation is similar to that of a bytes.Buffer: writing pushes
+// data to the end of the buffer while reading pops data from the head
+// of the buffer. So the same buffer can be used to both read and write.
+type Buffer struct {
+	buf   []byte
+	index int
+
+	// tmp is used when another byte slice is needed, such as when
+	// serializing messages, since we need to know the length before
+	// we can write the length prefix; by caching this, including
+	// after it is grown by serialization operations, we reduce the
+	// number of allocations needed
+	tmp []byte
+
+	deterministic bool
+}
+
+// NewBuffer creates a new buffer with the given slice of bytes as the
+// buffer's initial contents.
+func NewBuffer(buf []byte) *Buffer {
+	return &Buffer{buf: buf}
+}
+
+// SetDeterministic sets this buffer to encode messages deterministically. This
+// is useful for tests. But the overhead is non-zero, so it should not likely be
+// used outside of tests. When true, map fields in a message must have their
+// keys sorted before serialization to ensure deterministic output. Otherwise,
+// values in a map field will be serialized in map iteration order.
+func (cb *Buffer) SetDeterministic(deterministic bool) {
+	cb.deterministic = deterministic
+}
+
+// Reset resets this buffer back to empty. Any subsequent writes/encodes
+// to the buffer will allocate a new backing slice of bytes.
+func (cb *Buffer) Reset() {
+	cb.buf = []byte(nil)
+	cb.index = 0
+}
+
+// Bytes returns the slice of bytes remaining in the buffer. Note that
+// this does not perform a copy: if the contents of the returned slice
+// are modified, the modifications will be visible to subsequent reads
+// via the buffer.
+func (cb *Buffer) Bytes() []byte {
+	return cb.buf[cb.index:]
+}
+
+// String returns the remaining bytes in the buffer as a string.
+func (cb *Buffer) String() string {
+	return string(cb.Bytes())
+}
+
+// EOF returns true if there are no more bytes remaining to read.
+func (cb *Buffer) EOF() bool {
+	return cb.index >= len(cb.buf)
+}
+
+// Skip attempts to skip the given number of bytes in the input. If
+// the input has fewer bytes than the given count, false is returned
+// and the buffer is unchanged. Otherwise, the given number of bytes
+// are skipped and true is returned.
+func (cb *Buffer) Skip(count int) error {
+	if count < 0 {
+		return fmt.Errorf("proto: bad byte length %d", count)
+	}
+	newIndex := cb.index + count
+	if newIndex < cb.index || newIndex > len(cb.buf) {
+		return io.ErrUnexpectedEOF
+	}
+	cb.index = newIndex
+	return nil
+}
+
+// Len returns the remaining number of bytes in the buffer.
+func (cb *Buffer) Len() int {
+	return len(cb.buf) - cb.index
+}
+
+// Read implements the io.Reader interface. If there are no bytes
+// remaining in the buffer, it will return 0, io.EOF. Otherwise,
+// it reads max(len(dest), cb.Len()) bytes from input and copies
+// them into dest. It returns the number of bytes copied and a nil
+// error in this case.
+func (cb *Buffer) Read(dest []byte) (int, error) {
+	if cb.index == len(cb.buf) {
+		return 0, io.EOF
+	}
+	copied := copy(dest, cb.buf[cb.index:])
+	cb.index += copied
+	return copied, nil
+}
+
+var _ io.Reader = (*Buffer)(nil)
+
+// Write implements the io.Writer interface. It always returns
+// len(data), nil.
+func (cb *Buffer) Write(data []byte) (int, error) {
+	cb.buf = append(cb.buf, data...)
+	return len(data), nil
+}
+
+var _ io.Writer = (*Buffer)(nil)
diff --git a/vendor/github.com/jhump/protoreflect/codec/decode.go b/vendor/github.com/jhump/protoreflect/codec/decode.go
new file mode 100644
index 0000000..2a7e59f
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/codec/decode.go
@@ -0,0 +1,372 @@
+package codec
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"math"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/protoc-gen-go/descriptor"
+)
+
+// ErrOverflow is returned when an integer is too large to be represented.
+var ErrOverflow = errors.New("proto: integer overflow")
+
+// ErrBadWireType is returned when decoding a wire-type from a buffer that
+// is not valid.
+var ErrBadWireType = errors.New("proto: bad wiretype")
+
+var varintTypes = map[descriptor.FieldDescriptorProto_Type]bool{}
+var fixed32Types = map[descriptor.FieldDescriptorProto_Type]bool{}
+var fixed64Types = map[descriptor.FieldDescriptorProto_Type]bool{}
+
+func init() {
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_BOOL] = true
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_INT32] = true
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_INT64] = true
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_UINT32] = true
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_UINT64] = true
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_SINT32] = true
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_SINT64] = true
+	varintTypes[descriptor.FieldDescriptorProto_TYPE_ENUM] = true
+
+	fixed32Types[descriptor.FieldDescriptorProto_TYPE_FIXED32] = true
+	fixed32Types[descriptor.FieldDescriptorProto_TYPE_SFIXED32] = true
+	fixed32Types[descriptor.FieldDescriptorProto_TYPE_FLOAT] = true
+
+	fixed64Types[descriptor.FieldDescriptorProto_TYPE_FIXED64] = true
+	fixed64Types[descriptor.FieldDescriptorProto_TYPE_SFIXED64] = true
+	fixed64Types[descriptor.FieldDescriptorProto_TYPE_DOUBLE] = true
+}
+
+func (cb *Buffer) decodeVarintSlow() (x uint64, err error) {
+	i := cb.index
+	l := len(cb.buf)
+
+	for shift := uint(0); shift < 64; shift += 7 {
+		if i >= l {
+			err = io.ErrUnexpectedEOF
+			return
+		}
+		b := cb.buf[i]
+		i++
+		x |= (uint64(b) & 0x7F) << shift
+		if b < 0x80 {
+			cb.index = i
+			return
+		}
+	}
+
+	// The number is too large to represent in a 64-bit value.
+	err = ErrOverflow
+	return
+}
+
+// DecodeVarint reads a varint-encoded integer from the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (cb *Buffer) DecodeVarint() (uint64, error) {
+	i := cb.index
+	buf := cb.buf
+
+	if i >= len(buf) {
+		return 0, io.ErrUnexpectedEOF
+	} else if buf[i] < 0x80 {
+		cb.index++
+		return uint64(buf[i]), nil
+	} else if len(buf)-i < 10 {
+		return cb.decodeVarintSlow()
+	}
+
+	var b uint64
+	// we already checked the first byte
+	x := uint64(buf[i]) - 0x80
+	i++
+
+	b = uint64(buf[i])
+	i++
+	x += b << 7
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 7
+
+	b = uint64(buf[i])
+	i++
+	x += b << 14
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 14
+
+	b = uint64(buf[i])
+	i++
+	x += b << 21
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 21
+
+	b = uint64(buf[i])
+	i++
+	x += b << 28
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 28
+
+	b = uint64(buf[i])
+	i++
+	x += b << 35
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 35
+
+	b = uint64(buf[i])
+	i++
+	x += b << 42
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 42
+
+	b = uint64(buf[i])
+	i++
+	x += b << 49
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 49
+
+	b = uint64(buf[i])
+	i++
+	x += b << 56
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 56
+
+	b = uint64(buf[i])
+	i++
+	x += b << 63
+	if b&0x80 == 0 {
+		goto done
+	}
+	// x -= 0x80 << 63 // Always zero.
+
+	return 0, ErrOverflow
+
+done:
+	cb.index = i
+	return x, nil
+}
+
+// DecodeTagAndWireType decodes a field tag and wire type from input.
+// This reads a varint and then extracts the two fields from the varint
+// value read.
+func (cb *Buffer) DecodeTagAndWireType() (tag int32, wireType int8, err error) {
+	var v uint64
+	v, err = cb.DecodeVarint()
+	if err != nil {
+		return
+	}
+	// low 7 bits is wire type
+	wireType = int8(v & 7)
+	// rest is int32 tag number
+	v = v >> 3
+	if v > math.MaxInt32 {
+		err = fmt.Errorf("tag number out of range: %d", v)
+		return
+	}
+	tag = int32(v)
+	return
+}
+
+// DecodeFixed64 reads a 64-bit integer from the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (cb *Buffer) DecodeFixed64() (x uint64, err error) {
+	// x, err already 0
+	i := cb.index + 8
+	if i < 0 || i > len(cb.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	cb.index = i
+
+	x = uint64(cb.buf[i-8])
+	x |= uint64(cb.buf[i-7]) << 8
+	x |= uint64(cb.buf[i-6]) << 16
+	x |= uint64(cb.buf[i-5]) << 24
+	x |= uint64(cb.buf[i-4]) << 32
+	x |= uint64(cb.buf[i-3]) << 40
+	x |= uint64(cb.buf[i-2]) << 48
+	x |= uint64(cb.buf[i-1]) << 56
+	return
+}
+
+// DecodeFixed32 reads a 32-bit integer from the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (cb *Buffer) DecodeFixed32() (x uint64, err error) {
+	// x, err already 0
+	i := cb.index + 4
+	if i < 0 || i > len(cb.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	cb.index = i
+
+	x = uint64(cb.buf[i-4])
+	x |= uint64(cb.buf[i-3]) << 8
+	x |= uint64(cb.buf[i-2]) << 16
+	x |= uint64(cb.buf[i-1]) << 24
+	return
+}
+
+// DecodeZigZag32 decodes a signed 32-bit integer from the given
+// zig-zag encoded value.
+func DecodeZigZag32(v uint64) int32 {
+	return int32((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31))
+}
+
+// DecodeZigZag64 decodes a signed 64-bit integer from the given
+// zig-zag encoded value.
+func DecodeZigZag64(v uint64) int64 {
+	return int64((v >> 1) ^ uint64((int64(v&1)<<63)>>63))
+}
+
+// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (cb *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
+	n, err := cb.DecodeVarint()
+	if err != nil {
+		return nil, err
+	}
+
+	nb := int(n)
+	if nb < 0 {
+		return nil, fmt.Errorf("proto: bad byte length %d", nb)
+	}
+	end := cb.index + nb
+	if end < cb.index || end > len(cb.buf) {
+		return nil, io.ErrUnexpectedEOF
+	}
+
+	if !alloc {
+		buf = cb.buf[cb.index:end]
+		cb.index = end
+		return
+	}
+
+	buf = make([]byte, nb)
+	copy(buf, cb.buf[cb.index:])
+	cb.index = end
+	return
+}
+
+// ReadGroup reads the input until a "group end" tag is found
+// and returns the data up to that point. Subsequent reads from
+// the buffer will read data after the group end tag. If alloc
+// is true, the data is copied to a new slice before being returned.
+// Otherwise, the returned slice is a view into the buffer's
+// underlying byte slice.
+//
+// This function correctly handles nested groups: if a "group start"
+// tag is found, then that group's end tag will be included in the
+// returned data.
+func (cb *Buffer) ReadGroup(alloc bool) ([]byte, error) {
+	var groupEnd, dataEnd int
+	groupEnd, dataEnd, err := cb.findGroupEnd()
+	if err != nil {
+		return nil, err
+	}
+	var results []byte
+	if !alloc {
+		results = cb.buf[cb.index:dataEnd]
+	} else {
+		results = make([]byte, dataEnd-cb.index)
+		copy(results, cb.buf[cb.index:])
+	}
+	cb.index = groupEnd
+	return results, nil
+}
+
+// SkipGroup is like ReadGroup, except that it discards the
+// data and just advances the buffer to point to the input
+// right *after* the "group end" tag.
+func (cb *Buffer) SkipGroup() error {
+	groupEnd, _, err := cb.findGroupEnd()
+	if err != nil {
+		return err
+	}
+	cb.index = groupEnd
+	return nil
+}
+
+func (cb *Buffer) findGroupEnd() (groupEnd int, dataEnd int, err error) {
+	bs := cb.buf
+	start := cb.index
+	defer func() {
+		cb.index = start
+	}()
+	for {
+		fieldStart := cb.index
+		// read a field tag
+		_, wireType, err := cb.DecodeTagAndWireType()
+		if err != nil {
+			return 0, 0, err
+		}
+		// skip past the field's data
+		switch wireType {
+		case proto.WireFixed32:
+			if err := cb.Skip(4); err != nil {
+				return 0, 0, err
+			}
+		case proto.WireFixed64:
+			if err := cb.Skip(8); err != nil {
+				return 0, 0, err
+			}
+		case proto.WireVarint:
+			// skip varint by finding last byte (has high bit unset)
+			i := cb.index
+			limit := i + 10 // varint cannot be >10 bytes
+			for {
+				if i >= limit {
+					return 0, 0, ErrOverflow
+				}
+				if i >= len(bs) {
+					return 0, 0, io.ErrUnexpectedEOF
+				}
+				if bs[i]&0x80 == 0 {
+					break
+				}
+				i++
+			}
+			// TODO: This would only overflow if buffer length was MaxInt and we
+			// read the last byte. This is not a real/feasible concern on 64-bit
+			// systems. Something to worry about for 32-bit systems? Do we care?
+			cb.index = i + 1
+		case proto.WireBytes:
+			l, err := cb.DecodeVarint()
+			if err != nil {
+				return 0, 0, err
+			}
+			if err := cb.Skip(int(l)); err != nil {
+				return 0, 0, err
+			}
+		case proto.WireStartGroup:
+			if err := cb.SkipGroup(); err != nil {
+				return 0, 0, err
+			}
+		case proto.WireEndGroup:
+			return cb.index, fieldStart, nil
+		default:
+			return 0, 0, ErrBadWireType
+		}
+	}
+}
diff --git a/vendor/github.com/jhump/protoreflect/codec/decode_fields.go b/vendor/github.com/jhump/protoreflect/codec/decode_fields.go
new file mode 100644
index 0000000..938b4d9
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/codec/decode_fields.go
@@ -0,0 +1,283 @@
+package codec
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"math"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+	"github.com/jhump/protoreflect/desc"
+)
+
+// ErrWireTypeEndGroup is returned from DecodeFieldValue if the tag and wire-type
+// it reads indicates an end-group marker.
+var ErrWireTypeEndGroup = errors.New("unexpected wire type: end group")
+
+// MessageFactory is used to instantiate messages when DecodeFieldValue needs to
+// decode a message value.
+//
+// Also see MessageFactory in "github.com/jhump/protoreflect/dynamic", which
+// implements this interface.
+type MessageFactory interface {
+	NewMessage(md *desc.MessageDescriptor) proto.Message
+}
+
+// UnknownField represents a field that was parsed from the binary wire
+// format for a message, but was not a recognized field number. Enough
+// information is preserved so that re-serializing the message won't lose
+// any of the unrecognized data.
+type UnknownField struct {
+	// The tag number for the unrecognized field.
+	Tag int32
+
+	// Encoding indicates how the unknown field was encoded on the wire. If it
+	// is proto.WireBytes or proto.WireGroupStart then Contents will be set to
+	// the raw bytes. If it is proto.WireTypeFixed32 then the data is in the least
+	// significant 32 bits of Value. Otherwise, the data is in all 64 bits of
+	// Value.
+	Encoding int8
+	Contents []byte
+	Value    uint64
+}
+
+// DecodeFieldValue will read a field value from the buffer and return its
+// value and the corresponding field descriptor. The given function is used
+// to lookup a field descriptor by tag number. The given factory is used to
+// instantiate a message if the field value is (or contains) a message value.
+//
+// On error, the field descriptor and value are typically nil. However, if the
+// error returned is ErrWireTypeEndGroup, the returned value will indicate any
+// tag number encoded in the end-group marker.
+//
+// If the field descriptor returned is nil, that means that the given function
+// returned nil. This is expected to happen for unrecognized tag numbers. In
+// that case, no error is returned, and the value will be an UnknownField.
+func (cb *Buffer) DecodeFieldValue(fieldFinder func(int32) *desc.FieldDescriptor, fact MessageFactory) (*desc.FieldDescriptor, interface{}, error) {
+	if cb.EOF() {
+		return nil, nil, io.EOF
+	}
+	tagNumber, wireType, err := cb.DecodeTagAndWireType()
+	if err != nil {
+		return nil, nil, err
+	}
+	if wireType == proto.WireEndGroup {
+		return nil, tagNumber, ErrWireTypeEndGroup
+	}
+	fd := fieldFinder(tagNumber)
+	if fd == nil {
+		val, err := cb.decodeUnknownField(tagNumber, wireType)
+		return nil, val, err
+	}
+	val, err := cb.decodeKnownField(fd, wireType, fact)
+	return fd, val, err
+}
+
+// DecodeScalarField extracts a properly-typed value from v. The returned value's
+// type depends on the given field descriptor type. It will be the same type as
+// generated structs use for the field descriptor's type. Enum types will return
+// an int32. If the given field type uses length-delimited encoding (nested
+// messages, bytes, and strings), an error is returned.
+func DecodeScalarField(fd *desc.FieldDescriptor, v uint64) (interface{}, error) {
+	switch fd.GetType() {
+	case descriptor.FieldDescriptorProto_TYPE_BOOL:
+		return v != 0, nil
+	case descriptor.FieldDescriptorProto_TYPE_UINT32,
+		descriptor.FieldDescriptorProto_TYPE_FIXED32:
+		if v > math.MaxUint32 {
+			return nil, ErrOverflow
+		}
+		return uint32(v), nil
+
+	case descriptor.FieldDescriptorProto_TYPE_INT32,
+		descriptor.FieldDescriptorProto_TYPE_ENUM:
+		s := int64(v)
+		if s > math.MaxInt32 || s < math.MinInt32 {
+			return nil, ErrOverflow
+		}
+		return int32(s), nil
+
+	case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
+		if v > math.MaxUint32 {
+			return nil, ErrOverflow
+		}
+		return int32(v), nil
+
+	case descriptor.FieldDescriptorProto_TYPE_SINT32:
+		if v > math.MaxUint32 {
+			return nil, ErrOverflow
+		}
+		return DecodeZigZag32(v), nil
+
+	case descriptor.FieldDescriptorProto_TYPE_UINT64,
+		descriptor.FieldDescriptorProto_TYPE_FIXED64:
+		return v, nil
+
+	case descriptor.FieldDescriptorProto_TYPE_INT64,
+		descriptor.FieldDescriptorProto_TYPE_SFIXED64:
+		return int64(v), nil
+
+	case descriptor.FieldDescriptorProto_TYPE_SINT64:
+		return DecodeZigZag64(v), nil
+
+	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
+		if v > math.MaxUint32 {
+			return nil, ErrOverflow
+		}
+		return math.Float32frombits(uint32(v)), nil
+
+	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
+		return math.Float64frombits(v), nil
+
+	default:
+		// bytes, string, message, and group cannot be represented as a simple numeric value
+		return nil, fmt.Errorf("bad input; field %s requires length-delimited wire type", fd.GetFullyQualifiedName())
+	}
+}
+
+// DecodeLengthDelimitedField extracts a properly-typed value from bytes. The
+// returned value's type will usually be []byte, string, or, for nested messages,
+// the type returned from the given message factory. However, since repeated
+// scalar fields can be length-delimited, when they used packed encoding, it can
+// also return an []interface{}, where each element is a scalar value. Furthermore,
+// it could return a scalar type, not in a slice, if the given field descriptor is
+// not repeated. This is to support cases where a field is changed from optional
+// to repeated. New code may emit a packed repeated representation, but old code
+// still expects a single scalar value. In this case, if the actual data in bytes
+// contains multiple values, only the last value is returned.
+func DecodeLengthDelimitedField(fd *desc.FieldDescriptor, bytes []byte, mf MessageFactory) (interface{}, error) {
+	switch {
+	case fd.GetType() == descriptor.FieldDescriptorProto_TYPE_BYTES:
+		return bytes, nil
+
+	case fd.GetType() == descriptor.FieldDescriptorProto_TYPE_STRING:
+		return string(bytes), nil
+
+	case fd.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE ||
+		fd.GetType() == descriptor.FieldDescriptorProto_TYPE_GROUP:
+		msg := mf.NewMessage(fd.GetMessageType())
+		err := proto.Unmarshal(bytes, msg)
+		if err != nil {
+			return nil, err
+		} else {
+			return msg, nil
+		}
+
+	default:
+		// even if the field is not repeated or not packed, we still parse it as such for
+		// backwards compatibility (e.g. message we are de-serializing could have been both
+		// repeated and packed at the time of serialization)
+		packedBuf := NewBuffer(bytes)
+		var slice []interface{}
+		var val interface{}
+		for !packedBuf.EOF() {
+			var v uint64
+			var err error
+			if varintTypes[fd.GetType()] {
+				v, err = packedBuf.DecodeVarint()
+			} else if fixed32Types[fd.GetType()] {
+				v, err = packedBuf.DecodeFixed32()
+			} else if fixed64Types[fd.GetType()] {
+				v, err = packedBuf.DecodeFixed64()
+			} else {
+				return nil, fmt.Errorf("bad input; cannot parse length-delimited wire type for field %s", fd.GetFullyQualifiedName())
+			}
+			if err != nil {
+				return nil, err
+			}
+			val, err = DecodeScalarField(fd, v)
+			if err != nil {
+				return nil, err
+			}
+			if fd.IsRepeated() {
+				slice = append(slice, val)
+			}
+		}
+		if fd.IsRepeated() {
+			return slice, nil
+		} else {
+			// if not a repeated field, last value wins
+			return val, nil
+		}
+	}
+}
+
+func (b *Buffer) decodeKnownField(fd *desc.FieldDescriptor, encoding int8, fact MessageFactory) (interface{}, error) {
+	var val interface{}
+	var err error
+	switch encoding {
+	case proto.WireFixed32:
+		var num uint64
+		num, err = b.DecodeFixed32()
+		if err == nil {
+			val, err = DecodeScalarField(fd, num)
+		}
+	case proto.WireFixed64:
+		var num uint64
+		num, err = b.DecodeFixed64()
+		if err == nil {
+			val, err = DecodeScalarField(fd, num)
+		}
+	case proto.WireVarint:
+		var num uint64
+		num, err = b.DecodeVarint()
+		if err == nil {
+			val, err = DecodeScalarField(fd, num)
+		}
+
+	case proto.WireBytes:
+		alloc := fd.GetType() == descriptor.FieldDescriptorProto_TYPE_BYTES
+		var raw []byte
+		raw, err = b.DecodeRawBytes(alloc)
+		if err == nil {
+			val, err = DecodeLengthDelimitedField(fd, raw, fact)
+		}
+
+	case proto.WireStartGroup:
+		if fd.GetMessageType() == nil {
+			return nil, fmt.Errorf("cannot parse field %s from group-encoded wire type", fd.GetFullyQualifiedName())
+		}
+		msg := fact.NewMessage(fd.GetMessageType())
+		var data []byte
+		data, err = b.ReadGroup(false)
+		if err == nil {
+			err = proto.Unmarshal(data, msg)
+			if err == nil {
+				val = msg
+			}
+		}
+
+	default:
+		return nil, ErrBadWireType
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return val, nil
+}
+
+func (b *Buffer) decodeUnknownField(tagNumber int32, encoding int8) (interface{}, error) {
+	u := UnknownField{Tag: tagNumber, Encoding: encoding}
+	var err error
+	switch encoding {
+	case proto.WireFixed32:
+		u.Value, err = b.DecodeFixed32()
+	case proto.WireFixed64:
+		u.Value, err = b.DecodeFixed64()
+	case proto.WireVarint:
+		u.Value, err = b.DecodeVarint()
+	case proto.WireBytes:
+		u.Contents, err = b.DecodeRawBytes(true)
+	case proto.WireStartGroup:
+		u.Contents, err = b.ReadGroup(true)
+	default:
+		err = ErrBadWireType
+	}
+	if err != nil {
+		return nil, err
+	}
+	return u, nil
+}
diff --git a/vendor/github.com/jhump/protoreflect/codec/doc.go b/vendor/github.com/jhump/protoreflect/codec/doc.go
new file mode 100644
index 0000000..f76499f
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/codec/doc.go
@@ -0,0 +1,7 @@
+// Package codec contains a reader/write type that assists with encoding
+// and decoding protobuf's binary representation.
+//
+// The code in this package began as a fork of proto.Buffer but provides
+// additional API to make it more useful to code that needs to dynamically
+// process or produce the protobuf binary format.
+package codec
diff --git a/vendor/github.com/jhump/protoreflect/codec/encode.go b/vendor/github.com/jhump/protoreflect/codec/encode.go
new file mode 100644
index 0000000..c84523f
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/codec/encode.go
@@ -0,0 +1,163 @@
+package codec
+
+import "github.com/golang/protobuf/proto"
+
+// EncodeVarint writes a varint-encoded integer to the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (cb *Buffer) EncodeVarint(x uint64) error {
+	for x >= 1<<7 {
+		cb.buf = append(cb.buf, uint8(x&0x7f|0x80))
+		x >>= 7
+	}
+	cb.buf = append(cb.buf, uint8(x))
+	return nil
+}
+
+// EncodeTagAndWireType encodes the given field tag and wire type to the
+// buffer. This combines the two values and then writes them as a varint.
+func (cb *Buffer) EncodeTagAndWireType(tag int32, wireType int8) error {
+	v := uint64((int64(tag) << 3) | int64(wireType))
+	return cb.EncodeVarint(v)
+}
+
+// EncodeFixed64 writes a 64-bit integer to the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (cb *Buffer) EncodeFixed64(x uint64) error {
+	cb.buf = append(cb.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24),
+		uint8(x>>32),
+		uint8(x>>40),
+		uint8(x>>48),
+		uint8(x>>56))
+	return nil
+}
+
+// EncodeFixed32 writes a 32-bit integer to the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (cb *Buffer) EncodeFixed32(x uint64) error {
+	cb.buf = append(cb.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24))
+	return nil
+}
+
+// EncodeZigZag64 does zig-zag encoding to convert the given
+// signed 64-bit integer into a form that can be expressed
+// efficiently as a varint, even for negative values.
+func EncodeZigZag64(v int64) uint64 {
+	return (uint64(v) << 1) ^ uint64(v>>63)
+}
+
+// EncodeZigZag32 does zig-zag encoding to convert the given
+// signed 32-bit integer into a form that can be expressed
+// efficiently as a varint, even for negative values.
+func EncodeZigZag32(v int32) uint64 {
+	return uint64((uint32(v) << 1) ^ uint32((v >> 31)))
+}
+
+// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (cb *Buffer) EncodeRawBytes(b []byte) error {
+	if err := cb.EncodeVarint(uint64(len(b))); err != nil {
+		return err
+	}
+	cb.buf = append(cb.buf, b...)
+	return nil
+}
+
+// EncodeMessage writes the given message to the buffer.
+func (cb *Buffer) EncodeMessage(pm proto.Message) error {
+	bytes, err := marshalMessage(cb.buf, pm, cb.deterministic)
+	if err != nil {
+		return err
+	}
+	cb.buf = bytes
+	return nil
+}
+
+// EncodeDelimitedMessage writes the given message to the buffer with a
+// varint-encoded length prefix (the delimiter).
+func (cb *Buffer) EncodeDelimitedMessage(pm proto.Message) error {
+	bytes, err := marshalMessage(cb.tmp, pm, cb.deterministic)
+	if err != nil {
+		return err
+	}
+	// save truncated buffer if it was grown (so we can re-use it and
+	// curtail future allocations)
+	if cap(bytes) > cap(cb.tmp) {
+		cb.tmp = bytes[:0]
+	}
+	return cb.EncodeRawBytes(bytes)
+}
+
+func marshalMessage(b []byte, pm proto.Message, deterministic bool) ([]byte, error) {
+	// we try to use the most efficient way to marshal to existing slice
+	nm, ok := pm.(interface {
+		// this interface is implemented by generated messages
+		XXX_Size() int
+		XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
+	})
+	if ok {
+		sz := nm.XXX_Size()
+		if cap(b) < len(b)+sz {
+			// re-allocate to fit
+			bytes := make([]byte, len(b), len(b)+sz)
+			copy(bytes, b)
+			b = bytes
+		}
+		return nm.XXX_Marshal(b, deterministic)
+	}
+
+	if deterministic {
+		// see if the message has custom deterministic methods, preferring an
+		// "append" method over one that must always re-allocate
+		madm, ok := pm.(interface {
+			MarshalAppendDeterministic(b []byte) ([]byte, error)
+		})
+		if ok {
+			return madm.MarshalAppendDeterministic(b)
+		}
+
+		mdm, ok := pm.(interface {
+			MarshalDeterministic() ([]byte, error)
+		})
+		if ok {
+			bytes, err := mdm.MarshalDeterministic()
+			if err != nil {
+				return nil, err
+			}
+			if len(b) == 0 {
+				return bytes, nil
+			}
+			return append(b, bytes...), nil
+		}
+	}
+
+	mam, ok := pm.(interface {
+		// see if we can append the message, vs. having to re-allocate
+		MarshalAppend(b []byte) ([]byte, error)
+	})
+	if ok {
+		return mam.MarshalAppend(b)
+	}
+
+	// lowest common denominator
+	bytes, err := proto.Marshal(pm)
+	if err != nil {
+		return nil, err
+	}
+	if len(b) == 0 {
+		return bytes, nil
+	}
+	return append(b, bytes...), nil
+}
diff --git a/vendor/github.com/jhump/protoreflect/codec/encode_fields.go b/vendor/github.com/jhump/protoreflect/codec/encode_fields.go
new file mode 100644
index 0000000..cda7299
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/codec/encode_fields.go
@@ -0,0 +1,267 @@
+package codec
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+	"github.com/jhump/protoreflect/desc"
+)
+
+func (cb *Buffer) EncodeFieldValue(fd *desc.FieldDescriptor, val interface{}) error {
+	if fd.IsMap() {
+		mp := val.(map[interface{}]interface{})
+		entryType := fd.GetMessageType()
+		keyType := entryType.FindFieldByNumber(1)
+		valType := entryType.FindFieldByNumber(2)
+		var entryBuffer Buffer
+		if cb.deterministic {
+			keys := make([]interface{}, 0, len(mp))
+			for k := range mp {
+				keys = append(keys, k)
+			}
+			sort.Sort(sortable(keys))
+			for _, k := range keys {
+				v := mp[k]
+				entryBuffer.Reset()
+				if err := entryBuffer.encodeFieldElement(keyType, k); err != nil {
+					return err
+				}
+				if err := entryBuffer.encodeFieldElement(valType, v); err != nil {
+					return err
+				}
+				if err := cb.EncodeTagAndWireType(fd.GetNumber(), proto.WireBytes); err != nil {
+					return err
+				}
+				if err := cb.EncodeRawBytes(entryBuffer.Bytes()); err != nil {
+					return err
+				}
+			}
+		} else {
+			for k, v := range mp {
+				entryBuffer.Reset()
+				if err := entryBuffer.encodeFieldElement(keyType, k); err != nil {
+					return err
+				}
+				if err := entryBuffer.encodeFieldElement(valType, v); err != nil {
+					return err
+				}
+				if err := cb.EncodeTagAndWireType(fd.GetNumber(), proto.WireBytes); err != nil {
+					return err
+				}
+				if err := cb.EncodeRawBytes(entryBuffer.Bytes()); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	} else if fd.IsRepeated() {
+		sl := val.([]interface{})
+		wt, err := getWireType(fd.GetType())
+		if err != nil {
+			return err
+		}
+		if isPacked(fd) && len(sl) > 1 &&
+			(wt == proto.WireVarint || wt == proto.WireFixed32 || wt == proto.WireFixed64) {
+			// packed repeated field
+			var packedBuffer Buffer
+			for _, v := range sl {
+				if err := packedBuffer.encodeFieldValue(fd, v); err != nil {
+					return err
+				}
+			}
+			if err := cb.EncodeTagAndWireType(fd.GetNumber(), proto.WireBytes); err != nil {
+				return err
+			}
+			return cb.EncodeRawBytes(packedBuffer.Bytes())
+		} else {
+			// non-packed repeated field
+			for _, v := range sl {
+				if err := cb.encodeFieldElement(fd, v); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+	} else {
+		return cb.encodeFieldElement(fd, val)
+	}
+}
+
+func isPacked(fd *desc.FieldDescriptor) bool {
+	opts := fd.AsFieldDescriptorProto().GetOptions()
+	// if set, use that value
+	if opts != nil && opts.Packed != nil {
+		return opts.GetPacked()
+	}
+	// if unset: proto2 defaults to false, proto3 to true
+	return fd.GetFile().IsProto3()
+}
+
+// sortable is used to sort map keys. Values will be integers (int32, int64, uint32, and uint64),
+// bools, or strings.
+type sortable []interface{}
+
+func (s sortable) Len() int {
+	return len(s)
+}
+
+func (s sortable) Less(i, j int) bool {
+	vi := s[i]
+	vj := s[j]
+	switch reflect.TypeOf(vi).Kind() {
+	case reflect.Int32:
+		return vi.(int32) < vj.(int32)
+	case reflect.Int64:
+		return vi.(int64) < vj.(int64)
+	case reflect.Uint32:
+		return vi.(uint32) < vj.(uint32)
+	case reflect.Uint64:
+		return vi.(uint64) < vj.(uint64)
+	case reflect.String:
+		return vi.(string) < vj.(string)
+	case reflect.Bool:
+		return !vi.(bool) && vj.(bool)
+	default:
+		panic(fmt.Sprintf("cannot compare keys of type %v", reflect.TypeOf(vi)))
+	}
+}
+
+func (s sortable) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (b *Buffer) encodeFieldElement(fd *desc.FieldDescriptor, val interface{}) error {
+	wt, err := getWireType(fd.GetType())
+	if err != nil {
+		return err
+	}
+	if err := b.EncodeTagAndWireType(fd.GetNumber(), wt); err != nil {
+		return err
+	}
+	if err := b.encodeFieldValue(fd, val); err != nil {
+		return err
+	}
+	if wt == proto.WireStartGroup {
+		return b.EncodeTagAndWireType(fd.GetNumber(), proto.WireEndGroup)
+	}
+	return nil
+}
+
+func (b *Buffer) encodeFieldValue(fd *desc.FieldDescriptor, val interface{}) error {
+	switch fd.GetType() {
+	case descriptor.FieldDescriptorProto_TYPE_BOOL:
+		v := val.(bool)
+		if v {
+			return b.EncodeVarint(1)
+		}
+		return b.EncodeVarint(0)
+
+	case descriptor.FieldDescriptorProto_TYPE_ENUM,
+		descriptor.FieldDescriptorProto_TYPE_INT32:
+		v := val.(int32)
+		return b.EncodeVarint(uint64(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
+		v := val.(int32)
+		return b.EncodeFixed32(uint64(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_SINT32:
+		v := val.(int32)
+		return b.EncodeVarint(EncodeZigZag32(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_UINT32:
+		v := val.(uint32)
+		return b.EncodeVarint(uint64(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_FIXED32:
+		v := val.(uint32)
+		return b.EncodeFixed32(uint64(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_INT64:
+		v := val.(int64)
+		return b.EncodeVarint(uint64(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_SFIXED64:
+		v := val.(int64)
+		return b.EncodeFixed64(uint64(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_SINT64:
+		v := val.(int64)
+		return b.EncodeVarint(EncodeZigZag64(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_UINT64:
+		v := val.(uint64)
+		return b.EncodeVarint(v)
+
+	case descriptor.FieldDescriptorProto_TYPE_FIXED64:
+		v := val.(uint64)
+		return b.EncodeFixed64(v)
+
+	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
+		v := val.(float64)
+		return b.EncodeFixed64(math.Float64bits(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
+		v := val.(float32)
+		return b.EncodeFixed32(uint64(math.Float32bits(v)))
+
+	case descriptor.FieldDescriptorProto_TYPE_BYTES:
+		v := val.([]byte)
+		return b.EncodeRawBytes(v)
+
+	case descriptor.FieldDescriptorProto_TYPE_STRING:
+		v := val.(string)
+		return b.EncodeRawBytes(([]byte)(v))
+
+	case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
+		return b.EncodeDelimitedMessage(val.(proto.Message))
+
+	case descriptor.FieldDescriptorProto_TYPE_GROUP:
+		// just append the nested message to this buffer
+		return b.EncodeMessage(val.(proto.Message))
+		// whosoever writeth start-group tag (e.g. caller) is responsible for writing end-group tag
+
+	default:
+		return fmt.Errorf("unrecognized field type: %v", fd.GetType())
+	}
+}
+
+func getWireType(t descriptor.FieldDescriptorProto_Type) (int8, error) {
+	switch t {
+	case descriptor.FieldDescriptorProto_TYPE_ENUM,
+		descriptor.FieldDescriptorProto_TYPE_BOOL,
+		descriptor.FieldDescriptorProto_TYPE_INT32,
+		descriptor.FieldDescriptorProto_TYPE_SINT32,
+		descriptor.FieldDescriptorProto_TYPE_UINT32,
+		descriptor.FieldDescriptorProto_TYPE_INT64,
+		descriptor.FieldDescriptorProto_TYPE_SINT64,
+		descriptor.FieldDescriptorProto_TYPE_UINT64:
+		return proto.WireVarint, nil
+
+	case descriptor.FieldDescriptorProto_TYPE_FIXED32,
+		descriptor.FieldDescriptorProto_TYPE_SFIXED32,
+		descriptor.FieldDescriptorProto_TYPE_FLOAT:
+		return proto.WireFixed32, nil
+
+	case descriptor.FieldDescriptorProto_TYPE_FIXED64,
+		descriptor.FieldDescriptorProto_TYPE_SFIXED64,
+		descriptor.FieldDescriptorProto_TYPE_DOUBLE:
+		return proto.WireFixed64, nil
+
+	case descriptor.FieldDescriptorProto_TYPE_BYTES,
+		descriptor.FieldDescriptorProto_TYPE_STRING,
+		descriptor.FieldDescriptorProto_TYPE_MESSAGE:
+		return proto.WireBytes, nil
+
+	case descriptor.FieldDescriptorProto_TYPE_GROUP:
+		return proto.WireStartGroup, nil
+
+	default:
+		return 0, ErrBadWireType
+	}
+}
diff --git a/vendor/github.com/jhump/protoreflect/desc/convert.go b/vendor/github.com/jhump/protoreflect/desc/convert.go
index 6573c90..538820c 100644
--- a/vendor/github.com/jhump/protoreflect/desc/convert.go
+++ b/vendor/github.com/jhump/protoreflect/desc/convert.go
@@ -166,16 +166,31 @@
 }
 
 func createFileDescriptorFromSet(fds *dpb.FileDescriptorSet, r *ImportResolver) (*FileDescriptor, error) {
+	result, err := createFileDescriptorsFromSet(fds, r)
+	if err != nil {
+		return nil, err
+	}
+	files := fds.GetFile()
+	lastFilename := files[len(files)-1].GetName()
+	return result[lastFilename], nil
+}
+
+// CreateFileDescriptorsFromSet creates file descriptors from the given file descriptor set.
+// The returned map includes all files in the set, keyed b name. The set must include the
+// full set of transitive dependencies for all files therein or else a link error will occur
+// and be returned instead of the slice of descriptors. This is the same format used by
+// protoc when a FileDescriptorSet file with an invocation like so:
+//    protoc --descriptor_set_out=./test.protoset --include_imports -I. test.proto
+func CreateFileDescriptorsFromSet(fds *dpb.FileDescriptorSet) (map[string]*FileDescriptor, error) {
+	return createFileDescriptorsFromSet(fds, nil)
+}
+
+func createFileDescriptorsFromSet(fds *dpb.FileDescriptorSet, r *ImportResolver) (map[string]*FileDescriptor, error) {
 	files := fds.GetFile()
 	if len(files) == 0 {
 		return nil, errors.New("file descriptor set is empty")
 	}
-	resolved, err := createFileDescriptors(files, r)
-	if err != nil {
-		return nil, err
-	}
-	lastFilename := files[len(files)-1].GetName()
-	return resolved[lastFilename], nil
+	return createFileDescriptors(files, r)
 }
 
 // createFromSet creates a descriptor for the given filename. It recursively
diff --git a/vendor/github.com/jhump/protoreflect/desc/descriptor_no_unsafe.go b/vendor/github.com/jhump/protoreflect/desc/descriptor_no_unsafe.go
index d8e2df0..cd7348e 100644
--- a/vendor/github.com/jhump/protoreflect/desc/descriptor_no_unsafe.go
+++ b/vendor/github.com/jhump/protoreflect/desc/descriptor_no_unsafe.go
@@ -1,5 +1,6 @@
-//+build appengine
-// TODO: other build tags for environments where unsafe package is inappropriate
+//+build appengine gopherjs purego
+// NB: other environments where unsafe is unappropriate should use "purego" build tag
+// https://github.com/golang/go/issues/23172
 
 package desc
 
diff --git a/vendor/github.com/jhump/protoreflect/desc/descriptor_unsafe.go b/vendor/github.com/jhump/protoreflect/desc/descriptor_unsafe.go
index 6ff872f..19b808d 100644
--- a/vendor/github.com/jhump/protoreflect/desc/descriptor_unsafe.go
+++ b/vendor/github.com/jhump/protoreflect/desc/descriptor_unsafe.go
@@ -1,5 +1,6 @@
-//+build !appengine
-// TODO: exclude other build tags for environments where unsafe package is inappropriate
+//+build !appengine,!gopherjs,!purego
+// NB: other environments where unsafe is unappropriate should use "purego" build tag
+// https://github.com/golang/go/issues/23172
 
 package desc
 
diff --git a/vendor/github.com/jhump/protoreflect/desc/imports.go b/vendor/github.com/jhump/protoreflect/desc/imports.go
index caf3277..ab93032 100644
--- a/vendor/github.com/jhump/protoreflect/desc/imports.go
+++ b/vendor/github.com/jhump/protoreflect/desc/imports.go
@@ -292,6 +292,13 @@
 	return createFileDescriptorFromSet(fds, r)
 }
 
+// CreateFileDescriptorsFromSet is the same as the package function of the same
+// name, but any alternate paths configured in this resolver are used when
+// linking the descriptor protos in the given set.
+func (r *ImportResolver) CreateFileDescriptorsFromSet(fds *dpb.FileDescriptorSet) (map[string]*FileDescriptor, error) {
+	return createFileDescriptorsFromSet(fds, r)
+}
+
 const dotPrefix = "." + string(filepath.Separator)
 
 func clean(path string) string {
diff --git a/vendor/github.com/jhump/protoreflect/desc/internal/source_info.go b/vendor/github.com/jhump/protoreflect/desc/internal/source_info.go
index 4d7dbae..b4150b8 100644
--- a/vendor/github.com/jhump/protoreflect/desc/internal/source_info.go
+++ b/vendor/github.com/jhump/protoreflect/desc/internal/source_info.go
@@ -6,16 +6,26 @@
 
 // SourceInfoMap is a map of paths in a descriptor to the corresponding source
 // code info.
-type SourceInfoMap map[string]*dpb.SourceCodeInfo_Location
+type SourceInfoMap map[string][]*dpb.SourceCodeInfo_Location
 
-// Get returns the source code info for the given path.
+// Get returns the source code info for the given path. If there are
+// multiple locations for the same path, the first one is returned.
 func (m SourceInfoMap) Get(path []int32) *dpb.SourceCodeInfo_Location {
+	v := m[asMapKey(path)]
+	if len(v) > 0 {
+		return v[0]
+	}
+	return nil
+}
+
+// GetAll returns all source code info for the given path.
+func (m SourceInfoMap) GetAll(path []int32) []*dpb.SourceCodeInfo_Location {
 	return m[asMapKey(path)]
 }
 
-// Put stores the given source code info for the given path.
-func (m SourceInfoMap) Put(path []int32, loc *dpb.SourceCodeInfo_Location) {
-	m[asMapKey(path)] = loc
+// Add stores the given source code info for the given path.
+func (m SourceInfoMap) Add(path []int32, loc *dpb.SourceCodeInfo_Location) {
+	m[asMapKey(path)] = append(m[asMapKey(path)], loc)
 }
 
 // PutIfAbsent stores the given source code info for the given path only if the
@@ -26,7 +36,7 @@
 	if _, ok := m[k]; ok {
 		return false
 	}
-	m[k] = loc
+	m[k] = []*dpb.SourceCodeInfo_Location{loc}
 	return true
 }
 
@@ -40,12 +50,13 @@
 	//return array.Interface()
 
 	b := make([]byte, len(slice)*4)
-	for i, s := range slice {
-		j := i * 4
+	j := 0
+	for _, s := range slice {
 		b[j] = byte(s)
 		b[j+1] = byte(s >> 8)
 		b[j+2] = byte(s >> 16)
 		b[j+3] = byte(s >> 24)
+		j += 4
 	}
 	return string(b)
 }
@@ -62,7 +73,7 @@
 // the given file descriptor.
 func PopulateSourceInfoMap(fd *dpb.FileDescriptorProto, m SourceInfoMap) {
 	for _, l := range fd.GetSourceCodeInfo().GetLocation() {
-		m.Put(l.Path, l)
+		m.Add(l.Path, l)
 	}
 }
 
diff --git a/vendor/github.com/jhump/protoreflect/desc/internal/util.go b/vendor/github.com/jhump/protoreflect/desc/internal/util.go
index d5197f1..139c9cd 100644
--- a/vendor/github.com/jhump/protoreflect/desc/internal/util.go
+++ b/vendor/github.com/jhump/protoreflect/desc/internal/util.go
@@ -105,6 +105,9 @@
 	// Field_typeTag is the tag number of the type element in a field descriptor
 	// proto.
 	Field_typeTag = 5
+	// Field_typeNameTag is the tag number of the type name element in a field
+	// descriptor proto.
+	Field_typeNameTag = 6
 	// Field_defaultTag is the tag number of the default value element in a
 	// field descriptor proto.
 	Field_defaultTag = 7
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/ast.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/ast.go
index 2499917..e1eb4df 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/ast.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/ast.go
@@ -1,24 +1,7 @@
 package protoparse
 
-import "fmt"
-
 // This file defines all of the nodes in the proto AST.
 
-// ErrorWithSourcePos is an error about a proto source file includes information
-// about the location in the file that caused the error.
-type ErrorWithSourcePos struct {
-	Underlying error
-	Pos        *SourcePos
-}
-
-// Error implements the error interface
-func (e ErrorWithSourcePos) Error() string {
-	if e.Pos.Line <= 0 || e.Pos.Col <= 0 {
-		return fmt.Sprintf("%s: %v", e.Pos.Filename, e.Underlying)
-	}
-	return fmt.Sprintf("%s:%d:%d: %v", e.Pos.Filename, e.Pos.Line, e.Pos.Col, e.Underlying)
-}
-
 // SourcePos identifies a location in a proto source file.
 type SourcePos struct {
 	Filename  string
@@ -30,17 +13,18 @@
 	return &SourcePos{Filename: filename}
 }
 
+// node is the interface implemented by all nodes in the AST
 type node interface {
 	start() *SourcePos
 	end() *SourcePos
-	leadingComments() []*comment
-	trailingComments() []*comment
+	leadingComments() []comment
+	trailingComments() []comment
 }
 
 type terminalNode interface {
 	node
-	popLeadingComment() *comment
-	pushTrailingComment(*comment)
+	popLeadingComment() comment
+	pushTrailingComment(comment)
 }
 
 var _ terminalNode = (*basicNode)(nil)
@@ -103,7 +87,6 @@
 type msgDecl interface {
 	node
 	messageName() node
-	reservedNames() []*stringLiteralNode
 }
 
 var _ msgDecl = (*messageNode)(nil)
@@ -121,38 +104,38 @@
 var _ methodDecl = (*noSourceNode)(nil)
 
 type posRange struct {
-	start, end *SourcePos
+	start, end SourcePos
 }
 
 type basicNode struct {
 	posRange
-	leading  []*comment
-	trailing []*comment
+	leading  []comment
+	trailing []comment
 }
 
 func (n *basicNode) start() *SourcePos {
-	return n.posRange.start
+	return &n.posRange.start
 }
 
 func (n *basicNode) end() *SourcePos {
-	return n.posRange.end
+	return &n.posRange.end
 }
 
-func (n *basicNode) leadingComments() []*comment {
+func (n *basicNode) leadingComments() []comment {
 	return n.leading
 }
 
-func (n *basicNode) trailingComments() []*comment {
+func (n *basicNode) trailingComments() []comment {
 	return n.trailing
 }
 
-func (n *basicNode) popLeadingComment() *comment {
+func (n *basicNode) popLeadingComment() comment {
 	c := n.leading[0]
 	n.leading = n.leading[1:]
 	return c
 }
 
-func (n *basicNode) pushTrailingComment(c *comment) {
+func (n *basicNode) pushTrailingComment(c comment) {
 	n.trailing = append(n.trailing, c)
 }
 
@@ -174,11 +157,11 @@
 	return n.last.end()
 }
 
-func (n *basicCompositeNode) leadingComments() []*comment {
+func (n *basicCompositeNode) leadingComments() []comment {
 	return n.first.leadingComments()
 }
 
-func (n *basicCompositeNode) trailingComments() []*comment {
+func (n *basicCompositeNode) trailingComments() []comment {
 	return n.last.trailingComments()
 }
 
@@ -192,13 +175,9 @@
 	syntax *syntaxNode
 	decls  []*fileElement
 
-	// These fields are populated after parsing, to make it easier to find them
-	// without searching decls. The parse result has a map of descriptors to
-	// nodes which makes the other declarations easily discoverable. But these
-	// elements do not map to descriptors -- they are just stored as strings in
-	// the file descriptor.
+	// This field is populated after parsing, to make it easier to find
+	// source locations by import name for constructing link errors.
 	imports []*importNode
-	pkg     *packageNode
 }
 
 func (n *fileNode) getSyntax() node {
@@ -225,11 +204,11 @@
 	return n.get().end()
 }
 
-func (n *fileElement) leadingComments() []*comment {
+func (n *fileElement) leadingComments() []comment {
 	return n.get().leadingComments()
 }
 
-func (n *fileElement) trailingComments() []*comment {
+func (n *fileElement) trailingComments() []comment {
 	return n.get().trailingComments()
 }
 
@@ -256,41 +235,53 @@
 
 type syntaxNode struct {
 	basicCompositeNode
-	syntax *stringLiteralNode
+	syntax *compoundStringNode
 }
 
 type importNode struct {
 	basicCompositeNode
-	name   *stringLiteralNode
+	name   *compoundStringNode
 	public bool
 	weak   bool
 }
 
 type packageNode struct {
 	basicCompositeNode
-	name *identNode
+	name *compoundIdentNode
 }
 
 type identifier string
 
-type identKind int
-
-const (
-	identSimpleName identKind = iota
-	identQualified
-	identTypeName
-)
-
 type identNode struct {
 	basicNode
-	val  string
-	kind identKind
+	val string
 }
 
 func (n *identNode) value() interface{} {
 	return identifier(n.val)
 }
 
+type compoundIdentNode struct {
+	basicCompositeNode
+	val string
+}
+
+func (n *compoundIdentNode) value() interface{} {
+	return identifier(n.val)
+}
+
+type compactOptionsNode struct {
+	basicCompositeNode
+	decls []*optionNode
+}
+
+func (n *compactOptionsNode) Elements() []*optionNode {
+	if n == nil {
+		return nil
+	}
+	return n.decls
+}
+
 type optionNode struct {
 	basicCompositeNode
 	name *optionNameNode
@@ -312,7 +303,7 @@
 
 type optionNamePartNode struct {
 	basicCompositeNode
-	text        *identNode
+	text        *compoundIdentNode
 	offset      int
 	length      int
 	isExtension bool
@@ -350,17 +341,22 @@
 	value() interface{}
 }
 
+var _ valueNode = (*identNode)(nil)
+var _ valueNode = (*compoundIdentNode)(nil)
 var _ valueNode = (*stringLiteralNode)(nil)
+var _ valueNode = (*compoundStringNode)(nil)
 var _ valueNode = (*intLiteralNode)(nil)
-var _ valueNode = (*negativeIntLiteralNode)(nil)
+var _ valueNode = (*compoundIntNode)(nil)
+var _ valueNode = (*compoundUintNode)(nil)
 var _ valueNode = (*floatLiteralNode)(nil)
+var _ valueNode = (*compoundFloatNode)(nil)
 var _ valueNode = (*boolLiteralNode)(nil)
 var _ valueNode = (*sliceLiteralNode)(nil)
 var _ valueNode = (*aggregateLiteralNode)(nil)
 var _ valueNode = (*noSourceNode)(nil)
 
 type stringLiteralNode struct {
-	basicCompositeNode
+	basicNode
 	val string
 }
 
@@ -368,12 +364,13 @@
 	return n.val
 }
 
-func (n *stringLiteralNode) popLeadingComment() *comment {
-	return n.first.(terminalNode).popLeadingComment()
+type compoundStringNode struct {
+	basicCompositeNode
+	val string
 }
 
-func (n *stringLiteralNode) pushTrailingComment(c *comment) {
-	n.last.(terminalNode).pushTrailingComment(c)
+func (n *compoundStringNode) value() interface{} {
+	return n.val
 }
 
 type intLiteralNode struct {
@@ -385,17 +382,26 @@
 	return n.val
 }
 
-type negativeIntLiteralNode struct {
+type compoundUintNode struct {
+	basicCompositeNode
+	val uint64
+}
+
+func (n *compoundUintNode) value() interface{} {
+	return n.val
+}
+
+type compoundIntNode struct {
 	basicCompositeNode
 	val int64
 }
 
-func (n *negativeIntLiteralNode) value() interface{} {
+func (n *compoundIntNode) value() interface{} {
 	return n.val
 }
 
 type floatLiteralNode struct {
-	basicCompositeNode
+	basicNode
 	val float64
 }
 
@@ -403,16 +409,17 @@
 	return n.val
 }
 
-func (n *floatLiteralNode) popLeadingComment() *comment {
-	return n.first.(terminalNode).popLeadingComment()
+type compoundFloatNode struct {
+	basicCompositeNode
+	val float64
 }
 
-func (n *floatLiteralNode) pushTrailingComment(c *comment) {
-	n.last.(terminalNode).pushTrailingComment(c)
+func (n *compoundFloatNode) value() interface{} {
+	return n.val
 }
 
 type boolLiteralNode struct {
-	basicNode
+	*identNode
 	val bool
 }
 
@@ -446,7 +453,7 @@
 
 type aggregateNameNode struct {
 	basicCompositeNode
-	name        *identNode
+	name        *compoundIdentNode
 	isExtension bool
 }
 
@@ -460,11 +467,11 @@
 
 type fieldNode struct {
 	basicCompositeNode
-	label   *labelNode
-	fldType *identNode
+	label   fieldLabel
+	fldType *compoundIdentNode
 	name    *identNode
 	tag     *intLiteralNode
-	options []*optionNode
+	options *compactOptionsNode
 
 	// This field is populated after parsing, to allow lookup of extendee source
 	// locations when field extendees cannot be linked. (Otherwise, this is just
@@ -477,10 +484,10 @@
 	// proto3 fields and fields inside one-ofs will not have a label and we need
 	// this check in order to return a nil node -- otherwise we'd return a
 	// non-nil node that has a nil pointer value in it :/
-	if n.label == nil {
+	if n.label.identNode == nil {
 		return nil
 	}
-	return n.label
+	return n.label.identNode
 }
 
 func (n *fieldNode) fieldName() node {
@@ -506,8 +513,8 @@
 	return nil
 }
 
-type labelNode struct {
-	basicNode
+type fieldLabel struct {
+	*identNode
 	repeated bool
 	required bool
 }
@@ -515,17 +522,11 @@
 type groupNode struct {
 	basicCompositeNode
 	groupKeyword *identNode
-	label        *labelNode
+	label        fieldLabel
 	name         *identNode
 	tag          *intLiteralNode
 	decls        []*messageElement
 
-	// This field is populated after parsing, to make it easier to find them
-	// without searching decls. The parse result has a map of descriptors to
-	// nodes which makes the other declarations easily discoverable. But these
-	// elements do not map to descriptors -- they are just stored as strings in
-	// the message descriptor.
-	reserved []*stringLiteralNode
 	// This field is populated after parsing, to allow lookup of extendee source
 	// locations when field extendees cannot be linked. (Otherwise, this is just
 	// stored as a string in the field descriptors defined inside the extend
@@ -534,7 +535,11 @@
 }
 
 func (n *groupNode) fieldLabel() node {
-	return n.label
+	if n.label.identNode == nil {
+		// return nil interface to indicate absence, not a typed nil
+		return nil
+	}
+	return n.label.identNode
 }
 
 func (n *groupNode) fieldName() node {
@@ -542,7 +547,7 @@
 }
 
 func (n *groupNode) fieldType() node {
-	return n.name
+	return n.groupKeyword
 }
 
 func (n *groupNode) fieldTag() node {
@@ -564,10 +569,6 @@
 	return n.name
 }
 
-func (n *groupNode) reservedNames() []*stringLiteralNode {
-	return n.reserved
-}
-
 type oneOfNode struct {
 	basicCompositeNode
 	name  *identNode
@@ -578,6 +579,7 @@
 	// a discriminated union: only one field will be set
 	option *optionNode
 	field  *fieldNode
+	group  *groupNode
 	empty  *basicNode
 }
 
@@ -589,11 +591,11 @@
 	return n.get().end()
 }
 
-func (n *oneOfElement) leadingComments() []*comment {
+func (n *oneOfElement) leadingComments() []comment {
 	return n.get().leadingComments()
 }
 
-func (n *oneOfElement) trailingComments() []*comment {
+func (n *oneOfElement) trailingComments() []comment {
 	return n.get().trailingComments()
 }
 
@@ -608,18 +610,23 @@
 	}
 }
 
-type mapFieldNode struct {
+type mapTypeNode struct {
 	basicCompositeNode
 	mapKeyword *identNode
 	keyType    *identNode
-	valueType  *identNode
-	name       *identNode
-	tag        *intLiteralNode
-	options    []*optionNode
+	valueType  *compoundIdentNode
+}
+
+type mapFieldNode struct {
+	basicCompositeNode
+	mapType *mapTypeNode
+	name    *identNode
+	tag     *intLiteralNode
+	options *compactOptionsNode
 }
 
 func (n *mapFieldNode) fieldLabel() node {
-	return n.mapKeyword
+	return nil
 }
 
 func (n *mapFieldNode) fieldName() node {
@@ -627,7 +634,7 @@
 }
 
 func (n *mapFieldNode) fieldType() node {
-	return n.mapKeyword
+	return n.mapType
 }
 
 func (n *mapFieldNode) fieldTag() node {
@@ -646,32 +653,29 @@
 	return n.name
 }
 
-func (n *mapFieldNode) reservedNames() []*stringLiteralNode {
-	return nil
-}
-
 func (n *mapFieldNode) keyField() *syntheticMapField {
-	tag := &intLiteralNode{
-		basicNode: basicNode{
-			posRange: posRange{start: n.keyType.start(), end: n.keyType.end()},
-		},
-		val: 1,
-	}
-	return &syntheticMapField{ident: n.keyType, tag: tag}
+	k := n.mapType.keyType
+	t := &compoundIdentNode{val: k.val}
+	t.setRange(k, k)
+	return newSyntheticMapField(t, 1)
 }
 
 func (n *mapFieldNode) valueField() *syntheticMapField {
+	return newSyntheticMapField(n.mapType.valueType, 2)
+}
+
+func newSyntheticMapField(ident *compoundIdentNode, tagNum uint64) *syntheticMapField {
 	tag := &intLiteralNode{
 		basicNode: basicNode{
-			posRange: posRange{start: n.valueType.start(), end: n.valueType.end()},
+			posRange: posRange{start: *ident.start(), end: *ident.end()},
 		},
-		val: 2,
+		val: tagNum,
 	}
-	return &syntheticMapField{ident: n.valueType, tag: tag}
+	return &syntheticMapField{ident: ident, tag: tag}
 }
 
 type syntheticMapField struct {
-	ident *identNode
+	ident *compoundIdentNode
 	tag   *intLiteralNode
 }
 
@@ -683,11 +687,11 @@
 	return n.ident.end()
 }
 
-func (n *syntheticMapField) leadingComments() []*comment {
+func (n *syntheticMapField) leadingComments() []comment {
 	return nil
 }
 
-func (n *syntheticMapField) trailingComments() []*comment {
+func (n *syntheticMapField) trailingComments() []comment {
 	return nil
 }
 
@@ -718,7 +722,7 @@
 type extensionRangeNode struct {
 	basicCompositeNode
 	ranges  []*rangeNode
-	options []*optionNode
+	options *compactOptionsNode
 }
 
 type rangeNode struct {
@@ -738,20 +742,13 @@
 type reservedNode struct {
 	basicCompositeNode
 	ranges []*rangeNode
-	names  []*stringLiteralNode
+	names  []*compoundStringNode
 }
 
 type enumNode struct {
 	basicCompositeNode
 	name  *identNode
 	decls []*enumElement
-
-	// This field is populated after parsing, to make it easier to find them
-	// without searching decls. The parse result has a map of descriptors to
-	// nodes which makes the other declarations easily discoverable. But these
-	// elements do not map to descriptors -- they are just stored as strings in
-	// the message descriptor.
-	reserved []*stringLiteralNode
 }
 
 type enumElement struct {
@@ -770,11 +767,11 @@
 	return n.get().end()
 }
 
-func (n *enumElement) leadingComments() []*comment {
+func (n *enumElement) leadingComments() []comment {
 	return n.get().leadingComments()
 }
 
-func (n *enumElement) trailingComments() []*comment {
+func (n *enumElement) trailingComments() []comment {
 	return n.get().trailingComments()
 }
 
@@ -792,12 +789,8 @@
 type enumValueNode struct {
 	basicCompositeNode
 	name    *identNode
-	options []*optionNode
-
-	// only one of these two will be set:
-
-	numberP *intLiteralNode         // positive numeric value
-	numberN *negativeIntLiteralNode // negative numeric value
+	options *compactOptionsNode
+	number  *compoundIntNode
 }
 
 func (n *enumValueNode) getName() node {
@@ -805,33 +798,19 @@
 }
 
 func (n *enumValueNode) getNumber() node {
-	if n.numberP != nil {
-		return n.numberP
-	}
-	return n.numberN
+	return n.number
 }
 
 type messageNode struct {
 	basicCompositeNode
 	name  *identNode
 	decls []*messageElement
-
-	// This field is populated after parsing, to make it easier to find them
-	// without searching decls. The parse result has a map of descriptors to
-	// nodes which makes the other declarations easily discoverable. But these
-	// elements do not map to descriptors -- they are just stored as strings in
-	// the message descriptor.
-	reserved []*stringLiteralNode
 }
 
 func (n *messageNode) messageName() node {
 	return n.name
 }
 
-func (n *messageNode) reservedNames() []*stringLiteralNode {
-	return n.reserved
-}
-
 type messageElement struct {
 	// a discriminated union: only one field will be set
 	option         *optionNode
@@ -855,11 +834,11 @@
 	return n.get().end()
 }
 
-func (n *messageElement) leadingComments() []*comment {
+func (n *messageElement) leadingComments() []comment {
 	return n.get().leadingComments()
 }
 
-func (n *messageElement) trailingComments() []*comment {
+func (n *messageElement) trailingComments() []comment {
 	return n.get().trailingComments()
 }
 
@@ -892,7 +871,7 @@
 
 type extendNode struct {
 	basicCompositeNode
-	extendee *identNode
+	extendee *compoundIdentNode
 	decls    []*extendElement
 }
 
@@ -911,11 +890,11 @@
 	return n.get().end()
 }
 
-func (n *extendElement) leadingComments() []*comment {
+func (n *extendElement) leadingComments() []comment {
 	return n.get().leadingComments()
 }
 
-func (n *extendElement) trailingComments() []*comment {
+func (n *extendElement) trailingComments() []comment {
 	return n.get().trailingComments()
 }
 
@@ -951,11 +930,11 @@
 	return n.get().end()
 }
 
-func (n *serviceElement) leadingComments() []*comment {
+func (n *serviceElement) leadingComments() []comment {
 	return n.get().leadingComments()
 }
 
-func (n *serviceElement) trailingComments() []*comment {
+func (n *serviceElement) trailingComments() []comment {
 	return n.get().trailingComments()
 }
 
@@ -988,7 +967,7 @@
 
 type rpcTypeNode struct {
 	basicCompositeNode
-	msgType       *identNode
+	msgType       *compoundIdentNode
 	streamKeyword node
 }
 
@@ -1004,11 +983,11 @@
 	return n.pos
 }
 
-func (n noSourceNode) leadingComments() []*comment {
+func (n noSourceNode) leadingComments() []comment {
 	return nil
 }
 
-func (n noSourceNode) trailingComments() []*comment {
+func (n noSourceNode) trailingComments() []comment {
 	return nil
 }
 
@@ -1064,10 +1043,6 @@
 	return n
 }
 
-func (n noSourceNode) reservedNames() []*stringLiteralNode {
-	return nil
-}
-
 func (n noSourceNode) getInputType() node {
 	return n
 }
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/errors.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/errors.go
new file mode 100644
index 0000000..07a6214
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/errors.go
@@ -0,0 +1,103 @@
+package protoparse
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ErrInvalidSource is a sentinel error that is returned by calls to
+// Parser.ParseFiles and Parser.ParseFilesButDoNotLink in the event that syntax
+// or link errors are encountered, but the parser's configured ErrorReporter
+// always returns nil.
+var ErrInvalidSource = errors.New("parse failed: invalid proto source")
+
+// ErrorReporter is responsible for reporting the given error. If the reporter
+// returns a non-nil error, parsing/linking will abort with that error. If the
+// reporter returns nil, parsing will continue, allowing the parser to try to
+// report as many syntax and/or link errors as it can find.
+type ErrorReporter func(err ErrorWithPos) error
+
+func defaultErrorReporter(err ErrorWithPos) error {
+	// abort parsing after first error encountered
+	return err
+}
+
+type errorHandler struct {
+	reporter     ErrorReporter
+	errsReported bool
+	err          error
+}
+
+func newErrorHandler(reporter ErrorReporter) *errorHandler {
+	if reporter == nil {
+		reporter = defaultErrorReporter
+	}
+	return &errorHandler{
+		reporter: reporter,
+	}
+}
+
+func (h *errorHandler) handleError(err error) error {
+	if h.err != nil {
+		return h.err
+	}
+	if ewp, ok := err.(ErrorWithPos); ok {
+		h.errsReported = true
+		err = h.reporter(ewp)
+	}
+	h.err = err
+	return err
+}
+
+func (h *errorHandler) getError() error {
+	if h.errsReported && h.err == nil {
+		return ErrInvalidSource
+	}
+	return h.err
+}
+
+// ErrorWithPos is an error about a proto source file that includes information
+// about the location in the file that caused the error.
+//
+// The value of Error() will contain both the SourcePos and Underlying error.
+// The value of Unwrap() will only be the Underlying error.
+type ErrorWithPos interface {
+	error
+	GetPosition() SourcePos
+	Unwrap() error
+}
+
+// ErrorWithSourcePos is an error about a proto source file that includes
+// information about the location in the file that caused the error.
+//
+// Errors that include source location information *might* be of this type.
+// However, calling code that is trying to examine errors with location info
+// should instead look for instances of the ErrorWithPos interface, which
+// will find other kinds of errors. This type is only exported for backwards
+// compatibility.
+type ErrorWithSourcePos struct {
+	Underlying error
+	Pos        *SourcePos
+}
+
+// Error implements the error interface
+func (e ErrorWithSourcePos) Error() string {
+	if e.Pos.Line <= 0 || e.Pos.Col <= 0 {
+		return fmt.Sprintf("%s: %v", e.Pos.Filename, e.Underlying)
+	}
+	return fmt.Sprintf("%s:%d:%d: %v", e.Pos.Filename, e.Pos.Line, e.Pos.Col, e.Underlying)
+}
+
+// GetPosition implements the ErrorWithPos interface, supplying a location in
+// proto source that caused the error.
+func (e ErrorWithSourcePos) GetPosition() SourcePos {
+	return *e.Pos
+}
+
+// Unwrap implements the ErrorWithPos interface, supplying the underlying
+// error. This error will not include location information.
+func (e ErrorWithSourcePos) Unwrap() error {
+	return e.Underlying
+}
+
+var _ ErrorWithPos = ErrorWithSourcePos{}
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/lexer.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/lexer.go
index c685e56..b0b5f5b 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/lexer.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/lexer.go
@@ -39,15 +39,13 @@
 
 func lexError(l protoLexer, pos *SourcePos, err string) {
 	pl := l.(*protoLex)
-	if pl.err == nil {
-		pl.err = ErrorWithSourcePos{Underlying: errors.New(err), Pos: pos}
-	}
+	_ = pl.errs.handleError(ErrorWithSourcePos{Underlying: errors.New(err), Pos: pos})
 }
 
 type protoLex struct {
 	filename string
 	input    *runeReader
-	err      error
+	errs     *errorHandler
 	res      *fileNode
 
 	lineNo int
@@ -55,10 +53,23 @@
 	offset int
 
 	prevSym terminalNode
+
+	prevLineNo int
+	prevColNo  int
+	prevOffset int
+	comments   []comment
 }
 
-func newLexer(in io.Reader) *protoLex {
-	return &protoLex{input: &runeReader{rr: bufio.NewReader(in)}}
+func newTestLexer(in io.Reader) *protoLex {
+	return newLexer(in, "test.proto", newErrorHandler(nil))
+}
+
+func newLexer(in io.Reader, filename string, errs *errorHandler) *protoLex {
+	return &protoLex{
+		input:    &runeReader{rr: bufio.NewReader(in)},
+		filename: filename,
+		errs:     errs,
+	}
 }
 
 var keywords = map[string]int{
@@ -106,8 +117,8 @@
 	"returns":    _RETURNS,
 }
 
-func (l *protoLex) cur() *SourcePos {
-	return &SourcePos{
+func (l *protoLex) cur() SourcePos {
+	return SourcePos{
 		Filename: l.filename,
 		Offset:   l.offset,
 		Line:     l.lineNo + 1,
@@ -115,6 +126,25 @@
 	}
 }
 
+func (l *protoLex) adjustPos(consumedChars ...rune) {
+	for _, c := range consumedChars {
+		switch c {
+		case '\n':
+			// new line, back to first column
+			l.colNo = 0
+			l.lineNo++
+		case '\r':
+			// no adjustment
+		case '\t':
+			// advance to next tab stop
+			mod := l.colNo % 8
+			l.colNo += 8 - mod
+		default:
+			l.colNo++
+		}
+	}
+}
+
 func (l *protoLex) prev() *SourcePos {
 	if l.prevSym == nil {
 		return &SourcePos{
@@ -128,131 +158,16 @@
 }
 
 func (l *protoLex) Lex(lval *protoSymType) int {
-	if l.err != nil {
-		// if we are already in a failed state, bail
-		lval.err = l.err
-		return _ERROR
+	if l.errs.err != nil {
+		// if error reporter already returned non-nil error,
+		// we can skip the rest of the input
+		return 0
 	}
 
-	prevLineNo := l.lineNo
-	prevColNo := l.colNo
-	prevOffset := l.offset
-	var comments []*comment
-
-	pos := func() posRange {
-		return posRange{
-			start: &SourcePos{
-				Filename: l.filename,
-				Offset:   prevOffset,
-				Line:     prevLineNo + 1,
-				Col:      prevColNo + 1,
-			},
-			end: l.cur(),
-		}
-	}
-	basic := func() basicNode {
-		return basicNode{
-			posRange: pos(),
-			leading:  comments,
-		}
-	}
-	setPrev := func(n terminalNode) {
-		nStart := n.start().Line
-		if _, ok := n.(*basicNode); ok {
-			// if the node is a simple rune, don't attribute comments to it
-			// HACK: adjusting the start line makes leading comments appear
-			// detached so logic below will naturally associated trailing
-			// comment to previous symbol
-			nStart += 2
-		}
-		if l.prevSym != nil && len(n.leadingComments()) > 0 && l.prevSym.end().Line < nStart {
-			// we may need to re-attribute the first comment to
-			// instead be previous node's trailing comment
-			prevEnd := l.prevSym.end().Line
-			comments := n.leadingComments()
-			c := comments[0]
-			commentStart := c.start.Line
-			if commentStart == prevEnd {
-				// comment is on same line as previous symbol
-				n.popLeadingComment()
-				l.prevSym.pushTrailingComment(c)
-			} else if commentStart == prevEnd+1 {
-				// comment is right after previous symbol; see if it is detached
-				// and if so re-attribute
-				singleLineStyle := strings.HasPrefix(c.text, "//")
-				line := c.end.Line
-				groupEnd := -1
-				for i := 1; i < len(comments); i++ {
-					c := comments[i]
-					newGroup := false
-					if !singleLineStyle || c.start.Line > line+1 {
-						// we've found a gap between comments, which means the
-						// previous comments were detached
-						newGroup = true
-					} else {
-						line = c.end.Line
-						singleLineStyle = strings.HasPrefix(comments[i].text, "//")
-						if !singleLineStyle {
-							// we've found a switch from // comments to /*
-							// consider that a new group which means the
-							// previous comments were detached
-							newGroup = true
-						}
-					}
-					if newGroup {
-						groupEnd = i
-						break
-					}
-				}
-
-				if groupEnd == -1 {
-					// just one group of comments; we'll mark it as a trailing
-					// comment if it immediately follows previous symbol and is
-					// detached from current symbol
-					c1 := comments[0]
-					c2 := comments[len(comments)-1]
-					if c1.start.Line <= prevEnd+1 && c2.end.Line < nStart-1 {
-						groupEnd = len(comments)
-					}
-				}
-
-				for i := 0; i < groupEnd; i++ {
-					l.prevSym.pushTrailingComment(n.popLeadingComment())
-				}
-			}
-		}
-
-		l.prevSym = n
-	}
-	setString := func(val string) {
-		b := basic()
-		lval.str = &stringLiteralNode{val: val}
-		lval.str.setRange(&b, &b)
-		setPrev(lval.str)
-	}
-	setIdent := func(val string, kind identKind) {
-		lval.id = &identNode{basicNode: basic(), val: val, kind: kind}
-		setPrev(lval.id)
-	}
-	setInt := func(val uint64) {
-		lval.ui = &intLiteralNode{basicNode: basic(), val: val}
-		setPrev(lval.ui)
-	}
-	setFloat := func(val float64) {
-		b := basic()
-		lval.f = &floatLiteralNode{val: val}
-		lval.f.setRange(&b, &b)
-		setPrev(lval.f)
-	}
-	setRune := func() {
-		b := basic()
-		lval.b = &b
-		setPrev(lval.b)
-	}
-	setError := func(err error) {
-		lval.err = err
-		l.err = err
-	}
+	l.prevLineNo = l.lineNo
+	l.prevColNo = l.colNo
+	l.prevOffset = l.offset
+	l.comments = nil
 
 	for {
 		c, n, err := l.input.readRune()
@@ -260,58 +175,47 @@
 			// we're not actually returning a rune, but this will associate
 			// accumulated comments as a trailing comment on last symbol
 			// (if appropriate)
-			setRune()
+			l.setRune(lval)
 			return 0
 		} else if err != nil {
-			setError(err)
+			// we don't call setError because we don't want it wrapped
+			// with a source position because it's I/O, not syntax
+			lval.err = err
+			_ = l.errs.handleError(err)
 			return _ERROR
 		}
 
-		prevLineNo = l.lineNo
-		prevColNo = l.colNo
-		prevOffset = l.offset
+		l.prevLineNo = l.lineNo
+		l.prevColNo = l.colNo
+		l.prevOffset = l.offset
 
 		l.offset += n
-		if c == '\n' {
-			l.colNo = 0
-			l.lineNo++
-			continue
-		} else if c == '\r' {
-			continue
-		}
-		l.colNo++
-		if c == ' ' || c == '\t' {
+		l.adjustPos(c)
+		if strings.ContainsRune("\n\r\t ", c) {
 			continue
 		}
 
 		if c == '.' {
-			// tokens that start with a dot include type names and decimal literals
+			// decimal literals could start with a dot
 			cn, _, err := l.input.readRune()
 			if err != nil {
-				setRune()
+				l.setRune(lval)
 				return int(c)
 			}
-			if cn == '_' || (cn >= 'a' && cn <= 'z') || (cn >= 'A' && cn <= 'Z') {
-				l.colNo++
-				token := []rune{c, cn}
-				token = l.readIdentifier(token)
-				setIdent(string(token), identTypeName)
-				return _TYPENAME
-			}
 			if cn >= '0' && cn <= '9' {
-				l.colNo++
+				l.adjustPos(cn)
 				token := []rune{c, cn}
 				token = l.readNumber(token, false, true)
 				f, err := strconv.ParseFloat(string(token), 64)
 				if err != nil {
-					setError(err)
+					l.setError(lval, err)
 					return _ERROR
 				}
-				setFloat(f)
+				l.setFloat(lval, f)
 				return _FLOAT_LIT
 			}
 			l.input.unreadRune(cn)
-			setRune()
+			l.setRune(lval)
 			return int(c)
 		}
 
@@ -320,15 +224,11 @@
 			token := []rune{c}
 			token = l.readIdentifier(token)
 			str := string(token)
-			if strings.Contains(str, ".") {
-				setIdent(str, identQualified)
-				return _FQNAME
-			}
 			if t, ok := keywords[str]; ok {
-				setIdent(str, identSimpleName)
+				l.setIdent(lval, str)
 				return t
 			}
-			setIdent(str, identSimpleName)
+			l.setIdent(lval, str)
 			return _NAME
 		}
 
@@ -337,32 +237,32 @@
 			if c == '0' {
 				cn, _, err := l.input.readRune()
 				if err != nil {
-					setInt(0)
+					l.setInt(lval, 0)
 					return _INT_LIT
 				}
 				if cn == 'x' || cn == 'X' {
 					cnn, _, err := l.input.readRune()
 					if err != nil {
 						l.input.unreadRune(cn)
-						setInt(0)
+						l.setInt(lval, 0)
 						return _INT_LIT
 					}
 					if (cnn >= '0' && cnn <= '9') || (cnn >= 'a' && cnn <= 'f') || (cnn >= 'A' && cnn <= 'F') {
 						// hexadecimal!
-						l.colNo += 2
+						l.adjustPos(cn, cnn)
 						token := []rune{cnn}
 						token = l.readHexNumber(token)
 						ui, err := strconv.ParseUint(string(token), 16, 64)
 						if err != nil {
-							setError(err)
+							l.setError(lval, err)
 							return _ERROR
 						}
-						setInt(ui)
+						l.setInt(lval, ui)
 						return _INT_LIT
 					}
 					l.input.unreadRune(cnn)
 					l.input.unreadRune(cn)
-					setInt(0)
+					l.setInt(lval, 0)
 					return _INT_LIT
 				} else {
 					l.input.unreadRune(cn)
@@ -375,19 +275,19 @@
 				// floating point!
 				f, err := strconv.ParseFloat(numstr, 64)
 				if err != nil {
-					setError(err)
+					l.setError(lval, err)
 					return _ERROR
 				}
-				setFloat(f)
+				l.setFloat(lval, f)
 				return _FLOAT_LIT
 			}
 			// integer! (decimal or octal)
 			ui, err := strconv.ParseUint(numstr, 0, 64)
 			if err != nil {
-				setError(err)
+				l.setError(lval, err)
 				return _ERROR
 			}
-			setInt(ui)
+			l.setInt(lval, ui)
 			return _INT_LIT
 		}
 
@@ -395,10 +295,10 @@
 			// string literal
 			str, err := l.readStringLiteral(c)
 			if err != nil {
-				setError(err)
+				l.setError(lval, err)
 				return _ERROR
 			}
-			setString(str)
+			l.setString(lval, str)
 			return _STRING_LIT
 		}
 
@@ -406,39 +306,159 @@
 			// comment
 			cn, _, err := l.input.readRune()
 			if err != nil {
-				setRune()
+				l.setRune(lval)
 				return int(c)
 			}
 			if cn == '/' {
-				l.colNo++
+				l.adjustPos(cn)
 				hitNewline, txt := l.skipToEndOfLineComment()
-				commentPos := pos()
+				commentPos := l.posRange()
 				commentPos.end.Col++
 				if hitNewline {
-					l.colNo = 0
-					l.lineNo++
+					// we don't do this inside of skipToEndOfLineComment
+					// because we want to know the length of previous
+					// line for calculation above
+					l.adjustPos('\n')
 				}
-				comments = append(comments, &comment{posRange: commentPos, text: txt})
+				l.comments = append(l.comments, comment{posRange: commentPos, text: txt})
 				continue
 			}
 			if cn == '*' {
-				l.colNo++
+				l.adjustPos(cn)
 				if txt, ok := l.skipToEndOfBlockComment(); !ok {
-					setError(errors.New("block comment never terminates, unexpected EOF"))
+					l.setError(lval, errors.New("block comment never terminates, unexpected EOF"))
 					return _ERROR
 				} else {
-					comments = append(comments, &comment{posRange: pos(), text: txt})
+					l.comments = append(l.comments, comment{posRange: l.posRange(), text: txt})
 				}
 				continue
 			}
 			l.input.unreadRune(cn)
 		}
 
-		setRune()
+		l.setRune(lval)
 		return int(c)
 	}
 }
 
+func (l *protoLex) posRange() posRange {
+	return posRange{
+		start: SourcePos{
+			Filename: l.filename,
+			Offset:   l.prevOffset,
+			Line:     l.prevLineNo + 1,
+			Col:      l.prevColNo + 1,
+		},
+		end: l.cur(),
+	}
+}
+
+func (l *protoLex) newBasicNode() basicNode {
+	return basicNode{
+		posRange: l.posRange(),
+		leading:  l.comments,
+	}
+}
+
+func (l *protoLex) setPrev(n terminalNode) {
+	nStart := n.start().Line
+	if _, ok := n.(*basicNode); ok {
+		// if the node is a simple rune, don't attribute comments to it
+		// HACK: adjusting the start line makes leading comments appear
+		// detached so logic below will naturally associated trailing
+		// comment to previous symbol
+		nStart += 2
+	}
+	if l.prevSym != nil && len(n.leadingComments()) > 0 && l.prevSym.end().Line < nStart {
+		// we may need to re-attribute the first comment to
+		// instead be previous node's trailing comment
+		prevEnd := l.prevSym.end().Line
+		comments := n.leadingComments()
+		c := comments[0]
+		commentStart := c.start.Line
+		if commentStart == prevEnd {
+			// comment is on same line as previous symbol
+			n.popLeadingComment()
+			l.prevSym.pushTrailingComment(c)
+		} else if commentStart == prevEnd+1 {
+			// comment is right after previous symbol; see if it is detached
+			// and if so re-attribute
+			singleLineStyle := strings.HasPrefix(c.text, "//")
+			line := c.end.Line
+			groupEnd := -1
+			for i := 1; i < len(comments); i++ {
+				c := comments[i]
+				newGroup := false
+				if !singleLineStyle || c.start.Line > line+1 {
+					// we've found a gap between comments, which means the
+					// previous comments were detached
+					newGroup = true
+				} else {
+					line = c.end.Line
+					singleLineStyle = strings.HasPrefix(comments[i].text, "//")
+					if !singleLineStyle {
+						// we've found a switch from // comments to /*
+						// consider that a new group which means the
+						// previous comments were detached
+						newGroup = true
+					}
+				}
+				if newGroup {
+					groupEnd = i
+					break
+				}
+			}
+
+			if groupEnd == -1 {
+				// just one group of comments; we'll mark it as a trailing
+				// comment if it immediately follows previous symbol and is
+				// detached from current symbol
+				c1 := comments[0]
+				c2 := comments[len(comments)-1]
+				if c1.start.Line <= prevEnd+1 && c2.end.Line < nStart-1 {
+					groupEnd = len(comments)
+				}
+			}
+
+			for i := 0; i < groupEnd; i++ {
+				l.prevSym.pushTrailingComment(n.popLeadingComment())
+			}
+		}
+	}
+
+	l.prevSym = n
+}
+
+func (l *protoLex) setString(lval *protoSymType, val string) {
+	lval.s = &stringLiteralNode{basicNode: l.newBasicNode(), val: val}
+	l.setPrev(lval.s)
+}
+
+func (l *protoLex) setIdent(lval *protoSymType, val string) {
+	lval.id = &identNode{basicNode: l.newBasicNode(), val: val}
+	l.setPrev(lval.id)
+}
+
+func (l *protoLex) setInt(lval *protoSymType, val uint64) {
+	lval.i = &intLiteralNode{basicNode: l.newBasicNode(), val: val}
+	l.setPrev(lval.i)
+}
+
+func (l *protoLex) setFloat(lval *protoSymType, val float64) {
+	lval.f = &floatLiteralNode{basicNode: l.newBasicNode(), val: val}
+	l.setPrev(lval.f)
+}
+
+func (l *protoLex) setRune(lval *protoSymType) {
+	b := l.newBasicNode()
+	lval.b = &b
+	l.setPrev(lval.b)
+}
+
+func (l *protoLex) setError(lval *protoSymType, err error) {
+	lval.err = l.addSourceError(err)
+}
+
 func (l *protoLex) readNumber(sofar []rune, allowDot bool, allowExp bool) []rune {
 	token := sofar
 	for {
@@ -452,19 +472,6 @@
 				break
 			}
 			allowDot = false
-			cn, _, err := l.input.readRune()
-			if err != nil {
-				l.input.unreadRune(c)
-				break
-			}
-			if cn < '0' || cn > '9' {
-				l.input.unreadRune(cn)
-				l.input.unreadRune(c)
-				break
-			}
-			l.colNo++
-			token = append(token, c)
-			c = cn
 		} else if c == 'e' || c == 'E' {
 			if !allowExp {
 				l.input.unreadRune(c)
@@ -489,23 +496,22 @@
 					l.input.unreadRune(c)
 					break
 				}
-				l.colNo++
+				l.adjustPos(c)
 				token = append(token, c)
-				c = cn
-				cn = cnn
+				c, cn = cn, cnn
 			} else if cn < '0' || cn > '9' {
 				l.input.unreadRune(cn)
 				l.input.unreadRune(c)
 				break
 			}
-			l.colNo++
+			l.adjustPos(c)
 			token = append(token, c)
 			c = cn
 		} else if c < '0' || c > '9' {
 			l.input.unreadRune(c)
 			break
 		}
-		l.colNo++
+		l.adjustPos(c)
 		token = append(token, c)
 	}
 	return token
@@ -522,7 +528,7 @@
 			l.input.unreadRune(c)
 			break
 		}
-		l.colNo++
+		l.adjustPos(c)
 		token = append(token, c)
 	}
 	return token
@@ -535,25 +541,11 @@
 		if err != nil {
 			break
 		}
-		if c == '.' {
-			cn, _, err := l.input.readRune()
-			if err != nil {
-				l.input.unreadRune(c)
-				break
-			}
-			if cn != '_' && (cn < 'a' || cn > 'z') && (cn < 'A' || cn > 'Z') {
-				l.input.unreadRune(cn)
-				l.input.unreadRune(c)
-				break
-			}
-			l.colNo++
-			token = append(token, c)
-			c = cn
-		} else if c != '_' && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c < '0' || c > '9') {
+		if c != '_' && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c < '0' || c > '9') {
 			l.input.unreadRune(c)
 			break
 		}
-		l.colNo++
+		l.adjustPos(c)
 		token = append(token, c)
 	}
 	return token
@@ -570,11 +562,9 @@
 			return "", err
 		}
 		if c == '\n' {
-			l.colNo = 0
-			l.lineNo++
 			return "", errors.New("encountered end-of-line before end of string literal")
 		}
-		l.colNo++
+		l.adjustPos(c)
 		if c == quote {
 			break
 		}
@@ -587,14 +577,14 @@
 			if err != nil {
 				return "", err
 			}
-			l.colNo++
+			l.adjustPos(c)
 			if c == 'x' || c == 'X' {
 				// hex escape
 				c, _, err := l.input.readRune()
 				if err != nil {
 					return "", err
 				}
-				l.colNo++
+				l.adjustPos(c)
 				c2, _, err := l.input.readRune()
 				if err != nil {
 					return "", err
@@ -604,7 +594,7 @@
 					l.input.unreadRune(c2)
 					hex = string(c)
 				} else {
-					l.colNo++
+					l.adjustPos(c2)
 					hex = string([]rune{c, c2})
 				}
 				i, err := strconv.ParseInt(hex, 16, 32)
@@ -624,7 +614,7 @@
 					l.input.unreadRune(c2)
 					octal = string(c)
 				} else {
-					l.colNo++
+					l.adjustPos(c2)
 					c3, _, err := l.input.readRune()
 					if err != nil {
 						return "", err
@@ -633,7 +623,7 @@
 						l.input.unreadRune(c3)
 						octal = string([]rune{c, c2})
 					} else {
-						l.colNo++
+						l.adjustPos(c3)
 						octal = string([]rune{c, c2, c3})
 					}
 				}
@@ -654,7 +644,7 @@
 					if err != nil {
 						return "", err
 					}
-					l.colNo++
+					l.adjustPos(c)
 					u[i] = c
 				}
 				i, err := strconv.ParseInt(string(u), 16, 32)
@@ -671,7 +661,7 @@
 					if err != nil {
 						return "", err
 					}
-					l.colNo++
+					l.adjustPos(c)
 					u[i] = c
 				}
 				i, err := strconv.ParseInt(string(u), 16, 32)
@@ -723,9 +713,9 @@
 			return false, string(txt)
 		}
 		if c == '\n' {
-			return true, string(txt)
+			return true, string(append(txt, '\n'))
 		}
-		l.colNo++
+		l.adjustPos(c)
 		txt = append(txt, c)
 	}
 }
@@ -737,12 +727,7 @@
 		if err != nil {
 			return "", false
 		}
-		if c == '\n' {
-			l.colNo = 0
-			l.lineNo++
-		} else {
-			l.colNo++
-		}
+		l.adjustPos(c)
 		txt = append(txt, c)
 		if c == '*' {
 			c, _, err := l.input.readRune()
@@ -750,7 +735,7 @@
 				return "", false
 			}
 			if c == '/' {
-				l.colNo++
+				l.adjustPos(c)
 				txt = append(txt, c)
 				return string(txt), true
 			}
@@ -759,8 +744,15 @@
 	}
 }
 
-func (l *protoLex) Error(s string) {
-	if l.err == nil {
-		l.err = ErrorWithSourcePos{Underlying: errors.New(s), Pos: l.prevSym.start()}
+func (l *protoLex) addSourceError(err error) ErrorWithPos {
+	ewp, ok := err.(ErrorWithPos)
+	if !ok {
+		ewp = ErrorWithSourcePos{Pos: l.prev(), Underlying: err}
 	}
+	_ = l.errs.handleError(ewp)
+	return ewp
+}
+
+func (l *protoLex) Error(s string) {
+	_ = l.addSourceError(errors.New(s))
 }
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/linker.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/linker.go
index c150936..a990f4f 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/linker.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/linker.go
@@ -15,12 +15,14 @@
 
 type linker struct {
 	files          map[string]*parseResult
+	filenames      []string
+	errs           *errorHandler
 	descriptorPool map[*dpb.FileDescriptorProto]map[string]proto.Message
 	extensions     map[string]map[int32]string
 }
 
-func newLinker(files map[string]*parseResult) *linker {
-	return &linker{files: files}
+func newLinker(files *parseResults, errs *errorHandler) *linker {
+	return &linker{files: files.resultsByFilename, filenames: files.filenames, errs: errs}
 }
 
 func (l *linker) linkFiles() (map[string]*desc.FileDescriptor, error) {
@@ -41,6 +43,12 @@
 		return nil, err
 	}
 
+	if err := l.errs.getError(); err != nil {
+		// we won't be able to create real descriptors if we've encountered
+		// errors up to this point, so bail at this point
+		return nil, err
+	}
+
 	// Now we've validated the descriptors, so we can link them into rich
 	// descriptors. This is a little redundant since that step does similar
 	// checking of symbols. But, without breaking encapsulation (e.g. exporting
@@ -65,7 +73,8 @@
 
 func (l *linker) createDescriptorPool() error {
 	l.descriptorPool = map[*dpb.FileDescriptorProto]map[string]proto.Message{}
-	for _, r := range l.files {
+	for _, filename := range l.filenames {
+		r := l.files[filename]
 		fd := r.fd
 		pool := map[string]proto.Message{}
 		l.descriptorPool[fd] = pool
@@ -74,22 +83,22 @@
 			prefix += "."
 		}
 		for _, md := range fd.MessageType {
-			if err := addMessageToPool(r, pool, prefix, md); err != nil {
+			if err := addMessageToPool(r, pool, l.errs, prefix, md); err != nil {
 				return err
 			}
 		}
 		for _, fld := range fd.Extension {
-			if err := addFieldToPool(r, pool, prefix, fld); err != nil {
+			if err := addFieldToPool(r, pool, l.errs, prefix, fld); err != nil {
 				return err
 			}
 		}
 		for _, ed := range fd.EnumType {
-			if err := addEnumToPool(r, pool, prefix, ed); err != nil {
+			if err := addEnumToPool(r, pool, l.errs, prefix, ed); err != nil {
 				return err
 			}
 		}
 		for _, sd := range fd.Service {
-			if err := addServiceToPool(r, pool, prefix, sd); err != nil {
+			if err := addServiceToPool(r, pool, l.errs, prefix, sd); err != nil {
 				return err
 			}
 		}
@@ -101,8 +110,16 @@
 		msg  proto.Message
 	}
 	pool := map[string]entry{}
-	for f, p := range l.descriptorPool {
-		for k, v := range p {
+	for _, filename := range l.filenames {
+		f := l.files[filename].fd
+		p := l.descriptorPool[f]
+		keys := make([]string, 0, len(p))
+		for k := range p {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys) // for deterministic error reporting
+		for _, k := range keys {
+			v := p[k]
 			if e, ok := pool[k]; ok {
 				desc1 := e.msg
 				file1 := e.file
@@ -113,7 +130,9 @@
 					desc1, desc2 = desc2, desc1
 				}
 				node := l.files[file2].nodes[desc2]
-				return ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("duplicate symbol %s: already defined as %s in %q", k, descriptorType(desc1), file1)}
+				if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("duplicate symbol %s: already defined as %s in %q", k, descriptorType(desc1), file1)}); err != nil {
+					return err
+				}
 			}
 			pool[k] = entry{file: f.GetName(), msg: v}
 		}
@@ -122,72 +141,74 @@
 	return nil
 }
 
-func addMessageToPool(r *parseResult, pool map[string]proto.Message, prefix string, md *dpb.DescriptorProto) error {
+func addMessageToPool(r *parseResult, pool map[string]proto.Message, errs *errorHandler, prefix string, md *dpb.DescriptorProto) error {
 	fqn := prefix + md.GetName()
-	if err := addToPool(r, pool, fqn, md); err != nil {
+	if err := addToPool(r, pool, errs, fqn, md); err != nil {
 		return err
 	}
 	prefix = fqn + "."
 	for _, fld := range md.Field {
-		if err := addFieldToPool(r, pool, prefix, fld); err != nil {
+		if err := addFieldToPool(r, pool, errs, prefix, fld); err != nil {
 			return err
 		}
 	}
 	for _, fld := range md.Extension {
-		if err := addFieldToPool(r, pool, prefix, fld); err != nil {
+		if err := addFieldToPool(r, pool, errs, prefix, fld); err != nil {
 			return err
 		}
 	}
 	for _, nmd := range md.NestedType {
-		if err := addMessageToPool(r, pool, prefix, nmd); err != nil {
+		if err := addMessageToPool(r, pool, errs, prefix, nmd); err != nil {
 			return err
 		}
 	}
 	for _, ed := range md.EnumType {
-		if err := addEnumToPool(r, pool, prefix, ed); err != nil {
+		if err := addEnumToPool(r, pool, errs, prefix, ed); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func addFieldToPool(r *parseResult, pool map[string]proto.Message, prefix string, fld *dpb.FieldDescriptorProto) error {
+func addFieldToPool(r *parseResult, pool map[string]proto.Message, errs *errorHandler, prefix string, fld *dpb.FieldDescriptorProto) error {
 	fqn := prefix + fld.GetName()
-	return addToPool(r, pool, fqn, fld)
+	return addToPool(r, pool, errs, fqn, fld)
 }
 
-func addEnumToPool(r *parseResult, pool map[string]proto.Message, prefix string, ed *dpb.EnumDescriptorProto) error {
+func addEnumToPool(r *parseResult, pool map[string]proto.Message, errs *errorHandler, prefix string, ed *dpb.EnumDescriptorProto) error {
 	fqn := prefix + ed.GetName()
-	if err := addToPool(r, pool, fqn, ed); err != nil {
+	if err := addToPool(r, pool, errs, fqn, ed); err != nil {
 		return err
 	}
 	for _, evd := range ed.Value {
 		vfqn := fqn + "." + evd.GetName()
-		if err := addToPool(r, pool, vfqn, evd); err != nil {
+		if err := addToPool(r, pool, errs, vfqn, evd); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func addServiceToPool(r *parseResult, pool map[string]proto.Message, prefix string, sd *dpb.ServiceDescriptorProto) error {
+func addServiceToPool(r *parseResult, pool map[string]proto.Message, errs *errorHandler, prefix string, sd *dpb.ServiceDescriptorProto) error {
 	fqn := prefix + sd.GetName()
-	if err := addToPool(r, pool, fqn, sd); err != nil {
+	if err := addToPool(r, pool, errs, fqn, sd); err != nil {
 		return err
 	}
 	for _, mtd := range sd.Method {
 		mfqn := fqn + "." + mtd.GetName()
-		if err := addToPool(r, pool, mfqn, mtd); err != nil {
+		if err := addToPool(r, pool, errs, mfqn, mtd); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func addToPool(r *parseResult, pool map[string]proto.Message, fqn string, dsc proto.Message) error {
+func addToPool(r *parseResult, pool map[string]proto.Message, errs *errorHandler, fqn string, dsc proto.Message) error {
 	if d, ok := pool[fqn]; ok {
 		node := r.nodes[dsc]
-		return ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("duplicate symbol %s: already defined as %s", fqn, descriptorType(d))}
+		if err := errs.handleError(ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("duplicate symbol %s: already defined as %s", fqn, descriptorType(d))}); err != nil {
+			return err
+		}
 	}
 	pool[fqn] = dsc
 	return nil
@@ -223,7 +244,8 @@
 
 func (l *linker) resolveReferences() error {
 	l.extensions = map[string]map[int32]string{}
-	for _, r := range l.files {
+	for _, filename := range l.filenames {
+		r := l.files[filename]
 		fd := r.fd
 		prefix := fd.GetPackage()
 		scopes := []scope{fileScope(fd, l)}
@@ -326,14 +348,15 @@
 	node := r.getFieldNode(fld)
 	elemType := "field"
 	if fld.GetExtendee() != "" {
+		elemType = "extension"
 		fqn, dsc, _ := l.resolve(fd, fld.GetExtendee(), isMessage, scopes)
 		if dsc == nil {
-			return ErrorWithSourcePos{Pos: node.fieldExtendee().start(), Underlying: fmt.Errorf("unknown extendee type %s", fld.GetExtendee())}
+			return l.errs.handleError(ErrorWithSourcePos{Pos: node.fieldExtendee().start(), Underlying: fmt.Errorf("unknown extendee type %s", fld.GetExtendee())})
 		}
 		extd, ok := dsc.(*dpb.DescriptorProto)
 		if !ok {
 			otherType := descriptorType(dsc)
-			return ErrorWithSourcePos{Pos: node.fieldExtendee().start(), Underlying: fmt.Errorf("extendee is invalid: %s is a %s, not a message", fqn, otherType)}
+			return l.errs.handleError(ErrorWithSourcePos{Pos: node.fieldExtendee().start(), Underlying: fmt.Errorf("extendee is invalid: %s is a %s, not a message", fqn, otherType)})
 		}
 		fld.Extendee = proto.String("." + fqn)
 		// make sure the tag number is in range
@@ -346,19 +369,24 @@
 			}
 		}
 		if !found {
-			return ErrorWithSourcePos{Pos: node.fieldTag().start(), Underlying: fmt.Errorf("%s: tag %d is not in valid range for extended type %s", scope, tag, fqn)}
+			if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.fieldTag().start(), Underlying: fmt.Errorf("%s: tag %d is not in valid range for extended type %s", scope, tag, fqn)}); err != nil {
+				return err
+			}
+		} else {
+			// make sure tag is not a duplicate
+			usedExtTags := l.extensions[fqn]
+			if usedExtTags == nil {
+				usedExtTags = map[int32]string{}
+				l.extensions[fqn] = usedExtTags
+			}
+			if other := usedExtTags[fld.GetNumber()]; other != "" {
+				if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.fieldTag().start(), Underlying: fmt.Errorf("%s: duplicate extension: %s and %s are both using tag %d", scope, other, thisName, fld.GetNumber())}); err != nil {
+					return err
+				}
+			} else {
+				usedExtTags[fld.GetNumber()] = thisName
+			}
 		}
-		// make sure tag is not a duplicate
-		usedExtTags := l.extensions[fqn]
-		if usedExtTags == nil {
-			usedExtTags = map[int32]string{}
-			l.extensions[fqn] = usedExtTags
-		}
-		if other := usedExtTags[fld.GetNumber()]; other != "" {
-			return ErrorWithSourcePos{Pos: node.fieldTag().start(), Underlying: fmt.Errorf("%s: duplicate extension: %s and %s are both using tag %d", scope, other, thisName, fld.GetNumber())}
-		}
-		usedExtTags[fld.GetNumber()] = thisName
-		elemType = "extension"
 	}
 
 	if fld.Options != nil {
@@ -374,18 +402,22 @@
 
 	fqn, dsc, proto3 := l.resolve(fd, fld.GetTypeName(), isType, scopes)
 	if dsc == nil {
-		return ErrorWithSourcePos{Pos: node.fieldType().start(), Underlying: fmt.Errorf("%s: unknown type %s", scope, fld.GetTypeName())}
+		return l.errs.handleError(ErrorWithSourcePos{Pos: node.fieldType().start(), Underlying: fmt.Errorf("%s: unknown type %s", scope, fld.GetTypeName())})
 	}
 	switch dsc := dsc.(type) {
 	case *dpb.DescriptorProto:
 		fld.TypeName = proto.String("." + fqn)
+		// if type was tentatively unset, we now know it's actually a message
+		if fld.Type == nil {
+			fld.Type = dpb.FieldDescriptorProto_TYPE_MESSAGE.Enum()
+		}
 	case *dpb.EnumDescriptorProto:
 		if fld.GetExtendee() == "" && isProto3(fd) && !proto3 {
 			// fields in a proto3 message cannot refer to proto2 enums
 			return ErrorWithSourcePos{Pos: node.fieldType().start(), Underlying: fmt.Errorf("%s: cannot use proto2 enum %s in a proto3 message", scope, fld.GetTypeName())}
 		}
 		fld.TypeName = proto.String("." + fqn)
-		// the type was tentatively set to message, but now we know it's actually an enum
+		// the type was tentatively unset, but now we know it's actually an enum
 		fld.Type = dpb.FieldDescriptorProto_TYPE_ENUM.Enum()
 	default:
 		otherType := descriptorType(dsc)
@@ -412,23 +444,31 @@
 		node := r.getMethodNode(mtd)
 		fqn, dsc, _ := l.resolve(fd, mtd.GetInputType(), isMessage, scopes)
 		if dsc == nil {
-			return ErrorWithSourcePos{Pos: node.getInputType().start(), Underlying: fmt.Errorf("%s: unknown request type %s", scope, mtd.GetInputType())}
-		}
-		if _, ok := dsc.(*dpb.DescriptorProto); !ok {
+			if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.getInputType().start(), Underlying: fmt.Errorf("%s: unknown request type %s", scope, mtd.GetInputType())}); err != nil {
+				return err
+			}
+		} else if _, ok := dsc.(*dpb.DescriptorProto); !ok {
 			otherType := descriptorType(dsc)
-			return ErrorWithSourcePos{Pos: node.getInputType().start(), Underlying: fmt.Errorf("%s: invalid request type: %s is a %s, not a message", scope, fqn, otherType)}
+			if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.getInputType().start(), Underlying: fmt.Errorf("%s: invalid request type: %s is a %s, not a message", scope, fqn, otherType)}); err != nil {
+				return err
+			}
+		} else {
+			mtd.InputType = proto.String("." + fqn)
 		}
-		mtd.InputType = proto.String("." + fqn)
 
 		fqn, dsc, _ = l.resolve(fd, mtd.GetOutputType(), isMessage, scopes)
 		if dsc == nil {
-			return ErrorWithSourcePos{Pos: node.getOutputType().start(), Underlying: fmt.Errorf("%s: unknown response type %s", scope, mtd.GetOutputType())}
-		}
-		if _, ok := dsc.(*dpb.DescriptorProto); !ok {
+			if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.getOutputType().start(), Underlying: fmt.Errorf("%s: unknown response type %s", scope, mtd.GetOutputType())}); err != nil {
+				return err
+			}
+		} else if _, ok := dsc.(*dpb.DescriptorProto); !ok {
 			otherType := descriptorType(dsc)
-			return ErrorWithSourcePos{Pos: node.getOutputType().start(), Underlying: fmt.Errorf("%s: invalid response type: %s is a %s, not a message", scope, fqn, otherType)}
+			if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.getOutputType().start(), Underlying: fmt.Errorf("%s: invalid response type: %s is a %s, not a message", scope, fqn, otherType)}); err != nil {
+				return err
+			}
+		} else {
+			mtd.OutputType = proto.String("." + fqn)
 		}
-		mtd.OutputType = proto.String("." + fqn)
 	}
 	return nil
 }
@@ -438,19 +478,29 @@
 	if elemType != "file" {
 		scope = fmt.Sprintf("%s %s: ", elemType, elemName)
 	}
+opts:
 	for _, opt := range opts {
 		for _, nm := range opt.Name {
 			if nm.GetIsExtension() {
 				node := r.getOptionNamePartNode(nm)
 				fqn, dsc, _ := l.resolve(fd, nm.GetNamePart(), isField, scopes)
 				if dsc == nil {
-					return ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("%sunknown extension %s", scope, nm.GetNamePart())}
+					if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("%sunknown extension %s", scope, nm.GetNamePart())}); err != nil {
+						return err
+					}
+					continue opts
 				}
 				if ext, ok := dsc.(*dpb.FieldDescriptorProto); !ok {
 					otherType := descriptorType(dsc)
-					return ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("%sinvalid extension: %s is a %s, not an extension", scope, nm.GetNamePart(), otherType)}
+					if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("%sinvalid extension: %s is a %s, not an extension", scope, nm.GetNamePart(), otherType)}); err != nil {
+						return err
+					}
+					continue opts
 				} else if ext.GetExtendee() == "" {
-					return ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("%sinvalid extension: %s is a field but not an extension", scope, nm.GetNamePart())}
+					if err := l.errs.handleError(ErrorWithSourcePos{Pos: node.start(), Underlying: fmt.Errorf("%sinvalid extension: %s is a field but not an extension", scope, nm.GetNamePart())}); err != nil {
+						return err
+					}
+					continue opts
 				}
 				nm.NamePart = proto.String("." + fqn)
 			}
@@ -599,14 +649,14 @@
 	sort.Strings(names)
 	linked := map[string]*desc.FileDescriptor{}
 	for _, name := range names {
-		if _, err := l.linkFile(name, nil, linked); err != nil {
+		if _, err := l.linkFile(name, nil, nil, linked); err != nil {
 			return nil, err
 		}
 	}
 	return linked, nil
 }
 
-func (l *linker) linkFile(name string, seen []string, linked map[string]*desc.FileDescriptor) (*desc.FileDescriptor, error) {
+func (l *linker) linkFile(name string, rootImportLoc *SourcePos, seen []string, linked map[string]*desc.FileDescriptor) (*desc.FileDescriptor, error) {
 	// check for import cycle
 	for _, s := range seen {
 		if name == s {
@@ -621,7 +671,10 @@
 				fmt.Fprintf(&msg, "%q", s)
 			}
 			fmt.Fprintf(&msg, " -> %q", name)
-			return nil, fmt.Errorf("cycle found in imports: %s", msg.String())
+			return nil, ErrorWithSourcePos{
+				Underlying: fmt.Errorf("cycle found in imports: %s", msg.String()),
+				Pos:        rootImportLoc,
+			}
 		}
 	}
 	seen = append(seen, name)
@@ -636,12 +689,38 @@
 		return nil, fmt.Errorf("no descriptor found for %q, imported by %q", name, importer)
 	}
 	var deps []*desc.FileDescriptor
-	for _, dep := range r.fd.Dependency {
-		ldep, err := l.linkFile(dep, seen, linked)
-		if err != nil {
-			return nil, err
+	if rootImportLoc == nil {
+		// try to find a source location for this "root" import
+		decl := r.getFileNode(r.fd)
+		fnode, ok := decl.(*fileNode)
+		if ok {
+			for _, dep := range fnode.imports {
+				ldep, err := l.linkFile(dep.name.val, dep.name.start(), seen, linked)
+				if err != nil {
+					return nil, err
+				}
+				deps = append(deps, ldep)
+			}
+		} else {
+			// no AST? just use the descriptor
+			for _, dep := range r.fd.Dependency {
+				ldep, err := l.linkFile(dep, decl.start(), seen, linked)
+				if err != nil {
+					return nil, err
+				}
+				deps = append(deps, ldep)
+			}
 		}
-		deps = append(deps, ldep)
+	} else {
+		// we can just use the descriptor since we don't need source location
+		// (we'll just attribute any import cycles found to the "root" import)
+		for _, dep := range r.fd.Dependency {
+			ldep, err := l.linkFile(dep, rootImportLoc, seen, linked)
+			if err != nil {
+				return nil, err
+			}
+			deps = append(deps, ldep)
+		}
 	}
 	lfd, err := desc.CreateFileDescriptor(r.fd, deps...)
 	if err != nil {
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/options.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/options.go
index be287f6..04530dc 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/options.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/options.go
@@ -1004,7 +1004,7 @@
 
 	} else {
 		// not lenient: try to convert into the passed in message
-		// and fail is not successful
+		// and fail if not successful
 		if err := dm.ConvertTo(opts); err != nil {
 			node := res.nodes[element.AsProto()]
 			return nil, ErrorWithSourcePos{Pos: node.start(), Underlying: err}
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/parser.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/parser.go
index ce9a3e4..6eb1acc 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/parser.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/parser.go
@@ -21,8 +21,6 @@
 
 //go:generate goyacc -o proto.y.go -p proto proto.y
 
-var errNoImportPathsForAbsoluteFilePath = errors.New("must specify at least one import path if any absolute file paths are given")
-
 func init() {
 	protoErrorVerbose = true
 
@@ -31,8 +29,6 @@
 	setTokenName(_INT_LIT, "int literal")
 	setTokenName(_FLOAT_LIT, "float literal")
 	setTokenName(_NAME, "identifier")
-	setTokenName(_FQNAME, "fully-qualified name")
-	setTokenName(_TYPENAME, "type name")
 	setTokenName(_ERROR, "error")
 	// for keywords, just show the keyword itself wrapped in quotes
 	for str, i := range keywords {
@@ -88,49 +84,6 @@
 	}
 }
 
-// ResolveFilenames tries to resolve fileNames into paths that are relative to
-// directories in the given importPaths. The returned slice has the results in
-// the same order as they are supplied in fileNames.
-//
-// The resulting names should be suitable for passing to Parser.ParseFiles.
-//
-// If importPaths is empty and any path is absolute, this returns error.
-// If importPaths is empty and all paths are relative, this returns the original fileNames.
-func ResolveFilenames(importPaths []string, fileNames ...string) ([]string, error) {
-	if len(importPaths) == 0 {
-		if containsAbsFilePath(fileNames) {
-			// We have to do this as otherwise parseProtoFiles can result in duplicate symbols.
-			// For example, assume we import "foo/bar/bar.proto" in a file "/home/alice/dev/foo/bar/baz.proto"
-			// as we call ParseFiles("/home/alice/dev/foo/bar/bar.proto","/home/alice/dev/foo/bar/baz.proto")
-			// with "/home/alice/dev" as our current directory. Due to the recursive nature of parseProtoFiles,
-			// it will discover the import "foo/bar/bar.proto" in the input file, and call parse on this,
-			// adding "foo/bar/bar.proto" to the parsed results, as well as "/home/alice/dev/foo/bar/bar.proto"
-			// from the input file list. This will result in a
-			// 'duplicate symbol SYMBOL: already defined as field in "/home/alice/dev/foo/bar/bar.proto'
-			// error being returned from ParseFiles.
-			return nil, errNoImportPathsForAbsoluteFilePath
-		}
-		return fileNames, nil
-	}
-	absImportPaths, err := absoluteFilePaths(importPaths)
-	if err != nil {
-		return nil, err
-	}
-	absFileNames, err := absoluteFilePaths(fileNames)
-	if err != nil {
-		return nil, err
-	}
-	resolvedFileNames := make([]string, 0, len(fileNames))
-	for _, absFileName := range absFileNames {
-		resolvedFileName, err := resolveAbsFilename(absImportPaths, absFileName)
-		if err != nil {
-			return nil, err
-		}
-		resolvedFileNames = append(resolvedFileNames, resolvedFileName)
-	}
-	return resolvedFileNames, nil
-}
-
 // Parser parses proto source into descriptors.
 type Parser struct {
 	// The paths used to search for dependencies that are referenced in import
@@ -179,6 +132,14 @@
 	// fields, excluding enums. (Interpreting default values for enum fields
 	// requires resolving enum names, which requires linking.)
 	InterpretOptionsInUnlinkedFiles bool
+
+	// A custom reporter of syntax and link errors. If not specified, the
+	// default reporter just returns the reported error, which causes parsing
+	// to abort after encountering a single error.
+	//
+	// The reporter is not invoked for system or I/O errors, only for syntax and
+	// link errors.
+	ErrorReporter ErrorReporter
 }
 
 // ParseFiles parses the named files into descriptors. The returned slice has
@@ -191,6 +152,12 @@
 // files -- e.g. google/protobuf/*.proto -- without needing to supply sources
 // for these files. Like protoc, this parser has a built-in version of these
 // files it can use if they aren't explicitly supplied.
+//
+// If the Parser has no ErrorReporter set and a syntax or link error occurs,
+// parsing will abort with the first such error encountered. If there is an
+// ErrorReporter configured and it returns non-nil, parsing will abort with the
+// error it returns. If syntax or link errors are encountered but the configured
+// ErrorReporter always returns nil, the parse fails with ErrInvalidSource.
 func (p Parser) ParseFiles(filenames ...string) ([]*desc.FileDescriptor, error) {
 	accessor := p.Accessor
 	if accessor == nil {
@@ -218,14 +185,17 @@
 	}
 
 	protos := map[string]*parseResult{}
-	err := parseProtoFiles(accessor, filenames, true, true, protos)
-	if err != nil {
+	results := &parseResults{resultsByFilename: protos}
+	errs := newErrorHandler(p.ErrorReporter)
+	parseProtoFiles(accessor, filenames, errs, true, true, results)
+	if err := errs.getError(); err != nil {
 		return nil, err
 	}
 	if p.InferImportPaths {
+		// TODO: if this re-writes one of the names in filenames, lookups below will break
 		protos = fixupFilenames(protos)
 	}
-	linkedProtos, err := newLinker(protos).linkFiles()
+	linkedProtos, err := newLinker(results, errs).linkFiles()
 	if err != nil {
 		return nil, err
 	}
@@ -269,6 +239,12 @@
 // This method will still validate the syntax of parsed files. If the parser's
 // ValidateUnlinkedFiles field is true, additional checks, beyond syntax will
 // also be performed.
+//
+// If the Parser has no ErrorReporter set and a syntax or link error occurs,
+// parsing will abort with the first such error encountered. If there is an
+// ErrorReporter configured and it returns non-nil, parsing will abort with the
+// error it returns. If syntax or link errors are encountered but the configured
+// ErrorReporter always returns nil, the parse fails with ErrInvalidSource.
 func (p Parser) ParseFilesButDoNotLink(filenames ...string) ([]*dpb.FileDescriptorProto, error) {
 	accessor := p.Accessor
 	if accessor == nil {
@@ -278,11 +254,13 @@
 	}
 
 	protos := map[string]*parseResult{}
-	err := parseProtoFiles(accessor, filenames, false, p.ValidateUnlinkedFiles, protos)
-	if err != nil {
+	errs := newErrorHandler(p.ErrorReporter)
+	parseProtoFiles(accessor, filenames, errs, false, p.ValidateUnlinkedFiles, &parseResults{resultsByFilename: protos})
+	if err := errs.getError(); err != nil {
 		return nil, err
 	}
 	if p.InferImportPaths {
+		// TODO: if this re-writes one of the names in filenames, lookups below will break
 		protos = fixupFilenames(protos)
 	}
 	fds := make([]*dpb.FileDescriptorProto, len(filenames))
@@ -291,7 +269,7 @@
 		fd := pr.fd
 		if p.InterpretOptionsInUnlinkedFiles {
 			pr.lenient = true
-			interpretFileOptions(pr, poorFileDescriptorish{FileDescriptorProto: fd})
+			_ = interpretFileOptions(pr, poorFileDescriptorish{FileDescriptorProto: fd})
 		}
 		if p.IncludeSourceCodeInfo {
 			fd.SourceCodeInfo = pr.generateSourceCodeInfo()
@@ -301,57 +279,6 @@
 	return fds, nil
 }
 
-func containsAbsFilePath(filePaths []string) bool {
-	for _, filePath := range filePaths {
-		if filepath.IsAbs(filePath) {
-			return true
-		}
-	}
-	return false
-}
-
-func absoluteFilePaths(filePaths []string) ([]string, error) {
-	absFilePaths := make([]string, 0, len(filePaths))
-	for _, filePath := range filePaths {
-		absFilePath, err := filepath.Abs(filePath)
-		if err != nil {
-			return nil, err
-		}
-		absFilePaths = append(absFilePaths, absFilePath)
-	}
-	return absFilePaths, nil
-}
-
-func resolveAbsFilename(absImportPaths []string, absFileName string) (string, error) {
-	for _, absImportPath := range absImportPaths {
-		if isDescendant(absImportPath, absFileName) {
-			resolvedPath, err := filepath.Rel(absImportPath, absFileName)
-			if err != nil {
-				return "", err
-			}
-			return resolvedPath, nil
-		}
-	}
-	return "", fmt.Errorf("%s does not reside in any import path", absFileName)
-}
-
-// isDescendant returns true if file is a descendant of dir.
-func isDescendant(dir, file string) bool {
-	dir = filepath.Clean(dir)
-	cur := file
-	for {
-		d := filepath.Dir(cur)
-		if d == dir {
-			return true
-		}
-		if d == "." || d == cur {
-			// we've run out of path elements
-			return false
-		}
-		cur = d
-	}
-}
-
 func fixupFilenames(protos map[string]*parseResult) map[string]*parseResult {
 	// In the event that the given filenames (keys in the supplied map) do not
 	// match the actual paths used in 'import' statements in the files, we try
@@ -460,37 +387,103 @@
 	return revisedProtos
 }
 
-func parseProtoFiles(acc FileAccessor, filenames []string, recursive, validate bool, parsed map[string]*parseResult) error {
+func parseProtoFiles(acc FileAccessor, filenames []string, errs *errorHandler, recursive, validate bool, parsed *parseResults) {
 	for _, name := range filenames {
-		if _, ok := parsed[name]; ok {
-			continue
+		parseProtoFile(acc, name, nil, errs, recursive, validate, parsed)
+		if errs.err != nil {
+			return
 		}
-		in, err := acc(name)
-		if err != nil {
-			if d, ok := standardImports[name]; ok {
-				parsed[name] = &parseResult{fd: d}
-				continue
-			}
-			return err
-		}
+	}
+}
+
+func parseProtoFile(acc FileAccessor, filename string, importLoc *SourcePos, errs *errorHandler, recursive, validate bool, parsed *parseResults) {
+	if parsed.has(filename) {
+		return
+	}
+	in, err := acc(filename)
+	var result *parseResult
+	if err == nil {
+		// try to parse the bytes accessed
 		func() {
-			defer in.Close()
-			parsed[name], err = parseProto(name, in, validate)
+			defer func() {
+				// if we've already parsed contents, an error
+				// closing need not fail this operation
+				_ = in.Close()
+			}()
+			result = parseProto(filename, in, errs, validate)
 		}()
-		if err != nil {
-			return err
+	} else if d, ok := standardImports[filename]; ok {
+		// it's a well-known import
+		// (we clone it to make sure we're not sharing state with other
+		//  parsers, which could result in unsafe races if multiple
+		//  parsers are trying to access it concurrently)
+		result = &parseResult{fd: proto.Clone(d).(*dpb.FileDescriptorProto)}
+	} else {
+		if !strings.Contains(err.Error(), filename) {
+			// an error message that doesn't indicate the file is awful!
+			err = fmt.Errorf("%s: %v", filename, err)
 		}
-		if recursive {
-			err = parseProtoFiles(acc, parsed[name].fd.Dependency, true, validate, parsed)
-			if err != nil {
-				return fmt.Errorf("failed to load imports for %q: %s", name, err)
+		if _, ok := err.(ErrorWithPos); !ok && importLoc != nil {
+			// error has no source position? report it as the import line
+			err = ErrorWithSourcePos{
+				Pos:        importLoc,
+				Underlying: err,
+			}
+		}
+		_ = errs.handleError(err)
+		return
+	}
+
+	parsed.add(filename, result)
+
+	if errs.getError() != nil {
+		return // abort
+	}
+
+	if recursive {
+		fd := result.fd
+		decl := result.getFileNode(fd)
+		fnode, ok := decl.(*fileNode)
+		if !ok {
+			// no AST for this file? use imports in descriptor
+			for _, dep := range fd.Dependency {
+				parseProtoFile(acc, dep, decl.start(), errs, true, validate, parsed)
+				if errs.getError() != nil {
+					return // abort
+				}
+			}
+			return
+		}
+		// we have an AST; use it so we can report import location in errors
+		for _, dep := range fnode.imports {
+			parseProtoFile(acc, dep.name.val, dep.name.start(), errs, true, validate, parsed)
+			if errs.getError() != nil {
+				return // abort
 			}
 		}
 	}
-	return nil
+}
+
+type parseResults struct {
+	resultsByFilename map[string]*parseResult
+	filenames         []string
+}
+
+func (r *parseResults) has(filename string) bool {
+	_, ok := r.resultsByFilename[filename]
+	return ok
+}
+
+func (r *parseResults) add(filename string, result *parseResult) {
+	r.resultsByFilename[filename] = result
+	r.filenames = append(r.filenames, filename)
 }
 
 type parseResult struct {
+	// handles any errors encountered during parsing, construction of file descriptor,
+	// or validation
+	errs *errorHandler
+
 	// the parsed file descriptor
 	fd *dpb.FileDescriptorProto
 
@@ -529,13 +522,6 @@
 	return r.nodes[o]
 }
 
-func (r *parseResult) getMessageNode(m *dpb.DescriptorProto) msgDecl {
-	if r.nodes == nil {
-		return noSourceNode{pos: unknownPos(r.fd.GetName())}
-	}
-	return r.nodes[m].(msgDecl)
-}
-
 func (r *parseResult) getFieldNode(f *dpb.FieldDescriptorProto) fieldDecl {
 	if r.nodes == nil {
 		return noSourceNode{pos: unknownPos(r.fd.GetName())}
@@ -543,13 +529,6 @@
 	return r.nodes[f].(fieldDecl)
 }
 
-func (r *parseResult) getOneOfNode(o *dpb.OneofDescriptorProto) node {
-	if r.nodes == nil {
-		return noSourceNode{pos: unknownPos(r.fd.GetName())}
-	}
-	return r.nodes[o]
-}
-
 func (r *parseResult) getExtensionRangeNode(e *dpb.DescriptorProto_ExtensionRange) rangeDecl {
 	if r.nodes == nil {
 		return noSourceNode{pos: unknownPos(r.fd.GetName())}
@@ -564,13 +543,6 @@
 	return r.nodes[rr].(rangeDecl)
 }
 
-func (r *parseResult) getEnumNode(e *dpb.EnumDescriptorProto) node {
-	if r.nodes == nil {
-		return noSourceNode{pos: unknownPos(r.fd.GetName())}
-	}
-	return r.nodes[e]
-}
-
 func (r *parseResult) getEnumValueNode(e *dpb.EnumValueDescriptorProto) enumValueDecl {
 	if r.nodes == nil {
 		return noSourceNode{pos: unknownPos(r.fd.GetName())}
@@ -585,13 +557,6 @@
 	return r.nodes[rr].(rangeDecl)
 }
 
-func (r *parseResult) getServiceNode(s *dpb.ServiceDescriptorProto) node {
-	if r.nodes == nil {
-		return noSourceNode{pos: unknownPos(r.fd.GetName())}
-	}
-	return r.nodes[s]
-}
-
 func (r *parseResult) getMethodNode(m *dpb.MethodDescriptorProto) methodDecl {
 	if r.nodes == nil {
 		return noSourceNode{pos: unknownPos(r.fd.GetName())}
@@ -651,46 +616,38 @@
 	r.nodes[m] = n
 }
 
-func parseProto(filename string, r io.Reader, validate bool) (*parseResult, error) {
-	lx := newLexer(r)
-	lx.filename = filename
+func parseProto(filename string, r io.Reader, errs *errorHandler, validate bool) *parseResult {
+	lx := newLexer(r, filename, errs)
 	protoParse(lx)
-	if lx.err != nil {
-		if _, ok := lx.err.(ErrorWithSourcePos); ok {
-			return nil, lx.err
-		} else {
-			return nil, ErrorWithSourcePos{Pos: lx.prev(), Underlying: lx.err}
-		}
-	}
-	// parser will not return an error if input is empty, so we
-	// need to also check if the result is non-nil
-	if lx.res == nil {
-		return nil, ErrorWithSourcePos{Pos: lx.prev(), Underlying: errors.New("input is empty")}
+
+	res := createParseResult(filename, lx.res, errs)
+	if validate {
+		basicValidate(res)
 	}
 
-	res, err := createParseResult(filename, lx.res)
-	if err != nil {
-		return nil, err
-	}
-	if validate {
-		if err := basicValidate(res); err != nil {
-			return nil, err
-		}
-	}
-	return res, nil
+	return res
 }
 
-func createParseResult(filename string, file *fileNode) (*parseResult, error) {
+func createParseResult(filename string, file *fileNode, errs *errorHandler) *parseResult {
 	res := &parseResult{
+		errs:               errs,
 		nodes:              map[proto.Message]node{},
 		interpretedOptions: map[*optionNode][]int32{},
 	}
-	err := res.createFileDescriptor(filename, file)
-	return res, err
+	if file == nil {
+		// nil AST means there was an error that prevented any parsing
+		// or the file was empty; synthesize empty non-nil AST
+		file = &fileNode{}
+		n := noSourceNode{pos: unknownPos(filename)}
+		file.setRange(&n, &n)
+	}
+	res.createFileDescriptor(filename, file)
+	return res
 }
 
-func (r *parseResult) createFileDescriptor(filename string, file *fileNode) error {
+func (r *parseResult) createFileDescriptor(filename string, file *fileNode) {
 	fd := &dpb.FileDescriptorProto{Name: proto.String(filename)}
+	r.fd = fd
 	r.putFileNode(fd, file)
 
 	isProto3 := false
@@ -727,17 +684,19 @@
 			fd.Service = append(fd.Service, r.asServiceDescriptor(decl.service))
 		} else if decl.pkg != nil {
 			if fd.Package != nil {
-				return ErrorWithSourcePos{Pos: decl.pkg.start(), Underlying: errors.New("files should have only one package declaration")}
+				if r.errs.handleError(ErrorWithSourcePos{Pos: decl.pkg.start(), Underlying: errors.New("files should have only one package declaration")}) != nil {
+					return
+				}
 			}
-			file.pkg = decl.pkg
 			fd.Package = proto.String(decl.pkg.name.val)
 		}
 	}
-	r.fd = fd
-	return nil
 }
 
 func (r *parseResult) asUninterpretedOptions(nodes []*optionNode) []*dpb.UninterpretedOption {
+	if len(nodes) == 0 {
+		return nil
+	}
 	opts := make([]*dpb.UninterpretedOption, len(nodes))
 	for i, n := range nodes {
 		opts[i] = r.asUninterpretedOption(n)
@@ -810,8 +769,8 @@
 	}
 }
 
-func asLabel(lbl *labelNode) *dpb.FieldDescriptorProto_Label {
-	if lbl == nil {
+func asLabel(lbl *fieldLabel) *dpb.FieldDescriptorProto_Label {
+	if lbl.identNode == nil {
 		return nil
 	}
 	switch {
@@ -825,14 +784,32 @@
 }
 
 func (r *parseResult) asFieldDescriptor(node *fieldNode) *dpb.FieldDescriptorProto {
-	fd := newFieldDescriptor(node.name.val, node.fldType.val, int32(node.tag.val), asLabel(node.label))
+	fd := newFieldDescriptor(node.name.val, node.fldType.val, int32(node.tag.val), asLabel(&node.label))
 	r.putFieldNode(fd, node)
-	if len(node.options) > 0 {
-		fd.Options = &dpb.FieldOptions{UninterpretedOption: r.asUninterpretedOptions(node.options)}
+	if opts := node.options.Elements(); len(opts) > 0 {
+		fd.Options = &dpb.FieldOptions{UninterpretedOption: r.asUninterpretedOptions(opts)}
 	}
 	return fd
 }
 
+var fieldTypes = map[string]dpb.FieldDescriptorProto_Type{
+	"double":   dpb.FieldDescriptorProto_TYPE_DOUBLE,
+	"float":    dpb.FieldDescriptorProto_TYPE_FLOAT,
+	"int32":    dpb.FieldDescriptorProto_TYPE_INT32,
+	"int64":    dpb.FieldDescriptorProto_TYPE_INT64,
+	"uint32":   dpb.FieldDescriptorProto_TYPE_UINT32,
+	"uint64":   dpb.FieldDescriptorProto_TYPE_UINT64,
+	"sint32":   dpb.FieldDescriptorProto_TYPE_SINT32,
+	"sint64":   dpb.FieldDescriptorProto_TYPE_SINT64,
+	"fixed32":  dpb.FieldDescriptorProto_TYPE_FIXED32,
+	"fixed64":  dpb.FieldDescriptorProto_TYPE_FIXED64,
+	"sfixed32": dpb.FieldDescriptorProto_TYPE_SFIXED32,
+	"sfixed64": dpb.FieldDescriptorProto_TYPE_SFIXED64,
+	"bool":     dpb.FieldDescriptorProto_TYPE_BOOL,
+	"string":   dpb.FieldDescriptorProto_TYPE_STRING,
+	"bytes":    dpb.FieldDescriptorProto_TYPE_BYTES,
+}
+
 func newFieldDescriptor(name string, fieldType string, tag int32, lbl *dpb.FieldDescriptorProto_Label) *dpb.FieldDescriptorProto {
 	fd := &dpb.FieldDescriptorProto{
 		Name:     proto.String(name),
@@ -840,41 +817,13 @@
 		Number:   proto.Int32(tag),
 		Label:    lbl,
 	}
-	switch fieldType {
-	case "double":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_DOUBLE.Enum()
-	case "float":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_FLOAT.Enum()
-	case "int32":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_INT32.Enum()
-	case "int64":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_INT64.Enum()
-	case "uint32":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_UINT32.Enum()
-	case "uint64":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_UINT64.Enum()
-	case "sint32":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_SINT32.Enum()
-	case "sint64":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_SINT64.Enum()
-	case "fixed32":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_FIXED32.Enum()
-	case "fixed64":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_FIXED64.Enum()
-	case "sfixed32":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_SFIXED32.Enum()
-	case "sfixed64":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_SFIXED64.Enum()
-	case "bool":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_BOOL.Enum()
-	case "string":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_STRING.Enum()
-	case "bytes":
-		fd.Type = dpb.FieldDescriptorProto_TYPE_BYTES.Enum()
-	default:
-		// NB: we don't have enough info to determine whether this is an enum or a message type,
-		// so we'll change it to enum later once we can ascertain if it's an enum reference
-		fd.Type = dpb.FieldDescriptorProto_TYPE_MESSAGE.Enum()
+	t, ok := fieldTypes[fieldType]
+	if ok {
+		fd.Type = t.Enum()
+	} else {
+		// NB: we don't have enough info to determine whether this is an enum
+		// or a message type, so we'll leave Type nil and set it later
+		// (during linking)
 		fd.TypeName = proto.String(fieldType)
 	}
 	return fd
@@ -886,14 +835,14 @@
 		Name:     proto.String(fieldName),
 		JsonName: proto.String(internal.JsonName(fieldName)),
 		Number:   proto.Int32(int32(group.tag.val)),
-		Label:    asLabel(group.label),
+		Label:    asLabel(&group.label),
 		Type:     dpb.FieldDescriptorProto_TYPE_GROUP.Enum(),
 		TypeName: proto.String(group.name.val),
 	}
 	r.putFieldNode(fd, group)
 	md := &dpb.DescriptorProto{Name: proto.String(group.name.val)}
 	r.putMessageNode(md, group)
-	r.addMessageDecls(md, &group.reserved, group.decls, isProto3)
+	r.addMessageDecls(md, group.decls, isProto3)
 	return fd, md
 }
 
@@ -902,14 +851,14 @@
 	if !isProto3 {
 		lbl = dpb.FieldDescriptorProto_LABEL_OPTIONAL.Enum()
 	}
-	keyFd := newFieldDescriptor("key", mapField.keyType.val, 1, lbl)
+	keyFd := newFieldDescriptor("key", mapField.mapType.keyType.val, 1, lbl)
 	r.putFieldNode(keyFd, mapField.keyField())
-	valFd := newFieldDescriptor("value", mapField.valueType.val, 2, lbl)
+	valFd := newFieldDescriptor("value", mapField.mapType.valueType.val, 2, lbl)
 	r.putFieldNode(valFd, mapField.valueField())
 	entryName := internal.InitCap(internal.JsonName(mapField.name.val)) + "Entry"
 	fd := newFieldDescriptor(mapField.name.val, entryName, int32(mapField.tag.val), dpb.FieldDescriptorProto_LABEL_REPEATED.Enum())
-	if len(mapField.options) > 0 {
-		fd.Options = &dpb.FieldOptions{UninterpretedOption: r.asUninterpretedOptions(mapField.options)}
+	if opts := mapField.options.Elements(); len(opts) > 0 {
+		fd.Options = &dpb.FieldOptions{UninterpretedOption: r.asUninterpretedOptions(opts)}
 	}
 	r.putFieldNode(fd, mapField)
 	md := &dpb.DescriptorProto{
@@ -922,7 +871,7 @@
 }
 
 func (r *parseResult) asExtensionRanges(node *extensionRangeNode) []*dpb.DescriptorProto_ExtensionRange {
-	opts := r.asUninterpretedOptions(node.options)
+	opts := r.asUninterpretedOptions(node.options.Elements())
 	ers := make([]*dpb.DescriptorProto_ExtensionRange, len(node.ranges))
 	for i, rng := range node.ranges {
 		er := &dpb.DescriptorProto_ExtensionRange{
@@ -939,16 +888,11 @@
 }
 
 func (r *parseResult) asEnumValue(ev *enumValueNode) *dpb.EnumValueDescriptorProto {
-	var num int32
-	if ev.numberP != nil {
-		num = int32(ev.numberP.val)
-	} else {
-		num = int32(ev.numberN.val)
-	}
+	num := int32(ev.number.val)
 	evd := &dpb.EnumValueDescriptorProto{Name: proto.String(ev.name.val), Number: proto.Int32(num)}
 	r.putEnumValueNode(evd, ev)
-	if len(ev.options) > 0 {
-		evd.Options = &dpb.EnumValueOptions{UninterpretedOption: r.asUninterpretedOptions(ev.options)}
+	if opts := ev.options.Elements(); len(opts) > 0 {
+		evd.Options = &dpb.EnumValueOptions{UninterpretedOption: r.asUninterpretedOptions(opts)}
 	}
 	return evd
 }
@@ -989,7 +933,6 @@
 			ed.Value = append(ed.Value, r.asEnumValue(decl.value))
 		} else if decl.reserved != nil {
 			for _, n := range decl.reserved.names {
-				en.reserved = append(en.reserved, n)
 				ed.ReservedName = append(ed.ReservedName, n.val)
 			}
 			for _, rng := range decl.reserved.ranges {
@@ -1012,11 +955,11 @@
 func (r *parseResult) asMessageDescriptor(node *messageNode, isProto3 bool) *dpb.DescriptorProto {
 	msgd := &dpb.DescriptorProto{Name: proto.String(node.name.val)}
 	r.putMessageNode(msgd, node)
-	r.addMessageDecls(msgd, &node.reserved, node.decls, isProto3)
+	r.addMessageDecls(msgd, node.decls, isProto3)
 	return msgd
 }
 
-func (r *parseResult) addMessageDecls(msgd *dpb.DescriptorProto, reservedNames *[]*stringLiteralNode, decls []*messageElement, isProto3 bool) {
+func (r *parseResult) addMessageDecls(msgd *dpb.DescriptorProto, decls []*messageElement, isProto3 bool) {
 	for _, decl := range decls {
 		if decl.enum != nil {
 			msgd.EnumType = append(msgd.EnumType, r.asEnumDescriptor(decl.enum))
@@ -1049,6 +992,11 @@
 					fd := r.asFieldDescriptor(oodecl.field)
 					fd.OneofIndex = proto.Int32(int32(oodIndex))
 					msgd.Field = append(msgd.Field, fd)
+				} else if oodecl.group != nil {
+					fd, md := r.asGroupDescriptors(oodecl.group, isProto3)
+					fd.OneofIndex = proto.Int32(int32(oodIndex))
+					msgd.Field = append(msgd.Field, fd)
+					msgd.NestedType = append(msgd.NestedType, md)
 				}
 			}
 		} else if decl.option != nil {
@@ -1060,7 +1008,6 @@
 			msgd.NestedType = append(msgd.NestedType, r.asMessageDescriptor(decl.nested, isProto3))
 		} else if decl.reserved != nil {
 			for _, n := range decl.reserved.names {
-				*reservedNames = append(*reservedNames, n)
 				msgd.ReservedName = append(msgd.ReservedName, n.val)
 			}
 			for _, rng := range decl.reserved.ranges {
@@ -1095,7 +1042,7 @@
 	return sd
 }
 
-func toNameParts(ident *identNode, offset int) []*optionNamePartNode {
+func toNameParts(ident *compoundIdentNode, offset int) []*optionNamePartNode {
 	parts := strings.Split(ident.val[offset:], ".")
 	ret := make([]*optionNamePartNode, len(parts))
 	for i, p := range parts {
@@ -1119,7 +1066,9 @@
 }
 
 func checkTag(lex protoLexer, pos *SourcePos, v uint64) {
-	if v > internal.MaxTag {
+	if v < 1 {
+		lexError(lex, pos, fmt.Sprintf("tag number %d must be greater than zero", v))
+	} else if v > internal.MaxTag {
 		lexError(lex, pos, fmt.Sprintf("tag number %d is higher than max allowed tag number (%d)", v, internal.MaxTag))
 	} else if v >= internal.SpecialReservedStart && v <= internal.SpecialReservedEnd {
 		lexError(lex, pos, fmt.Sprintf("tag number %d is in disallowed reserved range %d-%d", v, internal.SpecialReservedStart, internal.SpecialReservedEnd))
@@ -1206,28 +1155,27 @@
 	}
 }
 
-func basicValidate(res *parseResult) error {
+func basicValidate(res *parseResult) {
 	fd := res.fd
 	isProto3 := fd.GetSyntax() == "proto3"
 
 	for _, md := range fd.MessageType {
-		if err := validateMessage(res, isProto3, "", md); err != nil {
-			return err
+		if validateMessage(res, isProto3, "", md) != nil {
+			return
 		}
 	}
 
 	for _, ed := range fd.EnumType {
-		if err := validateEnum(res, isProto3, "", ed); err != nil {
-			return err
+		if validateEnum(res, isProto3, "", ed) != nil {
+			return
 		}
 	}
 
 	for _, fld := range fd.Extension {
-		if err := validateField(res, isProto3, "", fld); err != nil {
-			return err
+		if validateField(res, isProto3, "", fld) != nil {
+			return
 		}
 	}
-	return nil
 }
 
 func validateMessage(res *parseResult, isProto3 bool, prefix string, md *dpb.DescriptorProto) error {
@@ -1258,11 +1206,15 @@
 
 	if isProto3 && len(md.ExtensionRange) > 0 {
 		n := res.getExtensionRangeNode(md.ExtensionRange[0])
-		return ErrorWithSourcePos{Pos: n.start(), Underlying: fmt.Errorf("%s: extension ranges are not allowed in proto3", scope)}
+		if err := res.errs.handleError(ErrorWithSourcePos{Pos: n.start(), Underlying: fmt.Errorf("%s: extension ranges are not allowed in proto3", scope)}); err != nil {
+			return err
+		}
 	}
 
 	if index, err := findOption(res, scope, md.Options.GetUninterpretedOption(), "map_entry"); err != nil {
-		return err
+		if err := res.errs.handleError(err); err != nil {
+			return err
+		}
 	} else if index >= 0 {
 		opt := md.Options.UninterpretedOption[index]
 		optn := res.getOptionNode(opt)
@@ -1270,14 +1222,19 @@
 		valid := false
 		if opt.IdentifierValue != nil {
 			if opt.GetIdentifierValue() == "true" {
-				return ErrorWithSourcePos{Pos: optn.getValue().start(), Underlying: fmt.Errorf("%s: map_entry option should not be set explicitly; use map type instead", scope)}
-			} else if opt.GetIdentifierValue() == "false" {
-				md.Options.MapEntry = proto.Bool(false)
 				valid = true
+				if err := res.errs.handleError(ErrorWithSourcePos{Pos: optn.getValue().start(), Underlying: fmt.Errorf("%s: map_entry option should not be set explicitly; use map type instead", scope)}); err != nil {
+					return err
+				}
+			} else if opt.GetIdentifierValue() == "false" {
+				valid = true
+				md.Options.MapEntry = proto.Bool(false)
 			}
 		}
 		if !valid {
-			return ErrorWithSourcePos{Pos: optn.getValue().start(), Underlying: fmt.Errorf("%s: expecting bool value for map_entry option", scope)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: optn.getValue().start(), Underlying: fmt.Errorf("%s: expecting bool value for map_entry option", scope)}); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -1291,7 +1248,9 @@
 	sort.Sort(rsvd)
 	for i := 1; i < len(rsvd); i++ {
 		if rsvd[i].start < rsvd[i-1].end {
-			return ErrorWithSourcePos{Pos: rsvd[i].node.start(), Underlying: fmt.Errorf("%s: reserved ranges overlap: %d to %d and %d to %d", scope, rsvd[i-1].start, rsvd[i-1].end-1, rsvd[i].start, rsvd[i].end-1)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: rsvd[i].node.start(), Underlying: fmt.Errorf("%s: reserved ranges overlap: %d to %d and %d to %d", scope, rsvd[i-1].start, rsvd[i-1].end-1, rsvd[i].start, rsvd[i].end-1)}); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -1304,7 +1263,9 @@
 	sort.Sort(exts)
 	for i := 1; i < len(exts); i++ {
 		if exts[i].start < exts[i-1].end {
-			return ErrorWithSourcePos{Pos: exts[i].node.start(), Underlying: fmt.Errorf("%s: extension ranges overlap: %d to %d and %d to %d", scope, exts[i-1].start, exts[i-1].end-1, exts[i].start, exts[i].end-1)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: exts[i].node.start(), Underlying: fmt.Errorf("%s: extension ranges overlap: %d to %d and %d to %d", scope, exts[i-1].start, exts[i-1].end-1, exts[i].start, exts[i].end-1)}); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -1321,7 +1282,9 @@
 				pos = exts[j].node.start()
 			}
 			// ranges overlap
-			return ErrorWithSourcePos{Pos: pos, Underlying: fmt.Errorf("%s: extension range %d to %d overlaps reserved range %d to %d", scope, exts[j].start, exts[j].end-1, rsvd[i].start, rsvd[i].end-1)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: pos, Underlying: fmt.Errorf("%s: extension range %d to %d overlaps reserved range %d to %d", scope, exts[j].start, exts[j].end-1, rsvd[i].start, rsvd[i].end-1)}); err != nil {
+				return err
+			}
 		}
 		if rsvd[i].start < exts[j].start {
 			i++
@@ -1340,21 +1303,29 @@
 	for _, fld := range md.Field {
 		fn := res.getFieldNode(fld)
 		if _, ok := rsvdNames[fld.GetName()]; ok {
-			return ErrorWithSourcePos{Pos: fn.fieldName().start(), Underlying: fmt.Errorf("%s: field %s is using a reserved name", scope, fld.GetName())}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: fn.fieldName().start(), Underlying: fmt.Errorf("%s: field %s is using a reserved name", scope, fld.GetName())}); err != nil {
+				return err
+			}
 		}
 		if existing := fieldTags[fld.GetNumber()]; existing != "" {
-			return ErrorWithSourcePos{Pos: fn.fieldTag().start(), Underlying: fmt.Errorf("%s: fields %s and %s both have the same tag %d", scope, existing, fld.GetName(), fld.GetNumber())}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: fn.fieldTag().start(), Underlying: fmt.Errorf("%s: fields %s and %s both have the same tag %d", scope, existing, fld.GetName(), fld.GetNumber())}); err != nil {
+				return err
+			}
 		}
 		fieldTags[fld.GetNumber()] = fld.GetName()
 		// check reserved ranges
 		r := sort.Search(len(rsvd), func(index int) bool { return rsvd[index].end > fld.GetNumber() })
 		if r < len(rsvd) && rsvd[r].start <= fld.GetNumber() {
-			return ErrorWithSourcePos{Pos: fn.fieldTag().start(), Underlying: fmt.Errorf("%s: field %s is using tag %d which is in reserved range %d to %d", scope, fld.GetName(), fld.GetNumber(), rsvd[r].start, rsvd[r].end-1)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: fn.fieldTag().start(), Underlying: fmt.Errorf("%s: field %s is using tag %d which is in reserved range %d to %d", scope, fld.GetName(), fld.GetNumber(), rsvd[r].start, rsvd[r].end-1)}); err != nil {
+				return err
+			}
 		}
 		// and check extension ranges
 		e := sort.Search(len(exts), func(index int) bool { return exts[index].end > fld.GetNumber() })
 		if e < len(exts) && exts[e].start <= fld.GetNumber() {
-			return ErrorWithSourcePos{Pos: fn.fieldTag().start(), Underlying: fmt.Errorf("%s: field %s is using tag %d which is in extension range %d to %d", scope, fld.GetName(), fld.GetNumber(), exts[e].start, exts[e].end-1)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: fn.fieldTag().start(), Underlying: fmt.Errorf("%s: field %s is using tag %d which is in extension range %d to %d", scope, fld.GetName(), fld.GetNumber(), exts[e].start, exts[e].end-1)}); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -1364,39 +1335,46 @@
 func validateEnum(res *parseResult, isProto3 bool, prefix string, ed *dpb.EnumDescriptorProto) error {
 	scope := fmt.Sprintf("enum %s%s", prefix, ed.GetName())
 
+	allowAlias := false
 	if index, err := findOption(res, scope, ed.Options.GetUninterpretedOption(), "allow_alias"); err != nil {
-		return err
+		if err := res.errs.handleError(err); err != nil {
+			return err
+		}
 	} else if index >= 0 {
 		opt := ed.Options.UninterpretedOption[index]
-		ed.Options.UninterpretedOption = removeOption(ed.Options.UninterpretedOption, index)
 		valid := false
 		if opt.IdentifierValue != nil {
 			if opt.GetIdentifierValue() == "true" {
-				ed.Options.AllowAlias = proto.Bool(true)
+				allowAlias = true
 				valid = true
 			} else if opt.GetIdentifierValue() == "false" {
-				ed.Options.AllowAlias = proto.Bool(false)
 				valid = true
 			}
 		}
 		if !valid {
 			optNode := res.getOptionNode(opt)
-			return ErrorWithSourcePos{Pos: optNode.getValue().start(), Underlying: fmt.Errorf("%s: expecting bool value for allow_alias option", scope)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: optNode.getValue().start(), Underlying: fmt.Errorf("%s: expecting bool value for allow_alias option", scope)}); err != nil {
+				return err
+			}
 		}
 	}
 
 	if isProto3 && ed.Value[0].GetNumber() != 0 {
 		evNode := res.getEnumValueNode(ed.Value[0])
-		return ErrorWithSourcePos{Pos: evNode.getNumber().start(), Underlying: fmt.Errorf("%s: proto3 requires that first value in enum have numeric value of 0", scope)}
+		if err := res.errs.handleError(ErrorWithSourcePos{Pos: evNode.getNumber().start(), Underlying: fmt.Errorf("%s: proto3 requires that first value in enum have numeric value of 0", scope)}); err != nil {
+			return err
+		}
 	}
 
-	if !ed.Options.GetAllowAlias() {
+	if !allowAlias {
 		// make sure all value numbers are distinct
 		vals := map[int32]string{}
 		for _, evd := range ed.Value {
 			if existing := vals[evd.GetNumber()]; existing != "" {
 				evNode := res.getEnumValueNode(evd)
-				return ErrorWithSourcePos{Pos: evNode.getNumber().start(), Underlying: fmt.Errorf("%s: values %s and %s both have the same numeric value %d; use allow_alias option if intentional", scope, existing, evd.GetName(), evd.GetNumber())}
+				if err := res.errs.handleError(ErrorWithSourcePos{Pos: evNode.getNumber().start(), Underlying: fmt.Errorf("%s: values %s and %s both have the same numeric value %d; use allow_alias option if intentional", scope, existing, evd.GetName(), evd.GetNumber())}); err != nil {
+					return err
+				}
 			}
 			vals[evd.GetNumber()] = evd.GetName()
 		}
@@ -1411,7 +1389,9 @@
 	sort.Sort(rsvd)
 	for i := 1; i < len(rsvd); i++ {
 		if rsvd[i].start <= rsvd[i-1].end {
-			return ErrorWithSourcePos{Pos: rsvd[i].node.start(), Underlying: fmt.Errorf("%s: reserved ranges overlap: %d to %d and %d to %d", scope, rsvd[i-1].start, rsvd[i-1].end, rsvd[i].start, rsvd[i].end)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: rsvd[i].node.start(), Underlying: fmt.Errorf("%s: reserved ranges overlap: %d to %d and %d to %d", scope, rsvd[i-1].start, rsvd[i-1].end, rsvd[i].start, rsvd[i].end)}); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -1424,12 +1404,16 @@
 	for _, ev := range ed.Value {
 		evn := res.getEnumValueNode(ev)
 		if _, ok := rsvdNames[ev.GetName()]; ok {
-			return ErrorWithSourcePos{Pos: evn.getName().start(), Underlying: fmt.Errorf("%s: value %s is using a reserved name", scope, ev.GetName())}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: evn.getName().start(), Underlying: fmt.Errorf("%s: value %s is using a reserved name", scope, ev.GetName())}); err != nil {
+				return err
+			}
 		}
 		// check reserved ranges
 		r := sort.Search(len(rsvd), func(index int) bool { return rsvd[index].end >= ev.GetNumber() })
 		if r < len(rsvd) && rsvd[r].start <= ev.GetNumber() {
-			return ErrorWithSourcePos{Pos: evn.getNumber().start(), Underlying: fmt.Errorf("%s: value %s is using number %d which is in reserved range %d to %d", scope, ev.GetName(), ev.GetNumber(), rsvd[r].start, rsvd[r].end)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: evn.getNumber().start(), Underlying: fmt.Errorf("%s: value %s is using number %d which is in reserved range %d to %d", scope, ev.GetName(), ev.GetNumber(), rsvd[r].start, rsvd[r].end)}); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -1443,23 +1427,34 @@
 	if isProto3 {
 		if fld.GetType() == dpb.FieldDescriptorProto_TYPE_GROUP {
 			n := node.(*groupNode)
-			return ErrorWithSourcePos{Pos: n.groupKeyword.start(), Underlying: fmt.Errorf("%s: groups are not allowed in proto3", scope)}
-		}
-		if fld.Label != nil && fld.GetLabel() != dpb.FieldDescriptorProto_LABEL_REPEATED {
-			return ErrorWithSourcePos{Pos: node.fieldLabel().start(), Underlying: fmt.Errorf("%s: field has label %v, but proto3 should omit labels other than 'repeated'", scope, fld.GetLabel())}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: n.groupKeyword.start(), Underlying: fmt.Errorf("%s: groups are not allowed in proto3", scope)}); err != nil {
+				return err
+			}
+		} else if fld.Label != nil && fld.GetLabel() != dpb.FieldDescriptorProto_LABEL_REPEATED {
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: node.fieldLabel().start(), Underlying: fmt.Errorf("%s: field has label %v, but proto3 must omit labels other than 'repeated'", scope, fld.GetLabel())}); err != nil {
+				return err
+			}
 		}
 		if index, err := findOption(res, scope, fld.Options.GetUninterpretedOption(), "default"); err != nil {
-			return err
+			if err := res.errs.handleError(err); err != nil {
+				return err
+			}
 		} else if index >= 0 {
 			optNode := res.getOptionNode(fld.Options.GetUninterpretedOption()[index])
-			return ErrorWithSourcePos{Pos: optNode.getName().start(), Underlying: fmt.Errorf("%s: default values are not allowed in proto3", scope)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: optNode.getName().start(), Underlying: fmt.Errorf("%s: default values are not allowed in proto3", scope)}); err != nil {
+				return err
+			}
 		}
 	} else {
 		if fld.Label == nil && fld.OneofIndex == nil {
-			return ErrorWithSourcePos{Pos: node.fieldName().start(), Underlying: fmt.Errorf("%s: field has no label, but proto2 must indicate 'optional' or 'required'", scope)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: node.fieldName().start(), Underlying: fmt.Errorf("%s: field has no label, but proto2 must indicate 'optional' or 'required'", scope)}); err != nil {
+				return err
+			}
 		}
 		if fld.GetExtendee() != "" && fld.Label != nil && fld.GetLabel() == dpb.FieldDescriptorProto_LABEL_REQUIRED {
-			return ErrorWithSourcePos{Pos: node.fieldLabel().start(), Underlying: fmt.Errorf("%s: extension fields cannot be 'required'", scope)}
+			if err := res.errs.handleError(ErrorWithSourcePos{Pos: node.fieldLabel().start(), Underlying: fmt.Errorf("%s: extension fields cannot be 'required'", scope)}); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -1467,6 +1462,7 @@
 	if fld.Label == nil {
 		fld.Label = dpb.FieldDescriptorProto_LABEL_OPTIONAL.Enum()
 	}
+
 	return nil
 }
 
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y b/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y
index faf49d9..a795fe7 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y
@@ -25,6 +25,7 @@
 	msgDecls  []*messageElement
 	fld       *fieldNode
 	mapFld    *mapFieldNode
+	mapType   *mapTypeNode
 	grp       *groupNode
 	oo        *oneOfNode
 	ooDecls   []*oneOfElement
@@ -41,15 +42,18 @@
 	rpcType   *rpcTypeNode
 	opts      []*optionNode
 	optNm     []*optionNamePartNode
+	cmpctOpts *compactOptionsNode
 	rngs      []*rangeNode
-	names     []*stringLiteralNode
+	names     []*compoundStringNode
+	cid       *compoundIdentNode
 	sl        []valueNode
 	agg       []*aggregateEntryNode
 	aggName   *aggregateNameNode
 	v         valueNode
-	str       *stringLiteralNode
-	i         *negativeIntLiteralNode
-	ui        *intLiteralNode
+	il        *compoundIntNode
+	str       *compoundStringNode
+	s         *stringLiteralNode
+	i         *intLiteralNode
 	f         *floatLiteralNode
 	id        *identNode
 	b         *basicNode
@@ -63,20 +67,21 @@
 %type <fileDecls> fileDecl fileDecls
 %type <imprt>     import
 %type <pkg>       package
-%type <opts>      option fieldOption fieldOptions rpcOption rpcOptions
+%type <opts>      option compactOption compactOptionDecls rpcOption rpcOptions
 %type <optNm>     optionName optionNameRest optionNameComponent
-%type <v>         constant scalarConstant aggregate
-%type <id>        name ident typeIdent keyType
+%type <cmpctOpts> compactOptions
+%type <v>         constant scalarConstant aggregate uintLit floatLit
+%type <il>        intLit negIntLit
+%type <id>        name keyType
+%type <cid>       ident typeIdent
 %type <aggName>   aggName
-%type <i>         negIntLit
-%type <ui>        intLit
-%type <f>         floatLit
 %type <sl>        constantList
 %type <agg>       aggFields aggField aggFieldEntry
 %type <fld>       field oneofField
 %type <oo>        oneof
-%type <grp>       group
+%type <grp>       group oneofGroup
 %type <mapFld>    mapField
+%type <mapType>   mapType
 %type <msg>       message
 %type <msgDecls>  messageItem messageBody
 %type <ooDecls>   oneofItem oneofBody
@@ -96,10 +101,10 @@
 %type <rpcType>   rpcType
 
 // same for terminals
-%token <str> _STRING_LIT
-%token <ui>  _INT_LIT
+%token <s> _STRING_LIT
+%token <i>  _INT_LIT
 %token <f>   _FLOAT_LIT
-%token <id>  _NAME _FQNAME _TYPENAME
+%token <id>  _NAME
 %token <id>  _SYNTAX _IMPORT _WEAK _PUBLIC _PACKAGE _OPTION _TRUE _FALSE _INF _NAN _REPEATED _OPTIONAL _REQUIRED
 %token <id>  _DOUBLE _FLOAT _INT32 _INT64 _UINT32 _UINT64 _SINT32 _SINT64 _FIXED32 _FIXED64 _SFIXED32 _SFIXED64
 %token <id>  _BOOL _STRING _BYTES _GROUP _ONEOF _MAP _EXTENSIONS _TO _MAX _RESERVED _ENUM _MESSAGE _EXTEND
@@ -166,6 +171,10 @@
 	| ';' {
 		$$ = []*fileElement{{empty: $1}}
 	}
+	| error ';' {
+	}
+	| error {
+	}
 
 syntax : _SYNTAX '=' stringLit ';' {
 		if $3.val != "proto2" && $3.val != "proto3" {
@@ -193,8 +202,14 @@
 		$$.setRange($1, $3)
 	}
 
-ident : name
-	| _FQNAME
+ident : name {
+        $$ = &compoundIdentNode{val: $1.val}
+        $$.setRange($1, $1)
+    }
+	| ident '.' name {
+        $$ = &compoundIdentNode{val: $1.val + "." + $3.val}
+        $$.setRange($1, $3)
+	}
 
 option : _OPTION optionName '=' constant ';' {
 		n := &optionNameNode{parts: $2}
@@ -225,7 +240,7 @@
 		$$ = append($1, $2...)
 	}
 
-optionNameComponent : _TYPENAME {
+optionNameComponent : typeIdent {
 		$$ = toNameParts($1, 1 /* exclude leading dot */)
 	}
 	| '.' '(' typeIdent ')' {
@@ -240,26 +255,22 @@
 scalarConstant : stringLit {
 		$$ = $1
 	}
-	| intLit {
-		$$ = $1
-	}
+	| uintLit
 	| negIntLit {
-		$$ = $1
+	    $$ = $1
 	}
-	| floatLit {
-		$$ = $1
-	}
+	| floatLit
 	| name {
 		if $1.val == "true" {
-			$$ = &boolLiteralNode{basicNode: $1.basicNode, val: true}
+			$$ = &boolLiteralNode{identNode: $1, val: true}
 		} else if $1.val == "false" {
-			$$ = &boolLiteralNode{basicNode: $1.basicNode, val: false}
+			$$ = &boolLiteralNode{identNode: $1, val: false}
 		} else if $1.val == "inf" {
-			f := &floatLiteralNode{val: math.Inf(1)}
+			f := &compoundFloatNode{val: math.Inf(1)}
 			f.setRange($1, $1)
 			$$ = f
 		} else if $1.val == "nan" {
-			f := &floatLiteralNode{val: math.NaN()}
+			f := &compoundFloatNode{val: math.NaN()}
 			f.setRange($1, $1)
 			$$ = f
 		} else {
@@ -267,40 +278,65 @@
 		}
 	}
 
-intLit : _INT_LIT
+uintLit : _INT_LIT {
+        i := &compoundUintNode{val: $1.val}
+        i.setRange($1, $1)
+        $$ = i
+    }
 	| '+' _INT_LIT {
-		$$ = $2
+        i := &compoundUintNode{val: $2.val}
+        i.setRange($1, $2)
+        $$ = i
 	}
 
 negIntLit : '-' _INT_LIT {
 		if $2.val > math.MaxInt64 + 1 {
 			lexError(protolex, $2.start(), fmt.Sprintf("numeric constant %d would underflow (allowed range is %d to %d)", $2.val, int64(math.MinInt64), int64(math.MaxInt64)))
 		}
-		$$ = &negativeIntLiteralNode{val: -int64($2.val)}
-		$$.setRange($1, $2)
+		i := &compoundIntNode{val: -int64($2.val)}
+		i.setRange($1, $2)
+		$$ = i
 	}
 
-floatLit : _FLOAT_LIT
+intLit : negIntLit
+    | _INT_LIT {
+        // we don't allow uintLit because this is for enum numeric vals, which don't allow '+'
+        checkUint64InInt32Range(protolex, $1.start(), $1.val)
+		i := &compoundIntNode{val: int64($1.val)}
+		i.setRange($1, $1)
+		$$ = i
+    }
+
+floatLit : _FLOAT_LIT {
+        $$ = $1
+    }
 	| '-' _FLOAT_LIT {
-		$$ = &floatLiteralNode{val: -$2.val}
-		$$.setRange($1, $2)
+		f := &compoundFloatNode{val: -$2.val}
+		f.setRange($1, $2)
+		$$ = f
 	}
 	| '+' _FLOAT_LIT {
-		$$ = &floatLiteralNode{val: $2.val}
-		$$.setRange($1, $2)
+		f := &compoundFloatNode{val: $2.val}
+		f.setRange($1, $2)
+		$$ = f
 	}
 	| '+' _INF {
-		$$ = &floatLiteralNode{val: math.Inf(1)}
-		$$.setRange($1, $2)
+		f := &compoundFloatNode{val: math.Inf(1)}
+		f.setRange($1, $2)
+		$$ = f
 	}
 	| '-' _INF {
-		$$ = &floatLiteralNode{val: math.Inf(-1)}
-		$$.setRange($1, $2)
+		f := &compoundFloatNode{val: math.Inf(-1)}
+		f.setRange($1, $2)
+		$$ = f
 	}
 
-stringLit : _STRING_LIT
+stringLit : _STRING_LIT {
+        $$ = &compoundStringNode{val: $1.val}
+        $$.setRange($1, $1)
+    }
     | stringLit _STRING_LIT {
-        $$ = &stringLiteralNode{val: $1.val + $2.val}
+        $$ = &compoundStringNode{val: $1.val + $2.val}
         $$.setRange($1, $2)
     }
 
@@ -325,6 +361,12 @@
 	| aggFieldEntry ';' {
 		$$ = $1
 	}
+	| error ',' {
+	}
+	| error ';' {
+	}
+	| error {
+	}
 
 aggFieldEntry : aggName ':' scalarConstant {
 		a := &aggregateEntryNode{name: $1, val: $3}
@@ -345,6 +387,8 @@
 		a.setRange($1, $5)
 		$$ = []*aggregateEntryNode{a}
 	}
+	| aggName ':' '[' error ']' {
+	}
 	| aggName ':' aggregate {
 		a := &aggregateEntryNode{name: $1, val: $3}
 		a.setRange($1, $3)
@@ -369,15 +413,23 @@
 		a.setRange($1, $4)
 		$$ = []*aggregateEntryNode{a}
 	}
+	| aggName ':' '<' error '>' {
+	}
+	| aggName '<' error '>' {
+	}
 
 aggName : name {
-		$$ = &aggregateNameNode{name: $1}
+        n := &compoundIdentNode{val: $1.val}
+        n.setRange($1, $1)
+		$$ = &aggregateNameNode{name: n}
 		$$.setRange($1, $1)
 	}
-	| '[' ident ']' {
+	| '[' typeIdent ']' {
 		$$ = &aggregateNameNode{name: $2, isExtension: true}
 		$$.setRange($1, $3)
 	}
+	| '[' error ']' {
+	}
 
 constantList : constant {
 		$$ = []valueNode{$1}
@@ -403,25 +455,34 @@
 		s.setRange($3, $5)
 		$$ = append($1, s)
 	}
+	| '<' error '>' {
+	}
+	| constantList ','  '<' error '>' {
+	}
+	| constantList ';'  '<' error '>' {
+	}
 
 typeIdent : ident
-	| _TYPENAME
+    | '.' ident {
+          $$ = &compoundIdentNode{val: "." + $2.val}
+          $$.setRange($1, $2)
+    }
 
 field : _REQUIRED typeIdent name '=' _INT_LIT ';' {
 		checkTag(protolex, $5.start(), $5.val)
-		lbl := &labelNode{basicNode: $1.basicNode, required: true}
+		lbl := fieldLabel{identNode: $1, required: true}
 		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5}
 		$$.setRange($1, $6)
 	}
 	| _OPTIONAL typeIdent name '=' _INT_LIT ';' {
 		checkTag(protolex, $5.start(), $5.val)
-		lbl := &labelNode{basicNode: $1.basicNode}
+		lbl := fieldLabel{identNode: $1}
 		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5}
 		$$.setRange($1, $6)
 	}
 	| _REPEATED typeIdent name '=' _INT_LIT ';' {
 		checkTag(protolex, $5.start(), $5.val)
-		lbl := &labelNode{basicNode: $1.basicNode, repeated: true}
+		lbl := fieldLabel{identNode: $1, repeated: true}
 		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5}
 		$$.setRange($1, $6)
 	}
@@ -430,36 +491,41 @@
 		$$ = &fieldNode{fldType: $1, name: $2, tag: $4}
 		$$.setRange($1, $5)
 	}
-	| _REQUIRED typeIdent name '=' _INT_LIT '[' fieldOptions ']' ';' {
+	| _REQUIRED typeIdent name '=' _INT_LIT compactOptions ';' {
 		checkTag(protolex, $5.start(), $5.val)
-		lbl := &labelNode{basicNode: $1.basicNode, required: true}
-		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $7}
-		$$.setRange($1, $9)
+		lbl := fieldLabel{identNode: $1, required: true}
+		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $6}
+		$$.setRange($1, $7)
 	}
-	| _OPTIONAL typeIdent name '=' _INT_LIT '[' fieldOptions ']' ';' {
+	| _OPTIONAL typeIdent name '=' _INT_LIT compactOptions ';' {
 		checkTag(protolex, $5.start(), $5.val)
-		lbl := &labelNode{basicNode: $1.basicNode}
-		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $7}
-		$$.setRange($1, $9)
+		lbl := fieldLabel{identNode: $1}
+		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $6}
+		$$.setRange($1, $7)
 	}
-	| _REPEATED typeIdent name '=' _INT_LIT '[' fieldOptions ']' ';' {
+	| _REPEATED typeIdent name '=' _INT_LIT compactOptions ';' {
 		checkTag(protolex, $5.start(), $5.val)
-		lbl := &labelNode{basicNode: $1.basicNode, repeated: true}
-		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $7}
-		$$.setRange($1, $9)
+		lbl := fieldLabel{identNode: $1, repeated: true}
+		$$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $6}
+		$$.setRange($1, $7)
 	}
-	| typeIdent name '=' _INT_LIT '[' fieldOptions ']' ';' {
+	| typeIdent name '=' _INT_LIT compactOptions ';' {
 		checkTag(protolex, $4.start(), $4.val)
-		$$ = &fieldNode{fldType: $1, name: $2, tag: $4, options: $6}
-		$$.setRange($1, $8)
+		$$ = &fieldNode{fldType: $1, name: $2, tag: $4, options: $5}
+		$$.setRange($1, $6)
 	}
 
-fieldOptions : fieldOptions ',' fieldOption {
+compactOptions: '[' compactOptionDecls ']' {
+        $$ = &compactOptionsNode{decls: $2}
+        $$.setRange($1, $3)
+    }
+
+compactOptionDecls : compactOptionDecls ',' compactOption {
 		$$ = append($1, $3...)
 	}
-	| fieldOption
+	| compactOption
 
-fieldOption: optionName '=' constant {
+compactOption: optionName '=' constant {
 		n := &optionNameNode{parts: $1}
 		n.setRange($1[0], $1[len($1)-1])
 		o := &optionNode{name: n, val: $3}
@@ -472,7 +538,7 @@
 		if !unicode.IsUpper(rune($3.val[0])) {
 			lexError(protolex, $3.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $3.val))
 		}
-		lbl := &labelNode{basicNode: $1.basicNode, required: true}
+		lbl := fieldLabel{identNode: $1, required: true}
 		$$ = &groupNode{groupKeyword: $2, label: lbl, name: $3, tag: $5, decls: $7}
 		$$.setRange($1, $8)
 	}
@@ -481,7 +547,7 @@
 		if !unicode.IsUpper(rune($3.val[0])) {
 			lexError(protolex, $3.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $3.val))
 		}
-		lbl := &labelNode{basicNode: $1.basicNode}
+		lbl := fieldLabel{identNode: $1}
 		$$ = &groupNode{groupKeyword: $2, label: lbl, name: $3, tag: $5, decls: $7}
 		$$.setRange($1, $8)
 	}
@@ -490,7 +556,7 @@
 		if !unicode.IsUpper(rune($3.val[0])) {
 			lexError(protolex, $3.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $3.val))
 		}
-		lbl := &labelNode{basicNode: $1.basicNode, repeated: true}
+		lbl := fieldLabel{identNode: $1, repeated: true}
 		$$ = &groupNode{groupKeyword: $2, label: lbl, name: $3, tag: $5, decls: $7}
 		$$.setRange($1, $8)
 	}
@@ -523,31 +589,52 @@
 	| oneofField {
 		$$ = []*oneOfElement{{field: $1}}
 	}
+	| oneofGroup {
+		$$ = []*oneOfElement{{group: $1}}
+	}
 	| ';' {
 		$$ = []*oneOfElement{{empty: $1}}
 	}
+	| error ';' {
+	}
+	| error {
+	}
 
 oneofField : typeIdent name '=' _INT_LIT ';' {
 		checkTag(protolex, $4.start(), $4.val)
 		$$ = &fieldNode{fldType: $1, name: $2, tag: $4}
 		$$.setRange($1, $5)
 	}
-	| typeIdent name '=' _INT_LIT '[' fieldOptions ']' ';' {
+	| typeIdent name '=' _INT_LIT compactOptions ';' {
 		checkTag(protolex, $4.start(), $4.val)
-		$$ = &fieldNode{fldType: $1, name: $2, tag: $4, options: $6}
-		$$.setRange($1, $8)
+		$$ = &fieldNode{fldType: $1, name: $2, tag: $4, options: $5}
+		$$.setRange($1, $6)
 	}
 
-mapField : _MAP '<' keyType ',' typeIdent '>' name '=' _INT_LIT ';' {
-		checkTag(protolex, $9.start(), $9.val)
-		$$ = &mapFieldNode{mapKeyword: $1, keyType: $3, valueType: $5, name: $7, tag: $9}
-		$$.setRange($1, $10)
+oneofGroup : _GROUP name '=' _INT_LIT '{' messageBody '}' {
+		checkTag(protolex, $4.start(), $4.val)
+		if !unicode.IsUpper(rune($2.val[0])) {
+			lexError(protolex, $2.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $2.val))
+		}
+		$$ = &groupNode{groupKeyword: $1, name: $2, tag: $4, decls: $6}
+		$$.setRange($1, $7)
 	}
-	| _MAP '<' keyType ',' typeIdent '>' name '=' _INT_LIT '[' fieldOptions ']' ';' {
-		checkTag(protolex, $9.start(), $9.val)
-		$$ = &mapFieldNode{mapKeyword: $1, keyType: $3, valueType: $5, name: $7, tag: $9, options: $11}
-		$$.setRange($1, $13)
+
+mapField : mapType name '=' _INT_LIT ';' {
+		checkTag(protolex, $4.start(), $4.val)
+		$$ = &mapFieldNode{mapType: $1, name: $2, tag: $4}
+		$$.setRange($1, $5)
 	}
+	| mapType name '=' _INT_LIT compactOptions ';' {
+		checkTag(protolex, $4.start(), $4.val)
+		$$ = &mapFieldNode{mapType: $1, name: $2, tag: $4, options: $5}
+		$$.setRange($1, $6)
+	}
+
+mapType : _MAP '<' keyType ',' typeIdent '>' {
+        $$ = &mapTypeNode{mapKeyword: $1, keyType: $3, valueType: $5}
+        $$.setRange($1, $6)
+}
 
 keyType : _INT32
 	| _INT64
@@ -566,9 +653,9 @@
 		$$ = &extensionRangeNode{ranges: $2}
 		$$.setRange($1, $3)
 	}
-	| _EXTENSIONS tagRanges '[' fieldOptions ']' ';' {
-		$$ = &extensionRangeNode{ranges: $2, options: $4}
-		$$.setRange($1, $6)
+	| _EXTENSIONS tagRanges compactOptions ';' {
+		$$ = &extensionRangeNode{ranges: $2, options: $3}
+		$$.setRange($1, $4)
 	}
 
 tagRanges : tagRanges ',' tagRange {
@@ -612,29 +699,13 @@
 	}
 	| enumRange
 
-enumRange : _INT_LIT {
-		checkUint64InInt32Range(protolex, $1.start(), $1.val)
-		r := &rangeNode{stNode: $1, enNode: $1, st: int32($1.val), en: int32($1.val)}
-		r.setRange($1, $1)
-		$$ = []*rangeNode{r}
-	}
-	| negIntLit {
+enumRange : intLit {
 		checkInt64InInt32Range(protolex, $1.start(), $1.val)
 		r := &rangeNode{stNode: $1, enNode: $1, st: int32($1.val), en: int32($1.val)}
 		r.setRange($1, $1)
 		$$ = []*rangeNode{r}
 	}
-	| _INT_LIT _TO _INT_LIT {
-		checkUint64InInt32Range(protolex, $1.start(), $1.val)
-		checkUint64InInt32Range(protolex, $3.start(), $3.val)
-		if $1.val > $3.val {
-			lexError(protolex, $1.start(), fmt.Sprintf("range, %d to %d, is invalid: start must be <= end", $1.val, $3.val))
-		}
-		r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: int32($3.val)}
-		r.setRange($1, $3)
-		$$ = []*rangeNode{r}
-	}
-	| negIntLit _TO negIntLit {
+	| intLit _TO intLit {
 		checkInt64InInt32Range(protolex, $1.start(), $1.val)
 		checkInt64InInt32Range(protolex, $3.start(), $3.val)
 		if $1.val > $3.val {
@@ -644,20 +715,7 @@
 		r.setRange($1, $3)
 		$$ = []*rangeNode{r}
 	}
-	| negIntLit _TO _INT_LIT {
-		checkInt64InInt32Range(protolex, $1.start(), $1.val)
-		checkUint64InInt32Range(protolex, $3.start(), $3.val)
-		r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: int32($3.val)}
-		r.setRange($1, $3)
-		$$ = []*rangeNode{r}
-	}
-	| _INT_LIT _TO _MAX {
-		checkUint64InInt32Range(protolex, $1.start(), $1.val)
-		r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: math.MaxInt32}
-		r.setRange($1, $3)
-		$$ = []*rangeNode{r}
-	}
-	| negIntLit _TO _MAX {
+	| intLit _TO _MAX {
 		checkInt64InInt32Range(protolex, $1.start(), $1.val)
 		r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: math.MaxInt32}
 		r.setRange($1, $3)
@@ -693,7 +751,7 @@
 		$$ = append($1, $3)
 	}
 	| stringLit {
-		$$ = []*stringLiteralNode{$1}
+		$$ = []*compoundStringNode{$1}
 	}
 
 enum : _ENUM name '{' enumBody '}' {
@@ -730,26 +788,20 @@
 	| ';' {
 		$$ = []*enumElement{{empty: $1}}
 	}
+	| error ';' {
+	}
+	| error {
+	}
 
-enumField : name '=' _INT_LIT ';' {
-		checkUint64InInt32Range(protolex, $3.start(), $3.val)
-		$$ = &enumValueNode{name: $1, numberP: $3}
+enumField : name '=' intLit ';' {
+		checkInt64InInt32Range(protolex, $3.start(), $3.val)
+		$$ = &enumValueNode{name: $1, number: $3}
 		$$.setRange($1, $4)
 	}
-	|  name '=' _INT_LIT '[' fieldOptions ']' ';' {
-		checkUint64InInt32Range(protolex, $3.start(), $3.val)
-		$$ = &enumValueNode{name: $1, numberP: $3, options: $5}
-		$$.setRange($1, $7)
-	}
-	| name '=' negIntLit ';' {
+	|  name '=' intLit compactOptions ';' {
 		checkInt64InInt32Range(protolex, $3.start(), $3.val)
-		$$ = &enumValueNode{name: $1, numberN: $3}
-		$$.setRange($1, $4)
-	}
-	|  name '=' negIntLit '[' fieldOptions ']' ';' {
-		checkInt64InInt32Range(protolex, $3.start(), $3.val)
-		$$ = &enumValueNode{name: $1, numberN: $3, options: $5}
-		$$.setRange($1, $7)
+		$$ = &enumValueNode{name: $1, number: $3, options: $4}
+		$$.setRange($1, $5)
 	}
 
 message : _MESSAGE name '{' messageBody '}' {
@@ -798,6 +850,10 @@
 	| ';' {
 		$$ = []*messageElement{{empty: $1}}
 	}
+	| error ';' {
+	}
+	| error {
+	}
 
 extend : _EXTEND typeIdent '{' extendBody '}' {
 		c := 0
@@ -830,6 +886,10 @@
 	| ';' {
 		$$ = []*extendElement{{empty: $1}}
 	}
+	| error ';' {
+	}
+	| error {
+	}
 
 service : _SERVICE name '{' serviceBody '}' {
 		$$ = &serviceNode{name: $2, decls: $4}
@@ -856,6 +916,10 @@
 	| ';' {
 		$$ = []*serviceElement{{empty: $1}}
 	}
+	| error ';' {
+	}
+	| error {
+	}
 
 rpc : _RPC name '(' rpcType ')' _RETURNS '(' rpcType ')' ';' {
 		$$ = &methodNode{name: $2, input: $4, output: $8}
@@ -889,6 +953,10 @@
 	| ';' {
 		$$ = []*optionNode{}
 	}
+	| error ';' {
+	}
+	| error {
+	}
 
 name : _NAME
 	| _SYNTAX
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y.go
index 6b8a4e6..843df01 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/proto.y.go
@@ -29,6 +29,7 @@
 	msgDecls  []*messageElement
 	fld       *fieldNode
 	mapFld    *mapFieldNode
+	mapType   *mapTypeNode
 	grp       *groupNode
 	oo        *oneOfNode
 	ooDecls   []*oneOfElement
@@ -45,15 +46,18 @@
 	rpcType   *rpcTypeNode
 	opts      []*optionNode
 	optNm     []*optionNamePartNode
+	cmpctOpts *compactOptionsNode
 	rngs      []*rangeNode
-	names     []*stringLiteralNode
+	names     []*compoundStringNode
+	cid       *compoundIdentNode
 	sl        []valueNode
 	agg       []*aggregateEntryNode
 	aggName   *aggregateNameNode
 	v         valueNode
-	str       *stringLiteralNode
-	i         *negativeIntLiteralNode
-	ui        *intLiteralNode
+	il        *compoundIntNode
+	str       *compoundStringNode
+	s         *stringLiteralNode
+	i         *intLiteralNode
 	f         *floatLiteralNode
 	id        *identNode
 	b         *basicNode
@@ -64,51 +68,49 @@
 const _INT_LIT = 57347
 const _FLOAT_LIT = 57348
 const _NAME = 57349
-const _FQNAME = 57350
-const _TYPENAME = 57351
-const _SYNTAX = 57352
-const _IMPORT = 57353
-const _WEAK = 57354
-const _PUBLIC = 57355
-const _PACKAGE = 57356
-const _OPTION = 57357
-const _TRUE = 57358
-const _FALSE = 57359
-const _INF = 57360
-const _NAN = 57361
-const _REPEATED = 57362
-const _OPTIONAL = 57363
-const _REQUIRED = 57364
-const _DOUBLE = 57365
-const _FLOAT = 57366
-const _INT32 = 57367
-const _INT64 = 57368
-const _UINT32 = 57369
-const _UINT64 = 57370
-const _SINT32 = 57371
-const _SINT64 = 57372
-const _FIXED32 = 57373
-const _FIXED64 = 57374
-const _SFIXED32 = 57375
-const _SFIXED64 = 57376
-const _BOOL = 57377
-const _STRING = 57378
-const _BYTES = 57379
-const _GROUP = 57380
-const _ONEOF = 57381
-const _MAP = 57382
-const _EXTENSIONS = 57383
-const _TO = 57384
-const _MAX = 57385
-const _RESERVED = 57386
-const _ENUM = 57387
-const _MESSAGE = 57388
-const _EXTEND = 57389
-const _SERVICE = 57390
-const _RPC = 57391
-const _STREAM = 57392
-const _RETURNS = 57393
-const _ERROR = 57394
+const _SYNTAX = 57350
+const _IMPORT = 57351
+const _WEAK = 57352
+const _PUBLIC = 57353
+const _PACKAGE = 57354
+const _OPTION = 57355
+const _TRUE = 57356
+const _FALSE = 57357
+const _INF = 57358
+const _NAN = 57359
+const _REPEATED = 57360
+const _OPTIONAL = 57361
+const _REQUIRED = 57362
+const _DOUBLE = 57363
+const _FLOAT = 57364
+const _INT32 = 57365
+const _INT64 = 57366
+const _UINT32 = 57367
+const _UINT64 = 57368
+const _SINT32 = 57369
+const _SINT64 = 57370
+const _FIXED32 = 57371
+const _FIXED64 = 57372
+const _SFIXED32 = 57373
+const _SFIXED64 = 57374
+const _BOOL = 57375
+const _STRING = 57376
+const _BYTES = 57377
+const _GROUP = 57378
+const _ONEOF = 57379
+const _MAP = 57380
+const _EXTENSIONS = 57381
+const _TO = 57382
+const _MAX = 57383
+const _RESERVED = 57384
+const _ENUM = 57385
+const _MESSAGE = 57386
+const _EXTEND = 57387
+const _SERVICE = 57388
+const _RPC = 57389
+const _STREAM = 57390
+const _RETURNS = 57391
+const _ERROR = 57392
 
 var protoToknames = [...]string{
 	"$end",
@@ -118,8 +120,6 @@
 	"_INT_LIT",
 	"_FLOAT_LIT",
 	"_NAME",
-	"_FQNAME",
-	"_TYPENAME",
 	"_SYNTAX",
 	"_IMPORT",
 	"_WEAK",
@@ -198,433 +198,562 @@
 const protoErrCode = 2
 const protoInitialStackSize = 16
 
-//line proto.y:937
+//line proto.y:1005
 
 //line yacctab:1
 var protoExca = [...]int{
+	-1, 0,
+	1, 4,
+	-2, 0,
 	-1, 1,
 	1, -1,
 	-2, 0,
+	-1, 2,
+	1, 1,
+	-2, 0,
+	-1, 3,
+	1, 2,
+	-2, 0,
+	-1, 22,
+	1, 3,
+	-2, 0,
+	-1, 93,
+	55, 162,
+	-2, 0,
+	-1, 94,
+	55, 150,
+	-2, 0,
+	-1, 95,
+	55, 179,
+	-2, 0,
+	-1, 97,
+	55, 188,
+	-2, 0,
+	-1, 110,
+	55, 54,
+	-2, 0,
+	-1, 229,
+	61, 54,
+	-2, 0,
+	-1, 246,
+	55, 103,
+	-2, 0,
+	-1, 272,
+	61, 54,
+	-2, 0,
+	-1, 316,
+	61, 54,
+	-2, 0,
+	-1, 354,
+	55, 162,
+	-2, 0,
+	-1, 357,
+	55, 162,
+	-2, 0,
+	-1, 360,
+	55, 162,
+	-2, 0,
+	-1, 370,
+	61, 54,
+	-2, 0,
+	-1, 372,
+	61, 54,
+	-2, 0,
+	-1, 393,
+	55, 162,
+	-2, 0,
+	-1, 404,
+	55, 200,
+	-2, 0,
 }
 
 const protoPrivate = 57344
 
-const protoLast = 2050
+const protoLast = 2634
 
 var protoAct = [...]int{
 
-	120, 8, 288, 8, 8, 386, 264, 80, 128, 113,
-	159, 160, 265, 271, 103, 196, 185, 112, 100, 101,
-	29, 171, 8, 28, 75, 119, 99, 114, 79, 153,
-	137, 148, 266, 184, 24, 139, 306, 255, 77, 78,
-	319, 82, 306, 83, 389, 86, 87, 306, 318, 74,
-	378, 306, 98, 306, 306, 363, 317, 306, 306, 361,
-	306, 359, 351, 222, 379, 338, 337, 366, 307, 328,
-	377, 224, 325, 322, 304, 280, 278, 286, 223, 380,
-	315, 356, 367, 197, 329, 90, 243, 326, 323, 305,
-	281, 279, 297, 140, 111, 154, 27, 197, 249, 214,
-	209, 106, 188, 336, 246, 276, 241, 330, 240, 211,
-	105, 173, 245, 144, 242, 287, 224, 208, 381, 150,
-	382, 149, 176, 146, 327, 207, 324, 163, 16, 226,
-	94, 93, 92, 91, 177, 179, 181, 16, 199, 140,
-	79, 75, 85, 392, 199, 383, 368, 199, 374, 183,
-	78, 77, 373, 154, 16, 187, 191, 372, 199, 144,
-	198, 365, 157, 174, 85, 191, 74, 156, 355, 146,
-	189, 206, 212, 150, 193, 149, 388, 354, 204, 201,
-	163, 210, 203, 14, 333, 158, 15, 16, 157, 85,
-	85, 88, 97, 156, 213, 16, 202, 335, 215, 216,
-	217, 218, 219, 220, 308, 262, 261, 4, 14, 244,
-	260, 15, 16, 376, 96, 259, 258, 18, 17, 19,
-	20, 257, 254, 256, 221, 339, 13, 272, 252, 194,
-	105, 75, 163, 248, 388, 275, 250, 390, 283, 95,
-	84, 267, 18, 17, 19, 20, 89, 23, 247, 225,
-	352, 13, 268, 303, 168, 169, 27, 186, 290, 302,
-	198, 282, 277, 285, 295, 301, 206, 170, 300, 5,
-	299, 272, 105, 22, 163, 163, 284, 117, 11, 275,
-	11, 11, 165, 166, 310, 312, 313, 75, 314, 75,
-	269, 22, 27, 155, 298, 167, 311, 186, 316, 11,
-	25, 26, 263, 168, 293, 320, 85, 206, 27, 152,
-	12, 147, 331, 75, 75, 163, 163, 3, 141, 332,
-	21, 115, 10, 138, 10, 10, 118, 195, 142, 105,
-	345, 75, 206, 347, 75, 123, 349, 75, 190, 105,
-	105, 163, 346, 10, 270, 348, 116, 9, 350, 9,
-	9, 122, 357, 121, 358, 273, 176, 353, 176, 369,
-	176, 334, 163, 161, 163, 290, 292, 104, 9, 206,
-	206, 340, 342, 102, 375, 75, 162, 227, 163, 163,
-	172, 385, 7, 387, 6, 2, 387, 384, 75, 1,
-	0, 391, 27, 107, 110, 31, 0, 0, 32, 33,
+	31, 124, 8, 406, 8, 8, 116, 117, 169, 75,
+	309, 288, 293, 209, 196, 107, 210, 103, 181, 78,
+	79, 161, 83, 104, 8, 168, 123, 81, 133, 118,
+	155, 195, 102, 142, 105, 145, 391, 358, 346, 331,
+	241, 355, 352, 242, 30, 76, 345, 330, 243, 80,
+	26, 244, 244, 338, 344, 244, 244, 244, 328, 84,
+	347, 304, 87, 88, 276, 275, 401, 212, 244, 342,
+	321, 29, 212, 244, 115, 383, 244, 268, 212, 227,
+	110, 226, 203, 367, 303, 226, 90, 412, 229, 225,
+	398, 101, 109, 225, 396, 151, 146, 266, 393, 162,
+	226, 360, 399, 308, 226, 265, 92, 226, 225, 374,
+	96, 173, 225, 351, 357, 225, 320, 403, 354, 404,
+	89, 249, 157, 379, 186, 156, 213, 90, 153, 250,
+	248, 213, 377, 246, 194, 79, 78, 213, 243, 226,
+	198, 199, 224, 97, 183, 151, 146, 225, 95, 94,
+	223, 93, 165, 375, 366, 361, 86, 341, 335, 188,
+	190, 192, 162, 17, 14, 80, 76, 220, 211, 173,
+	4, 15, 165, 200, 16, 17, 202, 222, 153, 86,
+	205, 157, 218, 17, 156, 215, 86, 202, 409, 234,
+	235, 236, 237, 238, 239, 86, 228, 166, 285, 17,
+	219, 232, 164, 230, 100, 19, 18, 20, 21, 409,
+	216, 183, 96, 206, 13, 187, 167, 166, 25, 365,
+	17, 368, 164, 211, 264, 217, 14, 99, 109, 364,
+	173, 332, 283, 15, 98, 282, 16, 17, 408, 281,
+	280, 410, 290, 85, 279, 269, 278, 247, 294, 240,
+	207, 271, 91, 24, 289, 273, 267, 245, 286, 408,
+	29, 197, 277, 382, 381, 327, 326, 19, 18, 20,
+	21, 109, 76, 173, 173, 299, 13, 325, 291, 306,
+	324, 211, 222, 211, 307, 302, 121, 11, 323, 11,
+	11, 322, 119, 10, 294, 10, 10, 311, 317, 301,
+	336, 337, 5, 315, 197, 334, 23, 284, 305, 11,
+	178, 178, 179, 175, 176, 10, 86, 173, 173, 29,
+	163, 299, 180, 29, 177, 23, 222, 160, 329, 27,
+	28, 3, 340, 109, 22, 12, 154, 147, 144, 343,
+	122, 289, 348, 362, 208, 339, 109, 109, 148, 173,
+	127, 120, 9, 201, 9, 9, 292, 222, 140, 76,
+	126, 376, 296, 125, 378, 363, 353, 380, 356, 295,
+	359, 173, 170, 173, 9, 313, 172, 251, 369, 371,
+	108, 106, 182, 405, 186, 173, 186, 173, 186, 287,
+	7, 6, 2, 222, 394, 222, 384, 1, 386, 0,
+	400, 0, 0, 0, 0, 0, 407, 407, 186, 411,
+	0, 0, 311, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 314, 392, 29, 111, 114, 32,
+	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+	43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+	53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+	63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+	73, 74, 0, 0, 0, 0, 110, 0, 0, 0,
+	0, 0, 0, 0, 316, 112, 113, 0, 0, 0,
+	312, 29, 111, 114, 32, 33, 34, 35, 36, 37,
+	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
+	68, 69, 70, 71, 72, 73, 74, 0, 0, 0,
+	0, 110, 0, 0, 0, 0, 0, 0, 0, 272,
+	112, 113, 0, 0, 270, 29, 111, 114, 32, 33,
 	34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
 	54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 	64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
-	0, 0, 0, 0, 106, 0, 0, 0, 0, 0,
-	0, 0, 294, 108, 109, 0, 0, 0, 291, 27,
-	107, 110, 31, 0, 0, 32, 33, 34, 35, 36,
-	37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
-	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
-	57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
-	67, 68, 69, 70, 71, 72, 73, 0, 0, 0,
-	0, 106, 0, 0, 0, 0, 0, 0, 0, 253,
-	108, 109, 0, 0, 251, 27, 107, 110, 31, 0,
-	0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-	41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-	51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
-	61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
-	71, 72, 73, 0, 0, 0, 0, 106, 0, 0,
-	0, 0, 0, 0, 0, 343, 108, 109, 27, 107,
-	110, 31, 0, 0, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
-	106, 0, 0, 0, 0, 0, 0, 0, 341, 108,
-	109, 27, 107, 110, 31, 0, 0, 32, 33, 34,
+	74, 0, 0, 0, 0, 110, 0, 0, 0, 0,
+	0, 0, 0, 372, 112, 113, 29, 111, 114, 32,
+	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+	43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+	53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+	63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+	73, 74, 0, 0, 0, 0, 110, 0, 0, 0,
+	0, 0, 171, 0, 370, 112, 113, 32, 33, 34,
 	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
 	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
 	55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
-	65, 66, 67, 68, 69, 70, 71, 72, 73, 0,
-	0, 0, 0, 106, 0, 0, 0, 0, 0, 0,
-	0, 31, 108, 109, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 371, 0, 0,
-	0, 31, 0, 164, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 370, 0, 0,
-	0, 31, 0, 164, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 344, 0, 0,
-	0, 31, 0, 164, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 321, 0, 0,
-	0, 31, 0, 164, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 296, 0, 0,
-	0, 31, 0, 164, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
-	0, 205, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 31, 0, 164, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 228, 229, 230, 231,
-	232, 233, 234, 235, 236, 237, 238, 239, 0, 0,
-	0, 31, 30, 164, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
-	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-	68, 69, 70, 71, 72, 73, 0, 0, 0, 0,
+	65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 76, 31, 30, 81, 32, 33, 34, 35, 36,
-	133, 38, 39, 40, 41, 127, 126, 125, 45, 46,
-	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
-	57, 58, 59, 60, 134, 135, 132, 64, 65, 136,
-	129, 130, 131, 70, 71, 72, 73, 0, 0, 124,
-	0, 0, 364, 31, 30, 81, 32, 33, 34, 35,
-	36, 133, 38, 39, 40, 41, 127, 126, 125, 45,
-	46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
-	56, 57, 58, 59, 60, 134, 135, 132, 64, 65,
-	136, 129, 130, 131, 70, 71, 72, 73, 0, 0,
-	124, 0, 0, 362, 31, 30, 81, 32, 33, 34,
-	35, 36, 133, 38, 39, 40, 41, 127, 126, 125,
-	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
-	55, 56, 57, 58, 59, 60, 134, 135, 132, 64,
-	65, 136, 129, 130, 131, 70, 71, 72, 73, 0,
-	0, 124, 0, 0, 360, 31, 30, 81, 32, 33,
-	34, 35, 36, 133, 38, 39, 40, 41, 42, 43,
+	0, 397, 0, 171, 0, 0, 0, 174, 32, 33,
+	34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
 	54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 	64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
-	0, 0, 274, 0, 0, 309, 31, 30, 81, 32,
-	33, 34, 35, 36, 37, 38, 39, 40, 41, 127,
-	126, 125, 45, 46, 47, 48, 49, 50, 51, 52,
+	74, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 395, 0, 171, 0, 0, 0, 174, 32,
+	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+	43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
 	53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
 	63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
-	73, 0, 0, 151, 0, 0, 200, 31, 30, 81,
-	32, 33, 34, 35, 36, 133, 38, 39, 40, 41,
-	127, 126, 125, 45, 46, 47, 48, 49, 50, 51,
-	52, 53, 54, 55, 56, 57, 58, 59, 60, 134,
-	135, 132, 64, 65, 136, 129, 130, 131, 70, 71,
-	72, 73, 0, 0, 124, 31, 0, 175, 32, 33,
-	34, 35, 36, 133, 38, 39, 40, 41, 42, 43,
-	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
-	54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-	64, 65, 145, 67, 68, 69, 70, 71, 72, 73,
-	0, 0, 143, 0, 0, 192, 31, 30, 81, 32,
-	33, 34, 35, 36, 133, 38, 39, 40, 41, 127,
-	126, 125, 45, 46, 47, 48, 49, 50, 51, 52,
-	53, 54, 55, 56, 57, 58, 59, 60, 134, 135,
-	132, 64, 65, 136, 129, 130, 131, 70, 71, 72,
-	73, 0, 0, 124, 31, 30, 81, 32, 33, 34,
-	35, 36, 133, 38, 39, 40, 41, 42, 43, 44,
-	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
-	55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
-	65, 66, 67, 68, 69, 70, 71, 72, 73, 0,
-	0, 274, 31, 30, 81, 32, 33, 34, 35, 36,
-	37, 38, 39, 40, 41, 127, 126, 125, 45, 46,
+	73, 74, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 373, 0, 0, 0, 0, 0, 174,
+	29, 111, 114, 32, 33, 34, 35, 36, 37, 38,
+	39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+	49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
+	59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
+	69, 70, 71, 72, 73, 74, 0, 0, 0, 0,
+	110, 0, 0, 0, 0, 0, 171, 0, 0, 112,
+	113, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+	41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+	51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+	61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+	71, 72, 73, 74, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 350, 0, 171, 0, 0,
+	0, 174, 32, 33, 34, 35, 36, 37, 38, 39,
+	40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+	50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+	60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+	70, 71, 72, 73, 74, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 319, 0, 171, 0,
+	0, 0, 174, 32, 33, 34, 35, 36, 37, 38,
+	39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+	49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
+	59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
+	69, 70, 71, 72, 73, 74, 0, 0, 0, 0,
+	0, 221, 0, 0, 0, 0, 0, 0, 0, 387,
+	0, 0, 0, 174, 32, 33, 34, 35, 36, 37,
+	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
+	68, 69, 70, 71, 72, 73, 74, 252, 253, 254,
+	255, 256, 257, 258, 259, 260, 261, 262, 263, 0,
+	385, 0, 0, 0, 174, 32, 33, 34, 35, 36,
+	37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
 	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
 	57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
-	67, 68, 69, 70, 71, 72, 73, 31, 0, 151,
-	32, 33, 34, 35, 36, 133, 38, 39, 40, 41,
+	67, 68, 69, 70, 71, 72, 73, 74, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 349, 0, 0, 0, 174, 32, 33, 34, 35,
+	36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+	46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+	56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
+	66, 67, 68, 69, 70, 71, 72, 73, 74, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 318, 0, 0, 0, 174, 32, 33, 34,
+	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+	55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+	65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 274, 0, 0, 0, 174, 32, 33,
+	34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+	54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+	64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
+	74, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 171, 0, 0, 0, 174, 32,
+	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+	43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+	53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+	63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+	73, 74, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 174,
+	32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
 	42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
 	52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-	62, 63, 64, 65, 145, 67, 68, 69, 70, 71,
-	72, 73, 0, 0, 143, 31, 30, 81, 32, 33,
+	62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
+	72, 73, 74, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 77, 32,
+	33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+	43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+	53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
+	63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+	73, 74, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 129, 0, 0, 0, 233, 32, 33,
+	34, 35, 36, 37, 138, 39, 40, 41, 42, 132,
+	131, 130, 46, 47, 48, 49, 50, 51, 52, 53,
+	54, 55, 56, 57, 58, 59, 60, 61, 139, 143,
+	137, 65, 66, 141, 134, 135, 136, 71, 72, 73,
+	74, 0, 0, 128, 0, 0, 402, 129, 0, 0,
+	82, 0, 32, 33, 34, 35, 36, 37, 138, 39,
+	40, 41, 42, 132, 131, 130, 46, 47, 48, 49,
+	50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+	60, 61, 139, 143, 137, 65, 66, 141, 134, 135,
+	136, 71, 72, 73, 74, 0, 0, 128, 0, 0,
+	390, 129, 0, 0, 82, 0, 32, 33, 34, 35,
+	36, 37, 138, 39, 40, 41, 42, 132, 131, 130,
+	46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+	56, 57, 58, 59, 60, 61, 139, 143, 137, 65,
+	66, 141, 134, 135, 136, 71, 72, 73, 74, 0,
+	0, 128, 0, 0, 389, 129, 0, 0, 82, 0,
+	32, 33, 34, 35, 36, 37, 138, 39, 40, 41,
+	42, 132, 131, 130, 46, 47, 48, 49, 50, 51,
+	52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+	139, 143, 137, 65, 66, 141, 134, 135, 136, 71,
+	72, 73, 74, 0, 0, 128, 0, 0, 388, 298,
+	0, 0, 82, 0, 32, 33, 34, 35, 36, 37,
+	138, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+	58, 59, 60, 300, 62, 63, 64, 65, 66, 67,
+	68, 69, 70, 71, 72, 73, 74, 0, 0, 297,
+	0, 0, 333, 159, 0, 0, 82, 0, 32, 33,
+	34, 35, 36, 37, 38, 39, 40, 41, 42, 132,
+	131, 130, 46, 47, 48, 49, 50, 51, 52, 53,
+	54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+	64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
+	74, 0, 0, 158, 0, 0, 214, 129, 0, 0,
+	82, 0, 32, 33, 34, 35, 36, 37, 138, 39,
+	40, 41, 42, 132, 131, 130, 46, 47, 48, 49,
+	50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+	60, 61, 139, 143, 137, 65, 66, 141, 134, 135,
+	136, 71, 72, 73, 74, 0, 0, 128, 0, 0,
+	185, 129, 0, 0, 82, 0, 32, 33, 34, 35,
+	36, 37, 138, 39, 40, 41, 42, 132, 131, 130,
+	46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+	56, 57, 58, 59, 60, 61, 139, 143, 137, 65,
+	66, 141, 134, 135, 136, 71, 72, 73, 74, 0,
+	0, 128, 0, 0, 298, 0, 0, 0, 82, 32,
+	33, 34, 35, 36, 37, 138, 39, 40, 41, 42,
+	43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+	53, 54, 55, 56, 57, 58, 59, 60, 300, 62,
+	63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+	73, 74, 0, 0, 297, 0, 0, 159, 0, 0,
+	0, 82, 32, 33, 34, 35, 36, 37, 38, 39,
+	40, 41, 42, 132, 131, 130, 46, 47, 48, 49,
+	50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+	60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+	70, 71, 72, 73, 74, 0, 0, 158, 0, 0,
+	231, 0, 0, 0, 82, 32, 33, 34, 35, 36,
+	37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+	57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
+	67, 68, 69, 70, 71, 72, 73, 74, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 82, 32, 33,
 	34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
 	54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-	64, 65, 66, 67, 68, 69, 70, 71, 289, 73,
-	31, 30, 81, 32, 33, 34, 35, 36, 37, 38,
+	64, 65, 66, 67, 68, 69, 70, 71, 72, 310,
+	74, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	82, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+	41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+	51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+	61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+	71, 72, 73, 74, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 82, 32, 33, 34, 35, 36, 37,
+	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+	58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
+	68, 69, 70, 71, 72, 73, 74, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 184, 32, 33, 34,
+	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+	55, 56, 57, 58, 59, 60, 193, 62, 63, 64,
+	65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 82,
+	32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+	42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+	52, 53, 54, 55, 56, 57, 58, 59, 60, 191,
+	62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
+	72, 73, 74, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 82, 32, 33, 34, 35, 36, 37, 38,
 	39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
 	49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
-	59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
-	69, 70, 71, 72, 73, 31, 30, 81, 32, 33,
-	34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
-	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
-	54, 55, 56, 57, 58, 59, 182, 61, 62, 63,
-	64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
-	31, 30, 81, 32, 33, 34, 35, 36, 37, 38,
-	39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
-	49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
-	59, 180, 61, 62, 63, 64, 65, 66, 67, 68,
-	69, 70, 71, 72, 73, 31, 30, 81, 32, 33,
-	34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
-	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
-	54, 55, 56, 57, 58, 59, 178, 61, 62, 63,
-	64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
-	31, 30, 0, 32, 33, 34, 35, 36, 37, 38,
-	39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
-	49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
-	59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
-	69, 70, 71, 72, 73, 31, 0, 0, 32, 33,
-	34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
-	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
-	54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-	64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
+	59, 60, 189, 62, 63, 64, 65, 66, 67, 68,
+	69, 70, 71, 72, 73, 74, 0, 0, 0, 0,
+	0, 150, 0, 0, 0, 82, 32, 33, 34, 35,
+	36, 37, 138, 39, 40, 41, 42, 43, 44, 45,
+	46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+	56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
+	66, 152, 68, 69, 70, 71, 72, 73, 74, 0,
+	150, 149, 0, 0, 204, 32, 33, 34, 35, 36,
+	37, 138, 39, 40, 41, 42, 43, 44, 45, 46,
+	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+	57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
+	152, 68, 69, 70, 71, 72, 73, 74, 0, 0,
+	149, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+	41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+	51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+	61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+	71, 72, 73, 74,
 }
 var protoPact = [...]int{
 
-	197, -1000, 172, 172, 194, -1000, -1000, -1000, -1000, -1000,
-	-1000, -1000, -1000, -1000, 288, 1953, 1124, 1998, 1998, 1773,
-	1998, 172, -1000, 304, 186, 304, 304, -1000, 137, -1000,
+	162, -1000, 224, 224, 202, -1000, -1000, -1000, -1000, -1000,
+	-1000, -1000, -1000, -1000, 166, 319, 2584, 1463, 2584, 2584,
+	2224, 2584, 224, -1000, 315, -1000, 191, 315, 315, -1000,
+	68, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	-1000, -1000, -1000, -1000, 193, -1000, 1773, 77, 76, 75,
-	-1000, -1000, 74, 185, -1000, -1000, 160, 138, -1000, 647,
-	26, 1539, 1680, 1635, 113, -1000, -1000, -1000, 131, -1000,
-	-1000, 302, -1000, -1000, -1000, -1000, 1064, -1000, 277, 249,
-	-1000, 102, 1440, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	-1000, -1000, -1000, -1000, -1000, 1908, 1863, 1818, 1998, 1998,
-	1998, 1773, 292, 1124, 1998, 38, 252, -1000, 1488, -1000,
-	-1000, -1000, -1000, -1000, 176, 92, -1000, 1389, -1000, -1000,
-	-1000, -1000, 139, -1000, -1000, -1000, -1000, 1998, -1000, 1004,
-	-1000, 63, 45, -1000, 1953, -1000, -1000, -1000, -1000, -1000,
-	-1000, -1000, 102, -1000, 32, -1000, -1000, 1998, 1998, 1998,
-	1998, 1998, 1998, 171, 9, -1000, 207, 73, 1091, 54,
-	52, 302, -1000, -1000, 81, 50, -1000, 206, 191, 298,
-	-1000, -1000, -1000, -1000, 31, -1000, -1000, -1000, -1000, 455,
-	-1000, 1064, -33, -1000, 1773, 168, 163, 162, 157, 153,
-	152, 297, -1000, 1124, 292, 247, 1587, 43, -1000, -1000,
-	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-	-1000, -1000, 304, 22, 21, 78, -1000, 233, 72, 1728,
-	-1000, 388, -1000, 1064, 944, -1000, 24, 289, 265, 263,
-	260, 254, 248, 20, -2, -1000, 151, -1000, -1000, -1000,
-	1338, -1000, -1000, -1000, -1000, 1998, 1773, 302, -1000, 1124,
-	-1000, 1124, -1000, -1000, -1000, -1000, -1000, -1000, 12, 1773,
-	-1000, -1000, -14, -1000, 1064, 884, -1000, -1000, 19, 70,
-	18, 68, 15, 51, -1000, 1124, 1124, 130, 647, -1000,
-	-1000, 144, 40, -4, -5, 174, -1000, -1000, 584, 521,
-	824, -1000, -1000, 1124, 1539, -1000, 1124, 1539, -1000, 1124,
-	1539, -8, -1000, -1000, -1000, 245, 1998, 123, 114, 14,
-	-1000, 1064, -1000, 1064, -1000, -9, 1287, -11, 1236, -15,
-	1185, 107, 13, 93, -1000, -1000, 1728, 764, 704, 103,
-	-1000, 98, -1000, 94, -1000, -1000, -1000, 1124, 208, 2,
-	-1000, -1000, -1000, -1000, -1000, -20, 10, 64, 91, -1000,
-	1124, -1000, 122, -1000, -26, 180, -1000, -1000, -1000, 89,
+	-1000, -1000, -1000, -1000, -1000, 201, 27, 2224, 97, 95,
+	94, 27, 2584, 89, 182, -1000, -1000, 175, 152, -1000,
+	2584, 856, 8, 1959, 2538, 2065, 27, 150, -1000, -1000,
+	-1000, -1000, 164, -1000, -1000, 312, -1000, -1000, -1000, -1000,
+	1402, -1000, 308, 306, -1000, 2277, 1905, -1000, -1000, -1000,
+	-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 163,
+	2436, 2383, 2330, 2584, 2584, 2584, 2224, 299, 1463, 2584,
+	2584, 256, -1000, 20, 2489, -1000, -1000, -1000, -1000, -1000,
+	161, 199, 67, -1000, 1851, -1000, -1000, -1000, -1000, 158,
+	170, -1000, -1000, -1000, -1000, 148, 2584, -1000, 1036, -1000,
+	90, 87, 26, -1000, 2118, -1000, -1000, -1000, -1000, -1000,
+	-1000, -1000, 2277, -1000, 1522, -1000, -1000, -1000, 2584, 2584,
+	2584, 2584, 2584, 2584, 198, -12, -1000, 217, 79, 196,
+	78, 69, 312, 1124, -1000, -1000, -1000, 73, 45, -1000,
+	216, -1000, -1000, 305, -1000, -1000, -1000, -1000, -1000, -1000,
+	12, -1000, -1000, -1000, -1000, -1000, -1000, 487, -1000, 1341,
+	-3, -4, -1000, 2224, 195, 193, 189, 188, 184, 181,
+	302, -1000, 146, 299, 1463, 237, 2012, 294, -1000, -1000,
+	315, 24, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
+	-1000, -1000, -1000, -1000, 9, 73, -1000, 62, 2171, -1000,
+	422, -1000, 1280, 975, 55, -1000, -1000, 4, 286, 283,
+	275, 272, 261, 260, 6, -1000, -1000, -21, -1000, 180,
+	-1000, -1000, 1797, -1000, -1000, -1000, -1000, -1000, 106, 2584,
+	2584, 1, 312, 2224, -1000, 105, -1000, -1000, -1000, 3,
+	2224, -1000, -1000, -14, -8, -1000, 1219, 914, 52, -1000,
+	-1000, -1000, -10, 64, -11, 60, -15, 47, -1000, 103,
+	-1000, 1463, 856, -1000, -1000, -1000, 178, 168, -1000, 102,
+	22, -1000, 172, -1000, -1000, 612, 551, -1000, 792, 48,
+	-1000, -1000, -1000, 101, 1959, -1000, 80, 1959, -1000, 71,
+	1959, -1000, -1000, -1000, 259, 258, -1000, -1000, 10, -1000,
+	1158, -1000, 1097, -1000, -1000, -1000, 1743, -1000, 1689, -1000,
+	1635, -16, 44, 2171, 731, 33, 670, 29, -1000, -1000,
+	-1000, -1000, 50, 1959, 0, -1000, -1000, -1000, -1000, -1000,
+	1581, 65, -1000, -1000, 207, 186, -1000, -1000, -1000, 35,
 	-1000, -1000, -1000,
 }
 var protoPgo = [...]int{
 
-	0, 389, 385, 269, 317, 384, 382, 0, 12, 6,
-	5, 381, 32, 21, 380, 52, 26, 18, 20, 7,
-	8, 377, 376, 14, 373, 367, 366, 10, 11, 363,
-	27, 355, 353, 25, 351, 346, 9, 17, 13, 344,
-	338, 335, 328, 30, 16, 33, 15, 327, 326, 321,
-	35, 323, 318, 277, 31, 311, 19, 310, 29, 309,
-	293, 2,
+	0, 397, 392, 302, 331, 391, 390, 1, 11, 389,
+	3, 383, 9, 18, 382, 43, 32, 17, 23, 381,
+	380, 16, 15, 0, 377, 27, 28, 376, 375, 25,
+	8, 372, 29, 369, 363, 26, 362, 360, 358, 351,
+	7, 6, 12, 356, 353, 350, 348, 33, 14, 31,
+	13, 344, 340, 292, 35, 338, 337, 286, 30, 336,
+	34, 335, 21, 327, 320, 10,
 }
 var protoR1 = [...]int{
 
 	0, 1, 1, 1, 1, 4, 4, 3, 3, 3,
-	3, 3, 3, 3, 3, 2, 5, 5, 5, 6,
-	19, 19, 7, 12, 12, 12, 13, 13, 14, 14,
-	15, 15, 16, 16, 16, 16, 16, 24, 24, 23,
-	25, 25, 25, 25, 25, 56, 56, 17, 27, 27,
-	27, 28, 28, 28, 29, 29, 29, 29, 29, 29,
-	29, 22, 22, 26, 26, 26, 26, 26, 26, 20,
-	20, 30, 30, 30, 30, 30, 30, 30, 30, 9,
-	9, 8, 33, 33, 33, 32, 39, 39, 39, 38,
-	38, 38, 31, 31, 34, 34, 21, 21, 21, 21,
-	21, 21, 21, 21, 21, 21, 21, 21, 48, 48,
-	45, 45, 44, 44, 44, 47, 47, 46, 46, 46,
-	46, 46, 46, 46, 41, 41, 42, 42, 43, 40,
-	40, 49, 51, 51, 51, 50, 50, 50, 50, 52,
-	52, 52, 52, 35, 37, 37, 37, 36, 36, 36,
-	36, 36, 36, 36, 36, 36, 36, 36, 53, 55,
-	55, 55, 54, 54, 54, 57, 59, 59, 59, 58,
-	58, 58, 60, 60, 61, 61, 11, 11, 11, 10,
-	10, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-	18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-	18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-	18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
-	18, 18, 18, 18,
+	3, 3, 3, 3, 3, 3, 3, 2, 5, 5,
+	5, 6, 25, 25, 7, 12, 12, 12, 13, 13,
+	14, 14, 16, 16, 17, 17, 17, 17, 17, 19,
+	19, 22, 21, 21, 20, 20, 20, 20, 20, 60,
+	60, 18, 29, 29, 29, 30, 30, 30, 30, 30,
+	30, 31, 31, 31, 31, 31, 31, 31, 31, 31,
+	31, 27, 27, 27, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 26, 26, 32, 32, 32, 32, 32,
+	32, 32, 32, 15, 9, 9, 8, 35, 35, 35,
+	34, 43, 43, 43, 42, 42, 42, 42, 42, 42,
+	33, 33, 36, 37, 37, 38, 24, 24, 24, 24,
+	24, 24, 24, 24, 24, 24, 24, 24, 52, 52,
+	49, 49, 48, 48, 48, 51, 51, 50, 50, 50,
+	45, 45, 46, 46, 47, 44, 44, 53, 55, 55,
+	55, 54, 54, 54, 54, 54, 54, 56, 56, 39,
+	41, 41, 41, 40, 40, 40, 40, 40, 40, 40,
+	40, 40, 40, 40, 40, 40, 57, 59, 59, 59,
+	58, 58, 58, 58, 58, 61, 63, 63, 63, 62,
+	62, 62, 62, 62, 64, 64, 65, 65, 11, 11,
+	11, 10, 10, 10, 10, 23, 23, 23, 23, 23,
+	23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+	23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+	23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+	23, 23, 23, 23, 23, 23, 23, 23,
 }
 var protoR2 = [...]int{
 
 	0, 1, 1, 2, 0, 2, 1, 1, 1, 1,
-	1, 1, 1, 1, 1, 4, 3, 4, 4, 3,
-	1, 1, 5, 1, 3, 4, 1, 2, 1, 4,
-	1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
-	1, 2, 2, 2, 2, 1, 2, 3, 1, 2,
-	0, 1, 2, 2, 3, 4, 5, 3, 2, 5,
-	4, 1, 3, 1, 3, 3, 3, 5, 5, 1,
-	1, 6, 6, 6, 5, 9, 9, 9, 8, 3,
-	1, 3, 8, 8, 8, 5, 2, 1, 0, 1,
-	1, 1, 5, 8, 10, 13, 1, 1, 1, 1,
-	1, 1, 1, 1, 1, 1, 1, 1, 3, 6,
-	3, 1, 1, 3, 3, 3, 1, 1, 1, 3,
-	3, 3, 3, 3, 3, 1, 3, 1, 3, 3,
-	1, 5, 2, 1, 0, 1, 1, 1, 1, 4,
-	7, 4, 7, 5, 2, 1, 0, 1, 1, 1,
-	1, 1, 1, 1, 1, 1, 1, 1, 5, 2,
-	1, 0, 1, 1, 1, 5, 2, 1, 0, 1,
-	1, 1, 10, 12, 2, 1, 2, 1, 0, 1,
+	1, 1, 1, 1, 1, 2, 1, 4, 3, 4,
+	4, 3, 1, 3, 5, 1, 3, 4, 1, 2,
+	1, 4, 1, 1, 1, 1, 1, 1, 1, 1,
+	2, 2, 1, 1, 1, 2, 2, 2, 2, 1,
+	2, 3, 1, 2, 0, 1, 2, 2, 2, 2,
+	1, 3, 4, 5, 5, 3, 2, 5, 4, 5,
+	4, 1, 3, 3, 1, 3, 3, 3, 5, 5,
+	3, 5, 5, 1, 2, 6, 6, 6, 5, 7,
+	7, 7, 6, 3, 3, 1, 3, 8, 8, 8,
+	5, 2, 1, 0, 1, 1, 1, 1, 2, 1,
+	5, 6, 7, 5, 6, 6, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 3, 4,
+	3, 1, 1, 3, 3, 3, 1, 1, 3, 3,
+	3, 1, 3, 1, 3, 3, 1, 5, 2, 1,
+	0, 1, 1, 1, 1, 2, 1, 4, 5, 5,
+	2, 1, 0, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 2, 1, 5, 2, 1, 0,
+	1, 1, 1, 2, 1, 5, 2, 1, 0, 1,
+	1, 1, 2, 1, 10, 12, 2, 1, 2, 1,
+	0, 1, 1, 2, 1, 1, 1, 1, 1, 1,
 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-	1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
 }
 var protoChk = [...]int{
 
-	-1000, -1, -2, -4, 10, -3, -5, -6, -7, -35,
-	-49, -53, -57, 54, 11, 14, 15, 46, 45, 47,
-	48, -4, -3, 53, -56, 12, 13, 4, -19, -18,
-	8, 7, 10, 11, 12, 13, 14, 15, 16, 17,
-	18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
-	28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
-	38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	48, 49, 50, 51, -12, -19, 67, -18, -18, -20,
-	-19, 9, -18, -56, 54, 4, -56, -56, 54, 53,
-	-20, 56, 56, 56, 56, 54, 54, 54, -15, -16,
-	-17, -56, -24, -23, -25, -18, 56, 5, 65, 66,
-	6, 68, -37, -36, -30, -49, -35, -53, -48, -33,
-	-7, -32, -34, -41, 54, 22, 21, 20, -20, 45,
-	46, 47, 41, 15, 39, 40, 44, -43, -51, -50,
-	-7, -52, -42, 54, -18, 44, -43, -55, -54, -30,
-	-33, 54, -59, -58, -7, -60, 54, 49, 54, -27,
-	-28, -29, -22, -18, 69, 5, 6, 18, 5, 6,
-	18, -13, -14, 9, 61, 57, -36, -20, 38, -20,
-	38, -20, 38, -18, -45, -44, 5, -18, 64, -45,
-	-40, -56, 57, -50, 53, -47, -46, 5, -23, 66,
-	57, -54, 57, -58, -18, 57, -28, 62, 54, 55,
-	-17, 64, -19, -13, 67, -18, -18, -18, -18, -18,
-	-18, 53, 54, 69, 62, 42, 56, -21, 25, 26,
-	27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
-	54, 54, 62, 5, -23, 62, 54, 42, 42, 67,
-	-16, 69, -17, 64, -27, 70, -20, 53, 53, 53,
-	53, 53, 53, 5, -9, -8, -12, -44, 5, 43,
-	-39, -38, -7, -31, 54, -20, 62, -56, 54, 69,
-	54, 69, -46, 5, 43, -23, 5, 43, -61, 50,
-	-20, 70, -26, -15, 64, -27, 63, 68, 5, 5,
-	5, 5, 5, 5, 54, 69, 62, 70, 53, 57,
-	-38, -18, -20, -9, -9, 68, -20, 70, 62, 54,
-	-27, 63, 54, 69, 56, 54, 69, 56, 54, 69,
-	56, -9, -8, 54, -15, 53, 63, 70, 70, 51,
-	-15, 64, -15, 64, 63, -9, -37, -9, -37, -9,
-	-37, 70, 5, -18, 54, 54, 67, -27, -27, 70,
-	57, 70, 57, 70, 57, 54, 54, 69, 53, -61,
-	63, 63, 54, 54, 54, -9, 5, 68, 70, 54,
-	69, 54, 56, 54, -9, -11, -10, -7, 54, 70,
-	57, -10, 54,
+	-1000, -1, -2, -4, 8, -3, -5, -6, -7, -39,
+	-53, -57, -61, 52, 2, 9, 12, 13, 44, 43,
+	45, 46, -4, -3, 51, 52, -60, 10, 11, 4,
+	-25, -23, 7, 8, 9, 10, 11, 12, 13, 14,
+	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+	25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+	45, 46, 47, 48, 49, -12, -25, 65, -23, -23,
+	-26, -25, 59, -23, -60, 52, 4, -60, -60, 52,
+	59, 51, -26, 54, 54, 54, -25, 54, 52, 52,
+	52, -23, -16, -17, -18, -60, -19, -22, -20, -23,
+	54, 5, 63, 64, 6, 66, -41, -40, -32, -53,
+	-39, -57, -52, -35, -7, -34, -37, -45, 52, 2,
+	20, 19, 18, -26, 43, 44, 45, 39, 13, 37,
+	-38, 42, -47, 38, -55, -54, -7, -56, -46, 52,
+	2, -23, 42, -47, -59, -58, -32, -35, 52, 2,
+	-63, -62, -7, -64, 52, 2, 47, 52, -29, -30,
+	-31, 2, -27, -23, 67, 5, 6, 16, 5, 6,
+	16, -13, -14, -26, 59, 55, -40, 52, -26, 36,
+	-26, 36, -26, 36, -23, -49, -48, 5, -23, -23,
+	-49, -44, -60, 62, 55, -54, 52, 51, -51, -50,
+	-21, -22, 5, 64, 55, -58, 52, 55, -62, 52,
+	-23, 55, -30, 60, 52, 60, 52, 53, -18, 62,
+	-26, 2, -13, 65, -23, -23, -23, -23, -23, -23,
+	51, 52, -15, 60, 67, 40, 54, 51, 52, 52,
+	60, -24, 23, 24, 25, 26, 27, 28, 29, 30,
+	31, 32, 33, 34, -21, 60, 52, 40, 65, -17,
+	67, -18, 62, -29, 2, 68, 68, -26, 51, 51,
+	51, 51, 51, 51, 5, 52, -48, -9, -8, -12,
+	5, 41, -43, -42, -7, -33, -36, 52, 2, -26,
+	36, 5, -60, 60, 52, -15, -50, -21, 41, -65,
+	48, -26, 68, -28, 2, -16, 62, -29, 2, 61,
+	61, 66, 5, 5, 5, 5, 5, 5, 52, -15,
+	68, 60, 51, 55, -42, 52, -23, -23, 52, -15,
+	-26, 52, 66, -26, 68, 60, 52, 68, -29, 2,
+	61, 61, 52, -15, 54, 52, -15, 54, 52, -15,
+	54, 52, -8, -16, 51, 51, 52, 61, 49, -16,
+	62, -16, 62, 61, 61, 52, -41, 52, -41, 52,
+	-41, 5, 5, 65, -29, 2, -29, 2, 55, 55,
+	55, 52, -15, 54, -65, 61, 61, 61, 61, 52,
+	-41, 66, 55, 52, 54, -11, -10, -7, 52, 2,
+	55, -10, 52,
 }
 var protoDef = [...]int{
 
-	4, -2, 1, 2, 0, 6, 7, 8, 9, 10,
-	11, 12, 13, 14, 0, 0, 0, 0, 0, 0,
-	0, 3, 5, 0, 0, 0, 0, 45, 0, 20,
-	21, 181, 182, 183, 184, 185, 186, 187, 188, 189,
-	190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
-	200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
-	210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-	220, 221, 222, 223, 0, 23, 0, 0, 0, 0,
-	69, 70, 0, 0, 16, 46, 0, 0, 19, 0,
-	0, 146, 134, 161, 168, 15, 17, 18, 0, 30,
-	31, 32, 33, 34, 35, 36, 50, 37, 0, 0,
-	40, 24, 0, 145, 147, 148, 149, 150, 151, 152,
-	153, 154, 155, 156, 157, 0, 0, 0, 0, 0,
-	0, 0, 213, 187, 0, 212, 216, 125, 0, 133,
-	135, 136, 137, 138, 0, 216, 127, 0, 160, 162,
-	163, 164, 0, 167, 169, 170, 171, 0, 22, 0,
-	48, 51, 0, 61, 0, 38, 42, 43, 39, 41,
-	44, 25, 26, 28, 0, 143, 144, 0, 0, 0,
-	0, 0, 0, 0, 0, 111, 112, 0, 0, 0,
-	0, 130, 131, 132, 0, 0, 116, 117, 118, 0,
-	158, 159, 165, 166, 0, 47, 49, 52, 53, 0,
-	58, 50, 0, 27, 0, 0, 0, 0, 0, 0,
-	0, 0, 108, 0, 0, 0, 88, 0, 96, 97,
-	98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
-	124, 128, 0, 0, 0, 0, 126, 0, 0, 0,
-	54, 0, 57, 50, 0, 62, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 80, 0, 110, 113, 114,
-	0, 87, 89, 90, 91, 0, 0, 129, 139, 0,
-	141, 0, 115, 119, 122, 120, 121, 123, 0, 222,
-	175, 55, 0, 63, 50, 0, 60, 29, 0, 0,
-	0, 0, 0, 0, 74, 0, 0, 0, 0, 85,
-	86, 0, 0, 0, 0, 0, 174, 56, 0, 0,
-	0, 59, 71, 0, 146, 72, 0, 146, 73, 0,
-	146, 0, 79, 109, 81, 0, 0, 0, 0, 0,
-	64, 50, 65, 50, 66, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 140, 142, 0, 0, 0, 0,
-	82, 0, 83, 0, 84, 78, 92, 0, 0, 0,
-	67, 68, 75, 76, 77, 0, 0, 0, 0, 94,
-	0, 172, 178, 93, 0, 0, 177, 179, 180, 0,
-	173, 176, 95,
+	-2, -2, -2, -2, 0, 6, 7, 8, 9, 10,
+	11, 12, 13, 14, 16, 0, 0, 0, 0, 0,
+	0, 0, -2, 5, 0, 15, 0, 0, 0, 49,
+	0, 22, 205, 206, 207, 208, 209, 210, 211, 212,
+	213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
+	223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
+	233, 234, 235, 236, 237, 238, 239, 240, 241, 242,
+	243, 244, 245, 246, 247, 0, 25, 0, 0, 0,
+	0, 83, 0, 0, 0, 18, 50, 0, 0, 21,
+	0, 0, 0, -2, -2, -2, 84, -2, 17, 19,
+	20, 23, 0, 32, 33, 34, 35, 36, 37, 38,
+	-2, 39, 0, 0, 44, 26, 0, 161, 163, 164,
+	165, 166, 167, 168, 169, 170, 171, 172, 173, 175,
+	0, 0, 0, 0, 241, 242, 0, 237, 211, 235,
+	0, 240, 141, 236, 0, 149, 151, 152, 153, 154,
+	156, 0, 240, 143, 0, 178, 180, 181, 182, 184,
+	0, 187, 189, 190, 191, 193, 0, 24, 0, 52,
+	55, 60, 0, 71, 0, 40, 46, 47, 41, 45,
+	48, 27, 28, 30, 0, 159, 160, 174, 0, 234,
+	0, 234, 0, 234, 0, 0, 131, 132, 0, 0,
+	0, 0, 146, 0, 147, 148, 155, 0, 0, 136,
+	137, 42, 43, 0, 176, 177, 183, 185, 186, 192,
+	0, 51, 53, 56, 57, 58, 59, 0, 66, -2,
+	0, 0, 29, 0, 0, 0, 0, 0, 0, 0,
+	0, 128, 0, 0, 0, 0, -2, 0, 140, 144,
+	0, 0, 116, 117, 118, 119, 120, 121, 122, 123,
+	124, 125, 126, 127, 0, 0, 142, 0, 0, 61,
+	0, 65, -2, 0, 60, 72, 73, 0, 0, 0,
+	0, 0, 0, 0, 0, 129, 130, 0, 95, 0,
+	133, 134, 0, 102, 104, 105, 106, 107, 109, 0,
+	234, 0, 145, 0, 157, 0, 135, 138, 139, 0,
+	246, 197, 62, 0, 0, 74, -2, 0, 60, 68,
+	70, 31, 0, 0, 0, 0, 0, 0, 88, 0,
+	93, 0, 0, 100, 101, 108, 0, 0, 113, 0,
+	0, 158, 0, 196, 63, 0, 0, 64, 0, 60,
+	67, 69, 85, 0, -2, 86, 0, -2, 87, 0,
+	-2, 92, 94, 96, 0, 0, 114, 115, 0, 75,
+	-2, 76, -2, 77, 80, 89, 0, 90, 0, 91,
+	0, 0, 0, 0, 0, 60, 0, 60, 97, 98,
+	99, 110, 0, -2, 0, 78, 81, 79, 82, 111,
+	0, 0, 112, 194, -2, 0, 199, 201, 202, 204,
+	195, 198, 203,
 }
 var protoTok1 = [...]int{
 
 	1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 78, 3, 76, 75, 74, 72, 3,
-	67, 68, 71, 65, 62, 66, 61, 59, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 55, 54,
-	64, 53, 63, 60, 77, 3, 3, 3, 3, 3,
+	3, 3, 3, 76, 3, 74, 73, 72, 70, 3,
+	65, 66, 69, 63, 60, 64, 59, 57, 3, 3,
+	3, 3, 3, 3, 3, 3, 3, 3, 53, 52,
+	62, 51, 61, 58, 75, 3, 3, 3, 3, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 69, 58, 70, 73, 3, 80, 3, 3, 3,
+	3, 67, 56, 68, 71, 3, 78, 3, 3, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 56, 3, 57, 79,
+	3, 3, 3, 54, 3, 55, 77,
 }
 var protoTok2 = [...]int{
 
@@ -632,8 +761,7 @@
 	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
 	22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 	32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
-	42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
-	52,
+	42, 43, 44, 45, 46, 47, 48, 49, 50,
 }
 var protoTok3 = [...]int{
 	0,
@@ -978,7 +1106,7 @@
 
 	case 1:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:114
+//line proto.y:119
 		{
 			protoVAL.file = &fileNode{syntax: protoDollar[1].syn}
 			protoVAL.file.setRange(protoDollar[1].syn, protoDollar[1].syn)
@@ -986,7 +1114,7 @@
 		}
 	case 2:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:119
+//line proto.y:124
 		{
 			protoVAL.file = &fileNode{decls: protoDollar[1].fileDecls}
 			if len(protoDollar[1].fileDecls) > 0 {
@@ -996,7 +1124,7 @@
 		}
 	case 3:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:126
+//line proto.y:131
 		{
 			protoVAL.file = &fileNode{syntax: protoDollar[1].syn, decls: protoDollar[2].fileDecls}
 			var end node
@@ -1010,66 +1138,76 @@
 		}
 	case 4:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:137
+//line proto.y:142
 		{
 		}
 	case 5:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:140
+//line proto.y:145
 		{
 			protoVAL.fileDecls = append(protoDollar[1].fileDecls, protoDollar[2].fileDecls...)
 		}
 	case 7:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:145
+//line proto.y:150
 		{
 			protoVAL.fileDecls = []*fileElement{{imp: protoDollar[1].imprt}}
 		}
 	case 8:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:148
+//line proto.y:153
 		{
 			protoVAL.fileDecls = []*fileElement{{pkg: protoDollar[1].pkg}}
 		}
 	case 9:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:151
+//line proto.y:156
 		{
 			protoVAL.fileDecls = []*fileElement{{option: protoDollar[1].opts[0]}}
 		}
 	case 10:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:154
+//line proto.y:159
 		{
 			protoVAL.fileDecls = []*fileElement{{message: protoDollar[1].msg}}
 		}
 	case 11:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:157
+//line proto.y:162
 		{
 			protoVAL.fileDecls = []*fileElement{{enum: protoDollar[1].en}}
 		}
 	case 12:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:160
+//line proto.y:165
 		{
 			protoVAL.fileDecls = []*fileElement{{extend: protoDollar[1].extend}}
 		}
 	case 13:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:163
+//line proto.y:168
 		{
 			protoVAL.fileDecls = []*fileElement{{service: protoDollar[1].svc}}
 		}
 	case 14:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:166
+//line proto.y:171
 		{
 			protoVAL.fileDecls = []*fileElement{{empty: protoDollar[1].b}}
 		}
 	case 15:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:174
+		{
+		}
+	case 16:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:176
+		{
+		}
+	case 17:
 		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:170
+//line proto.y:179
 		{
 			if protoDollar[3].str.val != "proto2" && protoDollar[3].str.val != "proto3" {
 				lexError(protolex, protoDollar[3].str.start(), "syntax value must be 'proto2' or 'proto3'")
@@ -1077,37 +1215,51 @@
 			protoVAL.syn = &syntaxNode{syntax: protoDollar[3].str}
 			protoVAL.syn.setRange(protoDollar[1].id, protoDollar[4].b)
 		}
-	case 16:
+	case 18:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:178
+//line proto.y:187
 		{
 			protoVAL.imprt = &importNode{name: protoDollar[2].str}
 			protoVAL.imprt.setRange(protoDollar[1].id, protoDollar[3].b)
 		}
-	case 17:
+	case 19:
 		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:182
+//line proto.y:191
 		{
 			protoVAL.imprt = &importNode{name: protoDollar[3].str, weak: true}
 			protoVAL.imprt.setRange(protoDollar[1].id, protoDollar[4].b)
 		}
-	case 18:
+	case 20:
 		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:186
+//line proto.y:195
 		{
 			protoVAL.imprt = &importNode{name: protoDollar[3].str, public: true}
 			protoVAL.imprt.setRange(protoDollar[1].id, protoDollar[4].b)
 		}
-	case 19:
+	case 21:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:191
+//line proto.y:200
 		{
-			protoVAL.pkg = &packageNode{name: protoDollar[2].id}
+			protoVAL.pkg = &packageNode{name: protoDollar[2].cid}
 			protoVAL.pkg.setRange(protoDollar[1].id, protoDollar[3].b)
 		}
 	case 22:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:205
+		{
+			protoVAL.cid = &compoundIdentNode{val: protoDollar[1].id.val}
+			protoVAL.cid.setRange(protoDollar[1].id, protoDollar[1].id)
+		}
+	case 23:
+		protoDollar = protoS[protopt-3 : protopt+1]
+//line proto.y:209
+		{
+			protoVAL.cid = &compoundIdentNode{val: protoDollar[1].cid.val + "." + protoDollar[3].id.val}
+			protoVAL.cid.setRange(protoDollar[1].cid, protoDollar[3].id)
+		}
+	case 24:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:199
+//line proto.y:214
 		{
 			n := &optionNameNode{parts: protoDollar[2].optNm}
 			n.setRange(protoDollar[2].optNm[0], protoDollar[2].optNm[len(protoDollar[2].optNm)-1])
@@ -1115,188 +1267,229 @@
 			o.setRange(protoDollar[1].id, protoDollar[5].b)
 			protoVAL.opts = []*optionNode{o}
 		}
-	case 23:
+	case 25:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:207
+//line proto.y:222
 		{
-			protoVAL.optNm = toNameParts(protoDollar[1].id, 0)
+			protoVAL.optNm = toNameParts(protoDollar[1].cid, 0)
 		}
-	case 24:
+	case 26:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:210
+//line proto.y:225
 		{
-			p := &optionNamePartNode{text: protoDollar[2].id, isExtension: true}
+			p := &optionNamePartNode{text: protoDollar[2].cid, isExtension: true}
 			p.setRange(protoDollar[1].b, protoDollar[3].b)
 			protoVAL.optNm = []*optionNamePartNode{p}
 		}
-	case 25:
+	case 27:
 		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:215
+//line proto.y:230
 		{
-			p := &optionNamePartNode{text: protoDollar[2].id, isExtension: true}
+			p := &optionNamePartNode{text: protoDollar[2].cid, isExtension: true}
 			p.setRange(protoDollar[1].b, protoDollar[3].b)
 			ps := make([]*optionNamePartNode, 1, len(protoDollar[4].optNm)+1)
 			ps[0] = p
 			protoVAL.optNm = append(ps, protoDollar[4].optNm...)
 		}
-	case 27:
+	case 29:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:224
+//line proto.y:239
 		{
 			protoVAL.optNm = append(protoDollar[1].optNm, protoDollar[2].optNm...)
 		}
-	case 28:
-		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:228
-		{
-			protoVAL.optNm = toNameParts(protoDollar[1].id, 1 /* exclude leading dot */)
-		}
-	case 29:
-		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:231
-		{
-			p := &optionNamePartNode{text: protoDollar[3].id, isExtension: true}
-			p.setRange(protoDollar[2].b, protoDollar[4].b)
-			protoVAL.optNm = []*optionNamePartNode{p}
-		}
-	case 32:
-		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:240
-		{
-			protoVAL.v = protoDollar[1].str
-		}
-	case 33:
+	case 30:
 		protoDollar = protoS[protopt-1 : protopt+1]
 //line proto.y:243
 		{
-			protoVAL.v = protoDollar[1].ui
+			protoVAL.optNm = toNameParts(protoDollar[1].cid, 1 /* exclude leading dot */)
+		}
+	case 31:
+		protoDollar = protoS[protopt-4 : protopt+1]
+//line proto.y:246
+		{
+			p := &optionNamePartNode{text: protoDollar[3].cid, isExtension: true}
+			p.setRange(protoDollar[2].b, protoDollar[4].b)
+			protoVAL.optNm = []*optionNamePartNode{p}
 		}
 	case 34:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:246
+//line proto.y:255
 		{
-			protoVAL.v = protoDollar[1].i
-		}
-	case 35:
-		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:249
-		{
-			protoVAL.v = protoDollar[1].f
+			protoVAL.v = protoDollar[1].str
 		}
 	case 36:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:252
+//line proto.y:259
+		{
+			protoVAL.v = protoDollar[1].il
+		}
+	case 38:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:263
 		{
 			if protoDollar[1].id.val == "true" {
-				protoVAL.v = &boolLiteralNode{basicNode: protoDollar[1].id.basicNode, val: true}
+				protoVAL.v = &boolLiteralNode{identNode: protoDollar[1].id, val: true}
 			} else if protoDollar[1].id.val == "false" {
-				protoVAL.v = &boolLiteralNode{basicNode: protoDollar[1].id.basicNode, val: false}
+				protoVAL.v = &boolLiteralNode{identNode: protoDollar[1].id, val: false}
 			} else if protoDollar[1].id.val == "inf" {
-				f := &floatLiteralNode{val: math.Inf(1)}
+				f := &compoundFloatNode{val: math.Inf(1)}
 				f.setRange(protoDollar[1].id, protoDollar[1].id)
 				protoVAL.v = f
 			} else if protoDollar[1].id.val == "nan" {
-				f := &floatLiteralNode{val: math.NaN()}
+				f := &compoundFloatNode{val: math.NaN()}
 				f.setRange(protoDollar[1].id, protoDollar[1].id)
 				protoVAL.v = f
 			} else {
 				protoVAL.v = protoDollar[1].id
 			}
 		}
-	case 38:
-		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:271
-		{
-			protoVAL.ui = protoDollar[2].ui
-		}
 	case 39:
-		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:275
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:281
 		{
-			if protoDollar[2].ui.val > math.MaxInt64+1 {
-				lexError(protolex, protoDollar[2].ui.start(), fmt.Sprintf("numeric constant %d would underflow (allowed range is %d to %d)", protoDollar[2].ui.val, int64(math.MinInt64), int64(math.MaxInt64)))
-			}
-			protoVAL.i = &negativeIntLiteralNode{val: -int64(protoDollar[2].ui.val)}
-			protoVAL.i.setRange(protoDollar[1].b, protoDollar[2].ui)
+			i := &compoundUintNode{val: protoDollar[1].i.val}
+			i.setRange(protoDollar[1].i, protoDollar[1].i)
+			protoVAL.v = i
+		}
+	case 40:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:286
+		{
+			i := &compoundUintNode{val: protoDollar[2].i.val}
+			i.setRange(protoDollar[1].b, protoDollar[2].i)
+			protoVAL.v = i
 		}
 	case 41:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:284
-		{
-			protoVAL.f = &floatLiteralNode{val: -protoDollar[2].f.val}
-			protoVAL.f.setRange(protoDollar[1].b, protoDollar[2].f)
-		}
-	case 42:
-		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:288
-		{
-			protoVAL.f = &floatLiteralNode{val: protoDollar[2].f.val}
-			protoVAL.f.setRange(protoDollar[1].b, protoDollar[2].f)
-		}
-	case 43:
-		protoDollar = protoS[protopt-2 : protopt+1]
 //line proto.y:292
 		{
-			protoVAL.f = &floatLiteralNode{val: math.Inf(1)}
-			protoVAL.f.setRange(protoDollar[1].b, protoDollar[2].id)
+			if protoDollar[2].i.val > math.MaxInt64+1 {
+				lexError(protolex, protoDollar[2].i.start(), fmt.Sprintf("numeric constant %d would underflow (allowed range is %d to %d)", protoDollar[2].i.val, int64(math.MinInt64), int64(math.MaxInt64)))
+			}
+			i := &compoundIntNode{val: -int64(protoDollar[2].i.val)}
+			i.setRange(protoDollar[1].b, protoDollar[2].i)
+			protoVAL.il = i
+		}
+	case 43:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:302
+		{
+			// we don't allow uintLit because this is for enum numeric vals, which don't allow '+'
+			checkUint64InInt32Range(protolex, protoDollar[1].i.start(), protoDollar[1].i.val)
+			i := &compoundIntNode{val: int64(protoDollar[1].i.val)}
+			i.setRange(protoDollar[1].i, protoDollar[1].i)
+			protoVAL.il = i
 		}
 	case 44:
-		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:296
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:310
 		{
-			protoVAL.f = &floatLiteralNode{val: math.Inf(-1)}
-			protoVAL.f.setRange(protoDollar[1].b, protoDollar[2].id)
+			protoVAL.v = protoDollar[1].f
+		}
+	case 45:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:313
+		{
+			f := &compoundFloatNode{val: -protoDollar[2].f.val}
+			f.setRange(protoDollar[1].b, protoDollar[2].f)
+			protoVAL.v = f
 		}
 	case 46:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:302
+//line proto.y:318
 		{
-			protoVAL.str = &stringLiteralNode{val: protoDollar[1].str.val + protoDollar[2].str.val}
-			protoVAL.str.setRange(protoDollar[1].str, protoDollar[2].str)
+			f := &compoundFloatNode{val: protoDollar[2].f.val}
+			f.setRange(protoDollar[1].b, protoDollar[2].f)
+			protoVAL.v = f
 		}
 	case 47:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:323
+		{
+			f := &compoundFloatNode{val: math.Inf(1)}
+			f.setRange(protoDollar[1].b, protoDollar[2].id)
+			protoVAL.v = f
+		}
+	case 48:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:328
+		{
+			f := &compoundFloatNode{val: math.Inf(-1)}
+			f.setRange(protoDollar[1].b, protoDollar[2].id)
+			protoVAL.v = f
+		}
+	case 49:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:334
+		{
+			protoVAL.str = &compoundStringNode{val: protoDollar[1].s.val}
+			protoVAL.str.setRange(protoDollar[1].s, protoDollar[1].s)
+		}
+	case 50:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:338
+		{
+			protoVAL.str = &compoundStringNode{val: protoDollar[1].str.val + protoDollar[2].s.val}
+			protoVAL.str.setRange(protoDollar[1].str, protoDollar[2].s)
+		}
+	case 51:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:307
+//line proto.y:343
 		{
 			a := &aggregateLiteralNode{elements: protoDollar[2].agg}
 			a.setRange(protoDollar[1].b, protoDollar[3].b)
 			protoVAL.v = a
 		}
-	case 49:
+	case 53:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:314
+//line proto.y:350
 		{
 			protoVAL.agg = append(protoDollar[1].agg, protoDollar[2].agg...)
 		}
-	case 50:
+	case 54:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:317
+//line proto.y:353
 		{
 			protoVAL.agg = nil
 		}
-	case 52:
+	case 56:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:322
+//line proto.y:358
 		{
 			protoVAL.agg = protoDollar[1].agg
 		}
-	case 53:
+	case 57:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:325
+//line proto.y:361
 		{
 			protoVAL.agg = protoDollar[1].agg
 		}
-	case 54:
+	case 58:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:364
+		{
+		}
+	case 59:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:366
+		{
+		}
+	case 60:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:368
+		{
+		}
+	case 61:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:329
+//line proto.y:371
 		{
 			a := &aggregateEntryNode{name: protoDollar[1].aggName, val: protoDollar[3].v}
 			a.setRange(protoDollar[1].aggName, protoDollar[3].v)
 			protoVAL.agg = []*aggregateEntryNode{a}
 		}
-	case 55:
+	case 62:
 		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:334
+//line proto.y:376
 		{
 			s := &sliceLiteralNode{}
 			s.setRange(protoDollar[3].b, protoDollar[4].b)
@@ -1304,9 +1497,9 @@
 			a.setRange(protoDollar[1].aggName, protoDollar[4].b)
 			protoVAL.agg = []*aggregateEntryNode{a}
 		}
-	case 56:
+	case 63:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:341
+//line proto.y:383
 		{
 			s := &sliceLiteralNode{elements: protoDollar[4].sl}
 			s.setRange(protoDollar[3].b, protoDollar[5].b)
@@ -1314,25 +1507,30 @@
 			a.setRange(protoDollar[1].aggName, protoDollar[5].b)
 			protoVAL.agg = []*aggregateEntryNode{a}
 		}
-	case 57:
+	case 64:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:390
+		{
+		}
+	case 65:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:348
+//line proto.y:392
 		{
 			a := &aggregateEntryNode{name: protoDollar[1].aggName, val: protoDollar[3].v}
 			a.setRange(protoDollar[1].aggName, protoDollar[3].v)
 			protoVAL.agg = []*aggregateEntryNode{a}
 		}
-	case 58:
+	case 66:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:353
+//line proto.y:397
 		{
 			a := &aggregateEntryNode{name: protoDollar[1].aggName, val: protoDollar[2].v}
 			a.setRange(protoDollar[1].aggName, protoDollar[2].v)
 			protoVAL.agg = []*aggregateEntryNode{a}
 		}
-	case 59:
+	case 67:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:358
+//line proto.y:402
 		{
 			s := &aggregateLiteralNode{elements: protoDollar[4].agg}
 			s.setRange(protoDollar[3].b, protoDollar[5].b)
@@ -1340,9 +1538,9 @@
 			a.setRange(protoDollar[1].aggName, protoDollar[5].b)
 			protoVAL.agg = []*aggregateEntryNode{a}
 		}
-	case 60:
+	case 68:
 		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:365
+//line proto.y:409
 		{
 			s := &aggregateLiteralNode{elements: protoDollar[3].agg}
 			s.setRange(protoDollar[2].b, protoDollar[4].b)
@@ -1350,141 +1548,187 @@
 			a.setRange(protoDollar[1].aggName, protoDollar[4].b)
 			protoVAL.agg = []*aggregateEntryNode{a}
 		}
-	case 61:
-		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:373
+	case 69:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:416
 		{
-			protoVAL.aggName = &aggregateNameNode{name: protoDollar[1].id}
+		}
+	case 70:
+		protoDollar = protoS[protopt-4 : protopt+1]
+//line proto.y:418
+		{
+		}
+	case 71:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:421
+		{
+			n := &compoundIdentNode{val: protoDollar[1].id.val}
+			n.setRange(protoDollar[1].id, protoDollar[1].id)
+			protoVAL.aggName = &aggregateNameNode{name: n}
 			protoVAL.aggName.setRange(protoDollar[1].id, protoDollar[1].id)
 		}
-	case 62:
+	case 72:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:377
+//line proto.y:427
 		{
-			protoVAL.aggName = &aggregateNameNode{name: protoDollar[2].id, isExtension: true}
+			protoVAL.aggName = &aggregateNameNode{name: protoDollar[2].cid, isExtension: true}
 			protoVAL.aggName.setRange(protoDollar[1].b, protoDollar[3].b)
 		}
-	case 63:
+	case 73:
+		protoDollar = protoS[protopt-3 : protopt+1]
+//line proto.y:431
+		{
+		}
+	case 74:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:382
+//line proto.y:434
 		{
 			protoVAL.sl = []valueNode{protoDollar[1].v}
 		}
-	case 64:
+	case 75:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:385
+//line proto.y:437
 		{
 			protoVAL.sl = append(protoDollar[1].sl, protoDollar[3].v)
 		}
-	case 65:
+	case 76:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:388
+//line proto.y:440
 		{
 			protoVAL.sl = append(protoDollar[1].sl, protoDollar[3].v)
 		}
-	case 66:
+	case 77:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:391
+//line proto.y:443
 		{
 			s := &aggregateLiteralNode{elements: protoDollar[2].agg}
 			s.setRange(protoDollar[1].b, protoDollar[3].b)
 			protoVAL.sl = []valueNode{s}
 		}
-	case 67:
-		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:396
-		{
-			s := &aggregateLiteralNode{elements: protoDollar[4].agg}
-			s.setRange(protoDollar[3].b, protoDollar[5].b)
-			protoVAL.sl = append(protoDollar[1].sl, s)
-		}
-	case 68:
-		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:401
-		{
-			s := &aggregateLiteralNode{elements: protoDollar[4].agg}
-			s.setRange(protoDollar[3].b, protoDollar[5].b)
-			protoVAL.sl = append(protoDollar[1].sl, s)
-		}
-	case 71:
-		protoDollar = protoS[protopt-6 : protopt+1]
-//line proto.y:410
-		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode, required: true}
-			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].id, name: protoDollar[3].id, tag: protoDollar[5].ui}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[6].b)
-		}
-	case 72:
-		protoDollar = protoS[protopt-6 : protopt+1]
-//line proto.y:416
-		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode}
-			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].id, name: protoDollar[3].id, tag: protoDollar[5].ui}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[6].b)
-		}
-	case 73:
-		protoDollar = protoS[protopt-6 : protopt+1]
-//line proto.y:422
-		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode, repeated: true}
-			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].id, name: protoDollar[3].id, tag: protoDollar[5].ui}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[6].b)
-		}
-	case 74:
-		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:428
-		{
-			checkTag(protolex, protoDollar[4].ui.start(), protoDollar[4].ui.val)
-			protoVAL.fld = &fieldNode{fldType: protoDollar[1].id, name: protoDollar[2].id, tag: protoDollar[4].ui}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[5].b)
-		}
-	case 75:
-		protoDollar = protoS[protopt-9 : protopt+1]
-//line proto.y:433
-		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode, required: true}
-			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].id, name: protoDollar[3].id, tag: protoDollar[5].ui, options: protoDollar[7].opts}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[9].b)
-		}
-	case 76:
-		protoDollar = protoS[protopt-9 : protopt+1]
-//line proto.y:439
-		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode}
-			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].id, name: protoDollar[3].id, tag: protoDollar[5].ui, options: protoDollar[7].opts}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[9].b)
-		}
-	case 77:
-		protoDollar = protoS[protopt-9 : protopt+1]
-//line proto.y:445
-		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode, repeated: true}
-			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].id, name: protoDollar[3].id, tag: protoDollar[5].ui, options: protoDollar[7].opts}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[9].b)
-		}
 	case 78:
-		protoDollar = protoS[protopt-8 : protopt+1]
-//line proto.y:451
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:448
 		{
-			checkTag(protolex, protoDollar[4].ui.start(), protoDollar[4].ui.val)
-			protoVAL.fld = &fieldNode{fldType: protoDollar[1].id, name: protoDollar[2].id, tag: protoDollar[4].ui, options: protoDollar[6].opts}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[8].b)
+			s := &aggregateLiteralNode{elements: protoDollar[4].agg}
+			s.setRange(protoDollar[3].b, protoDollar[5].b)
+			protoVAL.sl = append(protoDollar[1].sl, s)
 		}
 	case 79:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:453
+		{
+			s := &aggregateLiteralNode{elements: protoDollar[4].agg}
+			s.setRange(protoDollar[3].b, protoDollar[5].b)
+			protoVAL.sl = append(protoDollar[1].sl, s)
+		}
+	case 80:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:457
+//line proto.y:458
+		{
+		}
+	case 81:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:460
+		{
+		}
+	case 82:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:462
+		{
+		}
+	case 84:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:466
+		{
+			protoVAL.cid = &compoundIdentNode{val: "." + protoDollar[2].cid.val}
+			protoVAL.cid.setRange(protoDollar[1].b, protoDollar[2].cid)
+		}
+	case 85:
+		protoDollar = protoS[protopt-6 : protopt+1]
+//line proto.y:471
+		{
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
+			lbl := fieldLabel{identNode: protoDollar[1].id, required: true}
+			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].cid, name: protoDollar[3].id, tag: protoDollar[5].i}
+			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[6].b)
+		}
+	case 86:
+		protoDollar = protoS[protopt-6 : protopt+1]
+//line proto.y:477
+		{
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
+			lbl := fieldLabel{identNode: protoDollar[1].id}
+			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].cid, name: protoDollar[3].id, tag: protoDollar[5].i}
+			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[6].b)
+		}
+	case 87:
+		protoDollar = protoS[protopt-6 : protopt+1]
+//line proto.y:483
+		{
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
+			lbl := fieldLabel{identNode: protoDollar[1].id, repeated: true}
+			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].cid, name: protoDollar[3].id, tag: protoDollar[5].i}
+			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[6].b)
+		}
+	case 88:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:489
+		{
+			checkTag(protolex, protoDollar[4].i.start(), protoDollar[4].i.val)
+			protoVAL.fld = &fieldNode{fldType: protoDollar[1].cid, name: protoDollar[2].id, tag: protoDollar[4].i}
+			protoVAL.fld.setRange(protoDollar[1].cid, protoDollar[5].b)
+		}
+	case 89:
+		protoDollar = protoS[protopt-7 : protopt+1]
+//line proto.y:494
+		{
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
+			lbl := fieldLabel{identNode: protoDollar[1].id, required: true}
+			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].cid, name: protoDollar[3].id, tag: protoDollar[5].i, options: protoDollar[6].cmpctOpts}
+			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[7].b)
+		}
+	case 90:
+		protoDollar = protoS[protopt-7 : protopt+1]
+//line proto.y:500
+		{
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
+			lbl := fieldLabel{identNode: protoDollar[1].id}
+			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].cid, name: protoDollar[3].id, tag: protoDollar[5].i, options: protoDollar[6].cmpctOpts}
+			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[7].b)
+		}
+	case 91:
+		protoDollar = protoS[protopt-7 : protopt+1]
+//line proto.y:506
+		{
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
+			lbl := fieldLabel{identNode: protoDollar[1].id, repeated: true}
+			protoVAL.fld = &fieldNode{label: lbl, fldType: protoDollar[2].cid, name: protoDollar[3].id, tag: protoDollar[5].i, options: protoDollar[6].cmpctOpts}
+			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[7].b)
+		}
+	case 92:
+		protoDollar = protoS[protopt-6 : protopt+1]
+//line proto.y:512
+		{
+			checkTag(protolex, protoDollar[4].i.start(), protoDollar[4].i.val)
+			protoVAL.fld = &fieldNode{fldType: protoDollar[1].cid, name: protoDollar[2].id, tag: protoDollar[4].i, options: protoDollar[5].cmpctOpts}
+			protoVAL.fld.setRange(protoDollar[1].cid, protoDollar[6].b)
+		}
+	case 93:
+		protoDollar = protoS[protopt-3 : protopt+1]
+//line proto.y:518
+		{
+			protoVAL.cmpctOpts = &compactOptionsNode{decls: protoDollar[2].opts}
+			protoVAL.cmpctOpts.setRange(protoDollar[1].b, protoDollar[3].b)
+		}
+	case 94:
+		protoDollar = protoS[protopt-3 : protopt+1]
+//line proto.y:523
 		{
 			protoVAL.opts = append(protoDollar[1].opts, protoDollar[3].opts...)
 		}
-	case 81:
+	case 96:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:462
+//line proto.y:528
 		{
 			n := &optionNameNode{parts: protoDollar[1].optNm}
 			n.setRange(protoDollar[1].optNm[0], protoDollar[1].optNm[len(protoDollar[1].optNm)-1])
@@ -1492,45 +1736,45 @@
 			o.setRange(protoDollar[1].optNm[0], protoDollar[3].v)
 			protoVAL.opts = []*optionNode{o}
 		}
-	case 82:
+	case 97:
 		protoDollar = protoS[protopt-8 : protopt+1]
-//line proto.y:470
+//line proto.y:536
 		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
 			if !unicode.IsUpper(rune(protoDollar[3].id.val[0])) {
 				lexError(protolex, protoDollar[3].id.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", protoDollar[3].id.val))
 			}
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode, required: true}
-			protoVAL.grp = &groupNode{groupKeyword: protoDollar[2].id, label: lbl, name: protoDollar[3].id, tag: protoDollar[5].ui, decls: protoDollar[7].msgDecls}
+			lbl := fieldLabel{identNode: protoDollar[1].id, required: true}
+			protoVAL.grp = &groupNode{groupKeyword: protoDollar[2].id, label: lbl, name: protoDollar[3].id, tag: protoDollar[5].i, decls: protoDollar[7].msgDecls}
 			protoVAL.grp.setRange(protoDollar[1].id, protoDollar[8].b)
 		}
-	case 83:
+	case 98:
 		protoDollar = protoS[protopt-8 : protopt+1]
-//line proto.y:479
+//line proto.y:545
 		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
 			if !unicode.IsUpper(rune(protoDollar[3].id.val[0])) {
 				lexError(protolex, protoDollar[3].id.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", protoDollar[3].id.val))
 			}
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode}
-			protoVAL.grp = &groupNode{groupKeyword: protoDollar[2].id, label: lbl, name: protoDollar[3].id, tag: protoDollar[5].ui, decls: protoDollar[7].msgDecls}
+			lbl := fieldLabel{identNode: protoDollar[1].id}
+			protoVAL.grp = &groupNode{groupKeyword: protoDollar[2].id, label: lbl, name: protoDollar[3].id, tag: protoDollar[5].i, decls: protoDollar[7].msgDecls}
 			protoVAL.grp.setRange(protoDollar[1].id, protoDollar[8].b)
 		}
-	case 84:
+	case 99:
 		protoDollar = protoS[protopt-8 : protopt+1]
-//line proto.y:488
+//line proto.y:554
 		{
-			checkTag(protolex, protoDollar[5].ui.start(), protoDollar[5].ui.val)
+			checkTag(protolex, protoDollar[5].i.start(), protoDollar[5].i.val)
 			if !unicode.IsUpper(rune(protoDollar[3].id.val[0])) {
 				lexError(protolex, protoDollar[3].id.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", protoDollar[3].id.val))
 			}
-			lbl := &labelNode{basicNode: protoDollar[1].id.basicNode, repeated: true}
-			protoVAL.grp = &groupNode{groupKeyword: protoDollar[2].id, label: lbl, name: protoDollar[3].id, tag: protoDollar[5].ui, decls: protoDollar[7].msgDecls}
+			lbl := fieldLabel{identNode: protoDollar[1].id, repeated: true}
+			protoVAL.grp = &groupNode{groupKeyword: protoDollar[2].id, label: lbl, name: protoDollar[3].id, tag: protoDollar[5].i, decls: protoDollar[7].msgDecls}
 			protoVAL.grp.setRange(protoDollar[1].id, protoDollar[8].b)
 		}
-	case 85:
+	case 100:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:498
+//line proto.y:564
 		{
 			c := 0
 			for _, el := range protoDollar[4].ooDecls {
@@ -1544,170 +1788,143 @@
 			protoVAL.oo = &oneOfNode{name: protoDollar[2].id, decls: protoDollar[4].ooDecls}
 			protoVAL.oo.setRange(protoDollar[1].id, protoDollar[5].b)
 		}
-	case 86:
+	case 101:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:512
+//line proto.y:578
 		{
 			protoVAL.ooDecls = append(protoDollar[1].ooDecls, protoDollar[2].ooDecls...)
 		}
-	case 88:
+	case 103:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:516
+//line proto.y:582
 		{
 			protoVAL.ooDecls = nil
 		}
-	case 89:
+	case 104:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:520
+//line proto.y:586
 		{
 			protoVAL.ooDecls = []*oneOfElement{{option: protoDollar[1].opts[0]}}
 		}
-	case 90:
+	case 105:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:523
+//line proto.y:589
 		{
 			protoVAL.ooDecls = []*oneOfElement{{field: protoDollar[1].fld}}
 		}
-	case 91:
+	case 106:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:526
+//line proto.y:592
+		{
+			protoVAL.ooDecls = []*oneOfElement{{group: protoDollar[1].grp}}
+		}
+	case 107:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:595
 		{
 			protoVAL.ooDecls = []*oneOfElement{{empty: protoDollar[1].b}}
 		}
-	case 92:
-		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:530
-		{
-			checkTag(protolex, protoDollar[4].ui.start(), protoDollar[4].ui.val)
-			protoVAL.fld = &fieldNode{fldType: protoDollar[1].id, name: protoDollar[2].id, tag: protoDollar[4].ui}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[5].b)
-		}
-	case 93:
-		protoDollar = protoS[protopt-8 : protopt+1]
-//line proto.y:535
-		{
-			checkTag(protolex, protoDollar[4].ui.start(), protoDollar[4].ui.val)
-			protoVAL.fld = &fieldNode{fldType: protoDollar[1].id, name: protoDollar[2].id, tag: protoDollar[4].ui, options: protoDollar[6].opts}
-			protoVAL.fld.setRange(protoDollar[1].id, protoDollar[8].b)
-		}
-	case 94:
-		protoDollar = protoS[protopt-10 : protopt+1]
-//line proto.y:541
-		{
-			checkTag(protolex, protoDollar[9].ui.start(), protoDollar[9].ui.val)
-			protoVAL.mapFld = &mapFieldNode{mapKeyword: protoDollar[1].id, keyType: protoDollar[3].id, valueType: protoDollar[5].id, name: protoDollar[7].id, tag: protoDollar[9].ui}
-			protoVAL.mapFld.setRange(protoDollar[1].id, protoDollar[10].b)
-		}
-	case 95:
-		protoDollar = protoS[protopt-13 : protopt+1]
-//line proto.y:546
-		{
-			checkTag(protolex, protoDollar[9].ui.start(), protoDollar[9].ui.val)
-			protoVAL.mapFld = &mapFieldNode{mapKeyword: protoDollar[1].id, keyType: protoDollar[3].id, valueType: protoDollar[5].id, name: protoDollar[7].id, tag: protoDollar[9].ui, options: protoDollar[11].opts}
-			protoVAL.mapFld.setRange(protoDollar[1].id, protoDollar[13].b)
-		}
 	case 108:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:598
+		{
+		}
+	case 109:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:600
+		{
+		}
+	case 110:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:603
+		{
+			checkTag(protolex, protoDollar[4].i.start(), protoDollar[4].i.val)
+			protoVAL.fld = &fieldNode{fldType: protoDollar[1].cid, name: protoDollar[2].id, tag: protoDollar[4].i}
+			protoVAL.fld.setRange(protoDollar[1].cid, protoDollar[5].b)
+		}
+	case 111:
+		protoDollar = protoS[protopt-6 : protopt+1]
+//line proto.y:608
+		{
+			checkTag(protolex, protoDollar[4].i.start(), protoDollar[4].i.val)
+			protoVAL.fld = &fieldNode{fldType: protoDollar[1].cid, name: protoDollar[2].id, tag: protoDollar[4].i, options: protoDollar[5].cmpctOpts}
+			protoVAL.fld.setRange(protoDollar[1].cid, protoDollar[6].b)
+		}
+	case 112:
+		protoDollar = protoS[protopt-7 : protopt+1]
+//line proto.y:614
+		{
+			checkTag(protolex, protoDollar[4].i.start(), protoDollar[4].i.val)
+			if !unicode.IsUpper(rune(protoDollar[2].id.val[0])) {
+				lexError(protolex, protoDollar[2].id.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", protoDollar[2].id.val))
+			}
+			protoVAL.grp = &groupNode{groupKeyword: protoDollar[1].id, name: protoDollar[2].id, tag: protoDollar[4].i, decls: protoDollar[6].msgDecls}
+			protoVAL.grp.setRange(protoDollar[1].id, protoDollar[7].b)
+		}
+	case 113:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:623
+		{
+			checkTag(protolex, protoDollar[4].i.start(), protoDollar[4].i.val)
+			protoVAL.mapFld = &mapFieldNode{mapType: protoDollar[1].mapType, name: protoDollar[2].id, tag: protoDollar[4].i}
+			protoVAL.mapFld.setRange(protoDollar[1].mapType, protoDollar[5].b)
+		}
+	case 114:
+		protoDollar = protoS[protopt-6 : protopt+1]
+//line proto.y:628
+		{
+			checkTag(protolex, protoDollar[4].i.start(), protoDollar[4].i.val)
+			protoVAL.mapFld = &mapFieldNode{mapType: protoDollar[1].mapType, name: protoDollar[2].id, tag: protoDollar[4].i, options: protoDollar[5].cmpctOpts}
+			protoVAL.mapFld.setRange(protoDollar[1].mapType, protoDollar[6].b)
+		}
+	case 115:
+		protoDollar = protoS[protopt-6 : protopt+1]
+//line proto.y:634
+		{
+			protoVAL.mapType = &mapTypeNode{mapKeyword: protoDollar[1].id, keyType: protoDollar[3].id, valueType: protoDollar[5].cid}
+			protoVAL.mapType.setRange(protoDollar[1].id, protoDollar[6].b)
+		}
+	case 128:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:565
+//line proto.y:652
 		{
 			protoVAL.ext = &extensionRangeNode{ranges: protoDollar[2].rngs}
 			protoVAL.ext.setRange(protoDollar[1].id, protoDollar[3].b)
 		}
-	case 109:
-		protoDollar = protoS[protopt-6 : protopt+1]
-//line proto.y:569
+	case 129:
+		protoDollar = protoS[protopt-4 : protopt+1]
+//line proto.y:656
 		{
-			protoVAL.ext = &extensionRangeNode{ranges: protoDollar[2].rngs, options: protoDollar[4].opts}
-			protoVAL.ext.setRange(protoDollar[1].id, protoDollar[6].b)
+			protoVAL.ext = &extensionRangeNode{ranges: protoDollar[2].rngs, options: protoDollar[3].cmpctOpts}
+			protoVAL.ext.setRange(protoDollar[1].id, protoDollar[4].b)
 		}
-	case 110:
+	case 130:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:574
+//line proto.y:661
 		{
 			protoVAL.rngs = append(protoDollar[1].rngs, protoDollar[3].rngs...)
 		}
-	case 112:
+	case 132:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:579
+//line proto.y:666
 		{
-			if protoDollar[1].ui.val > internal.MaxTag {
-				lexError(protolex, protoDollar[1].ui.start(), fmt.Sprintf("range includes out-of-range tag: %d (should be between 0 and %d)", protoDollar[1].ui.val, internal.MaxTag))
+			if protoDollar[1].i.val > internal.MaxTag {
+				lexError(protolex, protoDollar[1].i.start(), fmt.Sprintf("range includes out-of-range tag: %d (should be between 0 and %d)", protoDollar[1].i.val, internal.MaxTag))
 			}
-			r := &rangeNode{stNode: protoDollar[1].ui, enNode: protoDollar[1].ui, st: int32(protoDollar[1].ui.val), en: int32(protoDollar[1].ui.val)}
-			r.setRange(protoDollar[1].ui, protoDollar[1].ui)
-			protoVAL.rngs = []*rangeNode{r}
-		}
-	case 113:
-		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:587
-		{
-			if protoDollar[1].ui.val > internal.MaxTag {
-				lexError(protolex, protoDollar[1].ui.start(), fmt.Sprintf("range start is out-of-range tag: %d (should be between 0 and %d)", protoDollar[1].ui.val, internal.MaxTag))
-			}
-			if protoDollar[3].ui.val > internal.MaxTag {
-				lexError(protolex, protoDollar[3].ui.start(), fmt.Sprintf("range end is out-of-range tag: %d (should be between 0 and %d)", protoDollar[3].ui.val, internal.MaxTag))
-			}
-			if protoDollar[1].ui.val > protoDollar[3].ui.val {
-				lexError(protolex, protoDollar[1].ui.start(), fmt.Sprintf("range, %d to %d, is invalid: start must be <= end", protoDollar[1].ui.val, protoDollar[3].ui.val))
-			}
-			r := &rangeNode{stNode: protoDollar[1].ui, enNode: protoDollar[3].ui, st: int32(protoDollar[1].ui.val), en: int32(protoDollar[3].ui.val)}
-			r.setRange(protoDollar[1].ui, protoDollar[3].ui)
-			protoVAL.rngs = []*rangeNode{r}
-		}
-	case 114:
-		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:601
-		{
-			if protoDollar[1].ui.val > internal.MaxTag {
-				lexError(protolex, protoDollar[1].ui.start(), fmt.Sprintf("range start is out-of-range tag: %d (should be between 0 and %d)", protoDollar[1].ui.val, internal.MaxTag))
-			}
-			r := &rangeNode{stNode: protoDollar[1].ui, enNode: protoDollar[3].id, st: int32(protoDollar[1].ui.val), en: internal.MaxTag}
-			r.setRange(protoDollar[1].ui, protoDollar[3].id)
-			protoVAL.rngs = []*rangeNode{r}
-		}
-	case 115:
-		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:610
-		{
-			protoVAL.rngs = append(protoDollar[1].rngs, protoDollar[3].rngs...)
-		}
-	case 117:
-		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:615
-		{
-			checkUint64InInt32Range(protolex, protoDollar[1].ui.start(), protoDollar[1].ui.val)
-			r := &rangeNode{stNode: protoDollar[1].ui, enNode: protoDollar[1].ui, st: int32(protoDollar[1].ui.val), en: int32(protoDollar[1].ui.val)}
-			r.setRange(protoDollar[1].ui, protoDollar[1].ui)
-			protoVAL.rngs = []*rangeNode{r}
-		}
-	case 118:
-		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:621
-		{
-			checkInt64InInt32Range(protolex, protoDollar[1].i.start(), protoDollar[1].i.val)
 			r := &rangeNode{stNode: protoDollar[1].i, enNode: protoDollar[1].i, st: int32(protoDollar[1].i.val), en: int32(protoDollar[1].i.val)}
 			r.setRange(protoDollar[1].i, protoDollar[1].i)
 			protoVAL.rngs = []*rangeNode{r}
 		}
-	case 119:
+	case 133:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:627
+//line proto.y:674
 		{
-			checkUint64InInt32Range(protolex, protoDollar[1].ui.start(), protoDollar[1].ui.val)
-			checkUint64InInt32Range(protolex, protoDollar[3].ui.start(), protoDollar[3].ui.val)
-			if protoDollar[1].ui.val > protoDollar[3].ui.val {
-				lexError(protolex, protoDollar[1].ui.start(), fmt.Sprintf("range, %d to %d, is invalid: start must be <= end", protoDollar[1].ui.val, protoDollar[3].ui.val))
+			if protoDollar[1].i.val > internal.MaxTag {
+				lexError(protolex, protoDollar[1].i.start(), fmt.Sprintf("range start is out-of-range tag: %d (should be between 0 and %d)", protoDollar[1].i.val, internal.MaxTag))
 			}
-			r := &rangeNode{stNode: protoDollar[1].ui, enNode: protoDollar[3].ui, st: int32(protoDollar[1].ui.val), en: int32(protoDollar[3].ui.val)}
-			r.setRange(protoDollar[1].ui, protoDollar[3].ui)
-			protoVAL.rngs = []*rangeNode{r}
-		}
-	case 120:
-		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:637
-		{
-			checkInt64InInt32Range(protolex, protoDollar[1].i.start(), protoDollar[1].i.val)
-			checkInt64InInt32Range(protolex, protoDollar[3].i.start(), protoDollar[3].i.val)
+			if protoDollar[3].i.val > internal.MaxTag {
+				lexError(protolex, protoDollar[3].i.start(), fmt.Sprintf("range end is out-of-range tag: %d (should be between 0 and %d)", protoDollar[3].i.val, internal.MaxTag))
+			}
 			if protoDollar[1].i.val > protoDollar[3].i.val {
 				lexError(protolex, protoDollar[1].i.start(), fmt.Sprintf("range, %d to %d, is invalid: start must be <= end", protoDollar[1].i.val, protoDollar[3].i.val))
 			}
@@ -1715,51 +1932,71 @@
 			r.setRange(protoDollar[1].i, protoDollar[3].i)
 			protoVAL.rngs = []*rangeNode{r}
 		}
-	case 121:
+	case 134:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:647
+//line proto.y:688
 		{
-			checkInt64InInt32Range(protolex, protoDollar[1].i.start(), protoDollar[1].i.val)
-			checkUint64InInt32Range(protolex, protoDollar[3].ui.start(), protoDollar[3].ui.val)
-			r := &rangeNode{stNode: protoDollar[1].i, enNode: protoDollar[3].ui, st: int32(protoDollar[1].i.val), en: int32(protoDollar[3].ui.val)}
-			r.setRange(protoDollar[1].i, protoDollar[3].ui)
-			protoVAL.rngs = []*rangeNode{r}
-		}
-	case 122:
-		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:654
-		{
-			checkUint64InInt32Range(protolex, protoDollar[1].ui.start(), protoDollar[1].ui.val)
-			r := &rangeNode{stNode: protoDollar[1].ui, enNode: protoDollar[3].id, st: int32(protoDollar[1].ui.val), en: math.MaxInt32}
-			r.setRange(protoDollar[1].ui, protoDollar[3].id)
-			protoVAL.rngs = []*rangeNode{r}
-		}
-	case 123:
-		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:660
-		{
-			checkInt64InInt32Range(protolex, protoDollar[1].i.start(), protoDollar[1].i.val)
-			r := &rangeNode{stNode: protoDollar[1].i, enNode: protoDollar[3].id, st: int32(protoDollar[1].i.val), en: math.MaxInt32}
+			if protoDollar[1].i.val > internal.MaxTag {
+				lexError(protolex, protoDollar[1].i.start(), fmt.Sprintf("range start is out-of-range tag: %d (should be between 0 and %d)", protoDollar[1].i.val, internal.MaxTag))
+			}
+			r := &rangeNode{stNode: protoDollar[1].i, enNode: protoDollar[3].id, st: int32(protoDollar[1].i.val), en: internal.MaxTag}
 			r.setRange(protoDollar[1].i, protoDollar[3].id)
 			protoVAL.rngs = []*rangeNode{r}
 		}
-	case 124:
+	case 135:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:667
+//line proto.y:697
+		{
+			protoVAL.rngs = append(protoDollar[1].rngs, protoDollar[3].rngs...)
+		}
+	case 137:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:702
+		{
+			checkInt64InInt32Range(protolex, protoDollar[1].il.start(), protoDollar[1].il.val)
+			r := &rangeNode{stNode: protoDollar[1].il, enNode: protoDollar[1].il, st: int32(protoDollar[1].il.val), en: int32(protoDollar[1].il.val)}
+			r.setRange(protoDollar[1].il, protoDollar[1].il)
+			protoVAL.rngs = []*rangeNode{r}
+		}
+	case 138:
+		protoDollar = protoS[protopt-3 : protopt+1]
+//line proto.y:708
+		{
+			checkInt64InInt32Range(protolex, protoDollar[1].il.start(), protoDollar[1].il.val)
+			checkInt64InInt32Range(protolex, protoDollar[3].il.start(), protoDollar[3].il.val)
+			if protoDollar[1].il.val > protoDollar[3].il.val {
+				lexError(protolex, protoDollar[1].il.start(), fmt.Sprintf("range, %d to %d, is invalid: start must be <= end", protoDollar[1].il.val, protoDollar[3].il.val))
+			}
+			r := &rangeNode{stNode: protoDollar[1].il, enNode: protoDollar[3].il, st: int32(protoDollar[1].il.val), en: int32(protoDollar[3].il.val)}
+			r.setRange(protoDollar[1].il, protoDollar[3].il)
+			protoVAL.rngs = []*rangeNode{r}
+		}
+	case 139:
+		protoDollar = protoS[protopt-3 : protopt+1]
+//line proto.y:718
+		{
+			checkInt64InInt32Range(protolex, protoDollar[1].il.start(), protoDollar[1].il.val)
+			r := &rangeNode{stNode: protoDollar[1].il, enNode: protoDollar[3].id, st: int32(protoDollar[1].il.val), en: math.MaxInt32}
+			r.setRange(protoDollar[1].il, protoDollar[3].id)
+			protoVAL.rngs = []*rangeNode{r}
+		}
+	case 140:
+		protoDollar = protoS[protopt-3 : protopt+1]
+//line proto.y:725
 		{
 			protoVAL.resvd = &reservedNode{ranges: protoDollar[2].rngs}
 			protoVAL.resvd.setRange(protoDollar[1].id, protoDollar[3].b)
 		}
-	case 126:
+	case 142:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:673
+//line proto.y:731
 		{
 			protoVAL.resvd = &reservedNode{ranges: protoDollar[2].rngs}
 			protoVAL.resvd.setRange(protoDollar[1].id, protoDollar[3].b)
 		}
-	case 128:
+	case 144:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:679
+//line proto.y:737
 		{
 			rsvd := map[string]struct{}{}
 			for _, n := range protoDollar[2].names {
@@ -1772,21 +2009,21 @@
 			protoVAL.resvd = &reservedNode{names: protoDollar[2].names}
 			protoVAL.resvd.setRange(protoDollar[1].id, protoDollar[3].b)
 		}
-	case 129:
+	case 145:
 		protoDollar = protoS[protopt-3 : protopt+1]
-//line proto.y:692
+//line proto.y:750
 		{
 			protoVAL.names = append(protoDollar[1].names, protoDollar[3].str)
 		}
-	case 130:
+	case 146:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:695
+//line proto.y:753
 		{
-			protoVAL.names = []*stringLiteralNode{protoDollar[1].str}
+			protoVAL.names = []*compoundStringNode{protoDollar[1].str}
 		}
-	case 131:
+	case 147:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:699
+//line proto.y:757
 		{
 			c := 0
 			for _, el := range protoDollar[4].enDecls {
@@ -1800,162 +2037,166 @@
 			protoVAL.en = &enumNode{name: protoDollar[2].id, decls: protoDollar[4].enDecls}
 			protoVAL.en.setRange(protoDollar[1].id, protoDollar[5].b)
 		}
-	case 132:
+	case 148:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:713
+//line proto.y:771
 		{
 			protoVAL.enDecls = append(protoDollar[1].enDecls, protoDollar[2].enDecls...)
 		}
-	case 134:
+	case 150:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:717
+//line proto.y:775
 		{
 			protoVAL.enDecls = nil
 		}
-	case 135:
+	case 151:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:721
+//line proto.y:779
 		{
 			protoVAL.enDecls = []*enumElement{{option: protoDollar[1].opts[0]}}
 		}
-	case 136:
+	case 152:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:724
+//line proto.y:782
 		{
 			protoVAL.enDecls = []*enumElement{{value: protoDollar[1].env}}
 		}
-	case 137:
+	case 153:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:727
+//line proto.y:785
 		{
 			protoVAL.enDecls = []*enumElement{{reserved: protoDollar[1].resvd}}
 		}
-	case 138:
+	case 154:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:730
+//line proto.y:788
 		{
 			protoVAL.enDecls = []*enumElement{{empty: protoDollar[1].b}}
 		}
-	case 139:
-		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:734
+	case 155:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:791
 		{
-			checkUint64InInt32Range(protolex, protoDollar[3].ui.start(), protoDollar[3].ui.val)
-			protoVAL.env = &enumValueNode{name: protoDollar[1].id, numberP: protoDollar[3].ui}
+		}
+	case 156:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:793
+		{
+		}
+	case 157:
+		protoDollar = protoS[protopt-4 : protopt+1]
+//line proto.y:796
+		{
+			checkInt64InInt32Range(protolex, protoDollar[3].il.start(), protoDollar[3].il.val)
+			protoVAL.env = &enumValueNode{name: protoDollar[1].id, number: protoDollar[3].il}
 			protoVAL.env.setRange(protoDollar[1].id, protoDollar[4].b)
 		}
-	case 140:
-		protoDollar = protoS[protopt-7 : protopt+1]
-//line proto.y:739
-		{
-			checkUint64InInt32Range(protolex, protoDollar[3].ui.start(), protoDollar[3].ui.val)
-			protoVAL.env = &enumValueNode{name: protoDollar[1].id, numberP: protoDollar[3].ui, options: protoDollar[5].opts}
-			protoVAL.env.setRange(protoDollar[1].id, protoDollar[7].b)
-		}
-	case 141:
-		protoDollar = protoS[protopt-4 : protopt+1]
-//line proto.y:744
-		{
-			checkInt64InInt32Range(protolex, protoDollar[3].i.start(), protoDollar[3].i.val)
-			protoVAL.env = &enumValueNode{name: protoDollar[1].id, numberN: protoDollar[3].i}
-			protoVAL.env.setRange(protoDollar[1].id, protoDollar[4].b)
-		}
-	case 142:
-		protoDollar = protoS[protopt-7 : protopt+1]
-//line proto.y:749
-		{
-			checkInt64InInt32Range(protolex, protoDollar[3].i.start(), protoDollar[3].i.val)
-			protoVAL.env = &enumValueNode{name: protoDollar[1].id, numberN: protoDollar[3].i, options: protoDollar[5].opts}
-			protoVAL.env.setRange(protoDollar[1].id, protoDollar[7].b)
-		}
-	case 143:
+	case 158:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:755
+//line proto.y:801
+		{
+			checkInt64InInt32Range(protolex, protoDollar[3].il.start(), protoDollar[3].il.val)
+			protoVAL.env = &enumValueNode{name: protoDollar[1].id, number: protoDollar[3].il, options: protoDollar[4].cmpctOpts}
+			protoVAL.env.setRange(protoDollar[1].id, protoDollar[5].b)
+		}
+	case 159:
+		protoDollar = protoS[protopt-5 : protopt+1]
+//line proto.y:807
 		{
 			protoVAL.msg = &messageNode{name: protoDollar[2].id, decls: protoDollar[4].msgDecls}
 			protoVAL.msg.setRange(protoDollar[1].id, protoDollar[5].b)
 		}
-	case 144:
+	case 160:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:760
+//line proto.y:812
 		{
 			protoVAL.msgDecls = append(protoDollar[1].msgDecls, protoDollar[2].msgDecls...)
 		}
-	case 146:
+	case 162:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:764
+//line proto.y:816
 		{
 			protoVAL.msgDecls = nil
 		}
-	case 147:
+	case 163:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:768
+//line proto.y:820
 		{
 			protoVAL.msgDecls = []*messageElement{{field: protoDollar[1].fld}}
 		}
-	case 148:
+	case 164:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:771
+//line proto.y:823
 		{
 			protoVAL.msgDecls = []*messageElement{{enum: protoDollar[1].en}}
 		}
-	case 149:
+	case 165:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:774
+//line proto.y:826
 		{
 			protoVAL.msgDecls = []*messageElement{{nested: protoDollar[1].msg}}
 		}
-	case 150:
+	case 166:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:777
+//line proto.y:829
 		{
 			protoVAL.msgDecls = []*messageElement{{extend: protoDollar[1].extend}}
 		}
-	case 151:
+	case 167:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:780
+//line proto.y:832
 		{
 			protoVAL.msgDecls = []*messageElement{{extensionRange: protoDollar[1].ext}}
 		}
-	case 152:
+	case 168:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:783
+//line proto.y:835
 		{
 			protoVAL.msgDecls = []*messageElement{{group: protoDollar[1].grp}}
 		}
-	case 153:
+	case 169:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:786
+//line proto.y:838
 		{
 			protoVAL.msgDecls = []*messageElement{{option: protoDollar[1].opts[0]}}
 		}
-	case 154:
+	case 170:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:789
+//line proto.y:841
 		{
 			protoVAL.msgDecls = []*messageElement{{oneOf: protoDollar[1].oo}}
 		}
-	case 155:
+	case 171:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:792
+//line proto.y:844
 		{
 			protoVAL.msgDecls = []*messageElement{{mapField: protoDollar[1].mapFld}}
 		}
-	case 156:
+	case 172:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:795
+//line proto.y:847
 		{
 			protoVAL.msgDecls = []*messageElement{{reserved: protoDollar[1].resvd}}
 		}
-	case 157:
+	case 173:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:798
+//line proto.y:850
 		{
 			protoVAL.msgDecls = []*messageElement{{empty: protoDollar[1].b}}
 		}
-	case 158:
+	case 174:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:853
+		{
+		}
+	case 175:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:855
+		{
+		}
+	case 176:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:802
+//line proto.y:858
 		{
 			c := 0
 			for _, el := range protoDollar[4].extDecls {
@@ -1966,128 +2207,158 @@
 			if c == 0 {
 				lexError(protolex, protoDollar[1].id.start(), "extend sections must define at least one extension")
 			}
-			protoVAL.extend = &extendNode{extendee: protoDollar[2].id, decls: protoDollar[4].extDecls}
+			protoVAL.extend = &extendNode{extendee: protoDollar[2].cid, decls: protoDollar[4].extDecls}
 			protoVAL.extend.setRange(protoDollar[1].id, protoDollar[5].b)
 		}
-	case 159:
+	case 177:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:816
+//line proto.y:872
 		{
 			protoVAL.extDecls = append(protoDollar[1].extDecls, protoDollar[2].extDecls...)
 		}
-	case 161:
+	case 179:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:820
+//line proto.y:876
 		{
 			protoVAL.extDecls = nil
 		}
-	case 162:
+	case 180:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:824
+//line proto.y:880
 		{
 			protoVAL.extDecls = []*extendElement{{field: protoDollar[1].fld}}
 		}
-	case 163:
+	case 181:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:827
+//line proto.y:883
 		{
 			protoVAL.extDecls = []*extendElement{{group: protoDollar[1].grp}}
 		}
-	case 164:
+	case 182:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:830
+//line proto.y:886
 		{
 			protoVAL.extDecls = []*extendElement{{empty: protoDollar[1].b}}
 		}
-	case 165:
+	case 183:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:889
+		{
+		}
+	case 184:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:891
+		{
+		}
+	case 185:
 		protoDollar = protoS[protopt-5 : protopt+1]
-//line proto.y:834
+//line proto.y:894
 		{
 			protoVAL.svc = &serviceNode{name: protoDollar[2].id, decls: protoDollar[4].svcDecls}
 			protoVAL.svc.setRange(protoDollar[1].id, protoDollar[5].b)
 		}
-	case 166:
+	case 186:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:839
+//line proto.y:899
 		{
 			protoVAL.svcDecls = append(protoDollar[1].svcDecls, protoDollar[2].svcDecls...)
 		}
-	case 168:
+	case 188:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:843
+//line proto.y:903
 		{
 			protoVAL.svcDecls = nil
 		}
-	case 169:
+	case 189:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:850
+//line proto.y:910
 		{
 			protoVAL.svcDecls = []*serviceElement{{option: protoDollar[1].opts[0]}}
 		}
-	case 170:
+	case 190:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:853
+//line proto.y:913
 		{
 			protoVAL.svcDecls = []*serviceElement{{rpc: protoDollar[1].mtd}}
 		}
-	case 171:
+	case 191:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:856
+//line proto.y:916
 		{
 			protoVAL.svcDecls = []*serviceElement{{empty: protoDollar[1].b}}
 		}
-	case 172:
+	case 192:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:919
+		{
+		}
+	case 193:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:921
+		{
+		}
+	case 194:
 		protoDollar = protoS[protopt-10 : protopt+1]
-//line proto.y:860
+//line proto.y:924
 		{
 			protoVAL.mtd = &methodNode{name: protoDollar[2].id, input: protoDollar[4].rpcType, output: protoDollar[8].rpcType}
 			protoVAL.mtd.setRange(protoDollar[1].id, protoDollar[10].b)
 		}
-	case 173:
+	case 195:
 		protoDollar = protoS[protopt-12 : protopt+1]
-//line proto.y:864
+//line proto.y:928
 		{
 			protoVAL.mtd = &methodNode{name: protoDollar[2].id, input: protoDollar[4].rpcType, output: protoDollar[8].rpcType, options: protoDollar[11].opts}
 			protoVAL.mtd.setRange(protoDollar[1].id, protoDollar[12].b)
 		}
-	case 174:
+	case 196:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:869
+//line proto.y:933
 		{
-			protoVAL.rpcType = &rpcTypeNode{msgType: protoDollar[2].id, streamKeyword: protoDollar[1].id}
-			protoVAL.rpcType.setRange(protoDollar[1].id, protoDollar[2].id)
+			protoVAL.rpcType = &rpcTypeNode{msgType: protoDollar[2].cid, streamKeyword: protoDollar[1].id}
+			protoVAL.rpcType.setRange(protoDollar[1].id, protoDollar[2].cid)
 		}
-	case 175:
+	case 197:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:873
+//line proto.y:937
 		{
-			protoVAL.rpcType = &rpcTypeNode{msgType: protoDollar[1].id}
-			protoVAL.rpcType.setRange(protoDollar[1].id, protoDollar[1].id)
+			protoVAL.rpcType = &rpcTypeNode{msgType: protoDollar[1].cid}
+			protoVAL.rpcType.setRange(protoDollar[1].cid, protoDollar[1].cid)
 		}
-	case 176:
+	case 198:
 		protoDollar = protoS[protopt-2 : protopt+1]
-//line proto.y:878
+//line proto.y:942
 		{
 			protoVAL.opts = append(protoDollar[1].opts, protoDollar[2].opts...)
 		}
-	case 178:
+	case 200:
 		protoDollar = protoS[protopt-0 : protopt+1]
-//line proto.y:882
+//line proto.y:946
 		{
 			protoVAL.opts = []*optionNode{}
 		}
-	case 179:
+	case 201:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:886
+//line proto.y:950
 		{
 			protoVAL.opts = protoDollar[1].opts
 		}
-	case 180:
+	case 202:
 		protoDollar = protoS[protopt-1 : protopt+1]
-//line proto.y:889
+//line proto.y:953
 		{
 			protoVAL.opts = []*optionNode{}
 		}
+	case 203:
+		protoDollar = protoS[protopt-2 : protopt+1]
+//line proto.y:956
+		{
+		}
+	case 204:
+		protoDollar = protoS[protopt-1 : protopt+1]
+//line proto.y:958
+		{
+		}
 	}
 	goto protostack /* stack new state and value */
 }
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/resolve_files.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/resolve_files.go
new file mode 100644
index 0000000..2561e56
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/resolve_files.go
@@ -0,0 +1,170 @@
+package protoparse
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var errNoImportPathsForAbsoluteFilePath = errors.New("must specify at least one import path if any absolute file paths are given")
+
+// ResolveFilenames tries to resolve fileNames into paths that are relative to
+// directories in the given importPaths. The returned slice has the results in
+// the same order as they are supplied in fileNames.
+//
+// The resulting names should be suitable for passing to Parser.ParseFiles.
+//
+// If no import paths are given and any file name is absolute, this returns an
+// error.  If no import paths are given and all file names are relative, this
+// returns the original file names. If a file name is already relative to one
+// of the given import paths, it will be unchanged in the returned slice. If a
+// file name given is relative to the current working directory, it will be made
+// relative to one of the given import paths; but if it cannot be made relative
+// (due to no matching import path), an error will be returned.
+func ResolveFilenames(importPaths []string, fileNames ...string) ([]string, error) {
+	if len(importPaths) == 0 {
+		if containsAbsFilePath(fileNames) {
+			// We have to do this as otherwise parseProtoFiles can result in duplicate symbols.
+			// For example, assume we import "foo/bar/bar.proto" in a file "/home/alice/dev/foo/bar/baz.proto"
+			// as we call ParseFiles("/home/alice/dev/foo/bar/bar.proto","/home/alice/dev/foo/bar/baz.proto")
+			// with "/home/alice/dev" as our current directory. Due to the recursive nature of parseProtoFiles,
+			// it will discover the import "foo/bar/bar.proto" in the input file, and call parse on this,
+			// adding "foo/bar/bar.proto" to the parsed results, as well as "/home/alice/dev/foo/bar/bar.proto"
+			// from the input file list. This will result in a
+			// 'duplicate symbol SYMBOL: already defined as field in "/home/alice/dev/foo/bar/bar.proto'
+			// error being returned from ParseFiles.
+			return nil, errNoImportPathsForAbsoluteFilePath
+		}
+		return fileNames, nil
+	}
+	absImportPaths, err := absoluteFilePaths(importPaths)
+	if err != nil {
+		return nil, err
+	}
+	resolvedFileNames := make([]string, 0, len(fileNames))
+	for _, fileName := range fileNames {
+		resolvedFileName, err := resolveFilename(absImportPaths, fileName)
+		if err != nil {
+			return nil, err
+		}
+		resolvedFileNames = append(resolvedFileNames, resolvedFileName)
+	}
+	return resolvedFileNames, nil
+}
+
+func containsAbsFilePath(filePaths []string) bool {
+	for _, filePath := range filePaths {
+		if filepath.IsAbs(filePath) {
+			return true
+		}
+	}
+	return false
+}
+
+func absoluteFilePaths(filePaths []string) ([]string, error) {
+	absFilePaths := make([]string, 0, len(filePaths))
+	for _, filePath := range filePaths {
+		absFilePath, err := canonicalize(filePath)
+		if err != nil {
+			return nil, err
+		}
+		absFilePaths = append(absFilePaths, absFilePath)
+	}
+	return absFilePaths, nil
+}
+
+func canonicalize(filePath string) (string, error) {
+	absPath, err := filepath.Abs(filePath)
+	if err != nil {
+		return "", err
+	}
+	// this is kind of gross, but it lets us construct a resolved path even if some
+	// path elements do not exist (a single call to filepath.EvalSymlinks would just
+	// return an error, ENOENT, in that case).
+	head := absPath
+	tail := ""
+	for {
+		noLinks, err := filepath.EvalSymlinks(head)
+		if err == nil {
+			if tail != "" {
+				return filepath.Join(noLinks, tail), nil
+			}
+			return noLinks, nil
+		}
+
+		if tail == "" {
+			tail = filepath.Base(head)
+		} else {
+			tail = filepath.Join(filepath.Base(head), tail)
+		}
+		head = filepath.Dir(head)
+		if head == "." {
+			// ran out of path elements to try to resolve
+			return absPath, nil
+		}
+	}
+}
+
+const dotPrefix = "." + string(filepath.Separator)
+const dotDotPrefix = ".." + string(filepath.Separator)
+
+func resolveFilename(absImportPaths []string, fileName string) (string, error) {
+	if filepath.IsAbs(fileName) {
+		return resolveAbsFilename(absImportPaths, fileName)
+	}
+
+	if !strings.HasPrefix(fileName, dotPrefix) && !strings.HasPrefix(fileName, dotDotPrefix) {
+		// Use of . and .. are assumed to be relative to current working
+		// directory. So if those aren't present, check to see if the file is
+		// relative to an import path.
+		for _, absImportPath := range absImportPaths {
+			absFileName := filepath.Join(absImportPath, fileName)
+			_, err := os.Stat(absFileName)
+			if err != nil {
+				continue
+			}
+			// found it! it was relative to this import path
+			return fileName, nil
+		}
+	}
+
+	// must be relative to current working dir
+	return resolveAbsFilename(absImportPaths, fileName)
+}
+
+func resolveAbsFilename(absImportPaths []string, fileName string) (string, error) {
+	absFileName, err := canonicalize(fileName)
+	if err != nil {
+		return "", err
+	}
+	for _, absImportPath := range absImportPaths {
+		if isDescendant(absImportPath, absFileName) {
+			resolvedPath, err := filepath.Rel(absImportPath, absFileName)
+			if err != nil {
+				return "", err
+			}
+			return resolvedPath, nil
+		}
+	}
+	return "", fmt.Errorf("%s does not reside in any import path", fileName)
+}
+
+// isDescendant returns true if file is a descendant of dir. Both dir and file must
+// be cleaned, absolute paths.
+func isDescendant(dir, file string) bool {
+	dir = filepath.Clean(dir)
+	cur := file
+	for {
+		d := filepath.Dir(cur)
+		if d == dir {
+			return true
+		}
+		if d == "." || d == cur {
+			// we've run out of path elements
+			return false
+		}
+		cur = d
+	}
+}
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/source_code_info.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/source_code_info.go
index d0a61c2..ff37733 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/source_code_info.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/source_code_info.go
@@ -2,8 +2,6 @@
 
 import (
 	"bytes"
-	"reflect"
-	"sort"
 	"strings"
 
 	"github.com/golang/protobuf/proto"
@@ -23,287 +21,267 @@
 	path := make([]int32, 0, 10)
 
 	fn := r.getFileNode(r.fd).(*fileNode)
+	sci.newLocWithoutComments(fn, nil)
+
 	if fn.syntax != nil {
 		sci.newLoc(fn.syntax, append(path, internal.File_syntaxTag))
 	}
-	if fn.pkg != nil {
-		sci.newLoc(fn.pkg, append(path, internal.File_packageTag))
-	}
-	for i, imp := range fn.imports {
-		sci.newLoc(imp, append(path, internal.File_dependencyTag, int32(i)))
-	}
 
-	// file options
-	r.generateSourceCodeInfoForOptions(&sci, fn.decls, func(n interface{}) *optionNode {
-		return n.(*fileElement).option
-	}, r.fd.Options.GetUninterpretedOption(), append(path, internal.File_optionsTag))
+	var depIndex, optIndex, msgIndex, enumIndex, extendIndex, svcIndex int32
 
-	// message types
-	for i, msg := range r.fd.GetMessageType() {
-		r.generateSourceCodeInfoForMessage(&sci, msg, append(path, internal.File_messagesTag, int32(i)))
-	}
-
-	// enum types
-	for i, enum := range r.fd.GetEnumType() {
-		r.generateSourceCodeInfoForEnum(&sci, enum, append(path, internal.File_enumsTag, int32(i)))
-	}
-
-	// extension fields
-	for i, ext := range r.fd.GetExtension() {
-		r.generateSourceCodeInfoForField(&sci, ext, append(path, internal.File_extensionsTag, int32(i)))
-	}
-
-	// services and methods
-	for i, svc := range r.fd.GetService() {
-		n := r.getServiceNode(svc).(*serviceNode)
-		svcPath := append(path, internal.File_servicesTag, int32(i))
-		sci.newLoc(n, svcPath)
-		sci.newLoc(n.name, append(svcPath, internal.Service_nameTag))
-
-		// service options
-		r.generateSourceCodeInfoForOptions(&sci, n.decls, func(n interface{}) *optionNode {
-			return n.(*serviceElement).option
-		}, svc.Options.GetUninterpretedOption(), append(svcPath, internal.Service_optionsTag))
-
-		// methods
-		for j, mtd := range svc.GetMethod() {
-			mn := r.getMethodNode(mtd).(*methodNode)
-			mtdPath := append(svcPath, internal.Service_methodsTag, int32(j))
-			sci.newLoc(mn, mtdPath)
-			sci.newLoc(mn.name, append(mtdPath, internal.Method_nameTag))
-
-			sci.newLoc(mn.input.msgType, append(mtdPath, internal.Method_inputTag))
-			if mn.input.streamKeyword != nil {
-				sci.newLoc(mn.input.streamKeyword, append(mtdPath, internal.Method_inputStreamTag))
-			}
-			sci.newLoc(mn.output.msgType, append(mtdPath, internal.Method_outputTag))
-			if mn.output.streamKeyword != nil {
-				sci.newLoc(mn.output.streamKeyword, append(mtdPath, internal.Method_outputStreamTag))
-			}
-
-			// method options
-			r.generateSourceCodeInfoForOptions(&sci, mn.options, func(n interface{}) *optionNode {
-				return n.(*optionNode)
-			}, mtd.Options.GetUninterpretedOption(), append(mtdPath, internal.Method_optionsTag))
-		}
-	}
-	return &dpb.SourceCodeInfo{Location: sci.generateLocs()}
-}
-
-func (r *parseResult) generateSourceCodeInfoForOptions(sci *sourceCodeInfo, elements interface{}, extractor func(interface{}) *optionNode, uninterp []*dpb.UninterpretedOption, path []int32) {
-	// Known options are option node elements that have a corresponding
-	// path in r.interpretedOptions. We'll do those first.
-	rv := reflect.ValueOf(elements)
-	for i := 0; i < rv.Len(); i++ {
-		on := extractor(rv.Index(i).Interface())
-		if on == nil {
-			continue
-		}
-		optPath := r.interpretedOptions[on]
-		if len(optPath) > 0 {
-			p := path
-			if optPath[0] == -1 {
-				// used by "default" and "json_name" field pseudo-options
-				// to attribute path to parent element (since those are
-				// stored directly on the descriptor, not its options)
-				p = make([]int32, len(path)-1)
-				copy(p, path)
-				optPath = optPath[1:]
-			}
-			sci.newLoc(on, append(p, optPath...))
-		}
-	}
-
-	// Now uninterpreted options
-	for i, uo := range uninterp {
-		optPath := append(path, internal.UninterpretedOptionsTag, int32(i))
-		on := r.getOptionNode(uo).(*optionNode)
-		sci.newLoc(on, optPath)
-
-		var valTag int32
+	for _, child := range fn.decls {
 		switch {
-		case uo.IdentifierValue != nil:
-			valTag = internal.Uninterpreted_identTag
-		case uo.PositiveIntValue != nil:
-			valTag = internal.Uninterpreted_posIntTag
-		case uo.NegativeIntValue != nil:
-			valTag = internal.Uninterpreted_negIntTag
-		case uo.DoubleValue != nil:
-			valTag = internal.Uninterpreted_doubleTag
-		case uo.StringValue != nil:
-			valTag = internal.Uninterpreted_stringTag
-		case uo.AggregateValue != nil:
-			valTag = internal.Uninterpreted_aggregateTag
+		case child.imp != nil:
+			sci.newLoc(child.imp, append(path, internal.File_dependencyTag, int32(depIndex)))
+			depIndex++
+		case child.pkg != nil:
+			sci.newLoc(child.pkg, append(path, internal.File_packageTag))
+		case child.option != nil:
+			r.generateSourceCodeInfoForOption(&sci, child.option, false, &optIndex, append(path, internal.File_optionsTag))
+		case child.message != nil:
+			r.generateSourceCodeInfoForMessage(&sci, child.message, nil, append(path, internal.File_messagesTag, msgIndex))
+			msgIndex++
+		case child.enum != nil:
+			r.generateSourceCodeInfoForEnum(&sci, child.enum, append(path, internal.File_enumsTag, enumIndex))
+			enumIndex++
+		case child.extend != nil:
+			r.generateSourceCodeInfoForExtensions(&sci, child.extend, &extendIndex, &msgIndex, append(path, internal.File_extensionsTag), append(dup(path), internal.File_messagesTag))
+		case child.service != nil:
+			r.generateSourceCodeInfoForService(&sci, child.service, append(path, internal.File_servicesTag, svcIndex))
+			svcIndex++
 		}
-		if valTag != 0 {
-			sci.newLoc(on.val, append(optPath, valTag))
-		}
+	}
 
-		for j, n := range uo.Name {
-			optNmPath := append(optPath, internal.Uninterpreted_nameTag, int32(j))
-			nn := r.getOptionNamePartNode(n).(*optionNamePartNode)
-			sci.newLoc(nn, optNmPath)
-			sci.newLoc(nn.text, append(optNmPath, internal.UninterpretedName_nameTag))
+	return &dpb.SourceCodeInfo{Location: sci.locs}
+}
+
+func (r *parseResult) generateSourceCodeInfoForOption(sci *sourceCodeInfo, n *optionNode, compact bool, uninterpIndex *int32, path []int32) {
+	if !compact {
+		sci.newLocWithoutComments(n, path)
+	}
+	subPath := r.interpretedOptions[n]
+	if len(subPath) > 0 {
+		p := path
+		if subPath[0] == -1 {
+			// used by "default" and "json_name" field pseudo-options
+			// to attribute path to parent element (since those are
+			// stored directly on the descriptor, not its options)
+			p = make([]int32, len(path)-1)
+			copy(p, path)
+			subPath = subPath[1:]
 		}
+		sci.newLoc(n, append(p, subPath...))
+		return
+	}
+
+	// it's an uninterpreted option
+	optPath := append(path, internal.UninterpretedOptionsTag, *uninterpIndex)
+	*uninterpIndex++
+	sci.newLoc(n, optPath)
+	var valTag int32
+	switch n.val.(type) {
+	case *compoundIdentNode:
+		valTag = internal.Uninterpreted_identTag
+	case *intLiteralNode:
+		valTag = internal.Uninterpreted_posIntTag
+	case *compoundIntNode:
+		valTag = internal.Uninterpreted_negIntTag
+	case *compoundFloatNode:
+		valTag = internal.Uninterpreted_doubleTag
+	case *compoundStringNode:
+		valTag = internal.Uninterpreted_stringTag
+	case *aggregateLiteralNode:
+		valTag = internal.Uninterpreted_aggregateTag
+	}
+	if valTag != 0 {
+		sci.newLoc(n.val, append(optPath, valTag))
+	}
+	for j, nn := range n.name.parts {
+		optNmPath := append(optPath, internal.Uninterpreted_nameTag, int32(j))
+		sci.newLoc(nn, optNmPath)
+		sci.newLoc(nn.text, append(optNmPath, internal.UninterpretedName_nameTag))
 	}
 }
 
-func (r *parseResult) generateSourceCodeInfoForMessage(sci *sourceCodeInfo, msg *dpb.DescriptorProto, path []int32) {
-	n := r.getMessageNode(msg)
+func (r *parseResult) generateSourceCodeInfoForMessage(sci *sourceCodeInfo, n msgDecl, fieldPath []int32, path []int32) {
 	sci.newLoc(n, path)
 
 	var decls []*messageElement
-	var resvdNames []*stringLiteralNode
 	switch n := n.(type) {
 	case *messageNode:
 		decls = n.decls
-		resvdNames = n.reserved
 	case *groupNode:
 		decls = n.decls
-		resvdNames = n.reserved
-	}
-	if decls == nil {
+	case *mapFieldNode:
 		// map entry so nothing else to do
 		return
 	}
 
 	sci.newLoc(n.messageName(), append(path, internal.Message_nameTag))
-
-	// message options
-	r.generateSourceCodeInfoForOptions(sci, decls, func(n interface{}) *optionNode {
-		return n.(*messageElement).option
-	}, msg.Options.GetUninterpretedOption(), append(path, internal.Message_optionsTag))
-
-	// fields
-	for i, fld := range msg.GetField() {
-		r.generateSourceCodeInfoForField(sci, fld, append(path, internal.Message_fieldsTag, int32(i)))
+	// matching protoc, which emits the corresponding field type name (for group fields)
+	// right after the source location for the group message name
+	if fieldPath != nil {
+		sci.newLoc(n.messageName(), append(fieldPath, internal.Field_typeNameTag))
 	}
 
-	// one-ofs
-	for i, ood := range msg.GetOneofDecl() {
-		oon := r.getOneOfNode(ood).(*oneOfNode)
-		ooPath := append(path, internal.Message_oneOfsTag, int32(i))
-		sci.newLoc(oon, ooPath)
-		sci.newLoc(oon.name, append(ooPath, internal.OneOf_nameTag))
-
-		// one-of options
-		r.generateSourceCodeInfoForOptions(sci, oon.decls, func(n interface{}) *optionNode {
-			return n.(*oneOfElement).option
-		}, ood.Options.GetUninterpretedOption(), append(ooPath, internal.OneOf_optionsTag))
-	}
-
-	// nested messages
-	for i, nm := range msg.GetNestedType() {
-		r.generateSourceCodeInfoForMessage(sci, nm, append(path, internal.Message_nestedMessagesTag, int32(i)))
-	}
-
-	// nested enums
-	for i, enum := range msg.GetEnumType() {
-		r.generateSourceCodeInfoForEnum(sci, enum, append(path, internal.Message_enumsTag, int32(i)))
-	}
-
-	// nested extensions
-	for i, ext := range msg.GetExtension() {
-		r.generateSourceCodeInfoForField(sci, ext, append(path, internal.Message_extensionsTag, int32(i)))
-	}
-
-	// extension ranges
-	for i, er := range msg.ExtensionRange {
-		rangePath := append(path, internal.Message_extensionRangeTag, int32(i))
-		rn := r.getExtensionRangeNode(er).(*rangeNode)
-		sci.newLoc(rn, rangePath)
-		sci.newLoc(rn.stNode, append(rangePath, internal.ExtensionRange_startTag))
-		if rn.stNode != rn.enNode {
-			sci.newLoc(rn.enNode, append(rangePath, internal.ExtensionRange_endTag))
-		}
-		// now we have to find the extension decl and options that correspond to this range :(
-		for _, d := range decls {
-			found := false
-			if d.extensionRange != nil {
-				for _, r := range d.extensionRange.ranges {
-					if rn == r {
-						found = true
-						break
-					}
+	var optIndex, fieldIndex, oneOfIndex, extendIndex, nestedMsgIndex int32
+	var nestedEnumIndex, extRangeIndex, reservedRangeIndex, reservedNameIndex int32
+	for _, child := range decls {
+		switch {
+		case child.option != nil:
+			r.generateSourceCodeInfoForOption(sci, child.option, false, &optIndex, append(path, internal.Message_optionsTag))
+		case child.field != nil:
+			r.generateSourceCodeInfoForField(sci, child.field, append(path, internal.Message_fieldsTag, fieldIndex))
+			fieldIndex++
+		case child.group != nil:
+			fldPath := append(path, internal.Message_fieldsTag, fieldIndex)
+			r.generateSourceCodeInfoForField(sci, child.group, fldPath)
+			fieldIndex++
+			r.generateSourceCodeInfoForMessage(sci, child.group, fldPath, append(dup(path), internal.Message_nestedMessagesTag, nestedMsgIndex))
+			nestedMsgIndex++
+		case child.mapField != nil:
+			r.generateSourceCodeInfoForField(sci, child.mapField, append(path, internal.Message_fieldsTag, fieldIndex))
+			fieldIndex++
+		case child.oneOf != nil:
+			r.generateSourceCodeInfoForOneOf(sci, child.oneOf, &fieldIndex, &nestedMsgIndex, append(path, internal.Message_fieldsTag), append(dup(path), internal.Message_nestedMessagesTag), append(dup(path), internal.Message_oneOfsTag, oneOfIndex))
+			oneOfIndex++
+		case child.nested != nil:
+			r.generateSourceCodeInfoForMessage(sci, child.nested, nil, append(path, internal.Message_nestedMessagesTag, nestedMsgIndex))
+			nestedMsgIndex++
+		case child.enum != nil:
+			r.generateSourceCodeInfoForEnum(sci, child.enum, append(path, internal.Message_enumsTag, nestedEnumIndex))
+			nestedEnumIndex++
+		case child.extend != nil:
+			r.generateSourceCodeInfoForExtensions(sci, child.extend, &extendIndex, &nestedMsgIndex, append(path, internal.Message_extensionsTag), append(dup(path), internal.Message_nestedMessagesTag))
+		case child.extensionRange != nil:
+			r.generateSourceCodeInfoForExtensionRanges(sci, child.extensionRange, &extRangeIndex, append(path, internal.Message_extensionRangeTag))
+		case child.reserved != nil:
+			if len(child.reserved.names) > 0 {
+				resPath := append(path, internal.Message_reservedNameTag)
+				sci.newLoc(child.reserved, resPath)
+				for _, rn := range child.reserved.names {
+					sci.newLoc(rn, append(resPath, reservedNameIndex))
+					reservedNameIndex++
 				}
 			}
-			if found {
-				r.generateSourceCodeInfoForOptions(sci, d.extensionRange.options, func(n interface{}) *optionNode {
-					return n.(*optionNode)
-				}, er.Options.GetUninterpretedOption(), append(rangePath, internal.ExtensionRange_optionsTag))
-				break
+			if len(child.reserved.ranges) > 0 {
+				resPath := append(path, internal.Message_reservedRangeTag)
+				sci.newLoc(child.reserved, resPath)
+				for _, rr := range child.reserved.ranges {
+					r.generateSourceCodeInfoForReservedRange(sci, rr, append(resPath, reservedRangeIndex))
+					reservedRangeIndex++
+				}
 			}
 		}
 	}
-
-	// reserved ranges
-	for i, rr := range msg.ReservedRange {
-		rangePath := append(path, internal.Message_reservedRangeTag, int32(i))
-		rn := r.getMessageReservedRangeNode(rr).(*rangeNode)
-		sci.newLoc(rn, rangePath)
-		sci.newLoc(rn.stNode, append(rangePath, internal.ReservedRange_startTag))
-		if rn.stNode != rn.enNode {
-			sci.newLoc(rn.enNode, append(rangePath, internal.ReservedRange_endTag))
-		}
-	}
-
-	// reserved names
-	for i, n := range resvdNames {
-		sci.newLoc(n, append(path, internal.Message_reservedNameTag, int32(i)))
-	}
 }
 
-func (r *parseResult) generateSourceCodeInfoForEnum(sci *sourceCodeInfo, enum *dpb.EnumDescriptorProto, path []int32) {
-	n := r.getEnumNode(enum).(*enumNode)
+func (r *parseResult) generateSourceCodeInfoForEnum(sci *sourceCodeInfo, n *enumNode, path []int32) {
 	sci.newLoc(n, path)
 	sci.newLoc(n.name, append(path, internal.Enum_nameTag))
 
-	// enum options
-	r.generateSourceCodeInfoForOptions(sci, n.decls, func(n interface{}) *optionNode {
-		return n.(*enumElement).option
-	}, enum.Options.GetUninterpretedOption(), append(path, internal.Enum_optionsTag))
-
-	// enum values
-	for j, ev := range enum.GetValue() {
-		evn := r.getEnumValueNode(ev).(*enumValueNode)
-		evPath := append(path, internal.Enum_valuesTag, int32(j))
-		sci.newLoc(evn, evPath)
-		sci.newLoc(evn.name, append(evPath, internal.EnumVal_nameTag))
-		sci.newLoc(evn.getNumber(), append(evPath, internal.EnumVal_numberTag))
-
-		// enum value options
-		r.generateSourceCodeInfoForOptions(sci, evn.options, func(n interface{}) *optionNode {
-			return n.(*optionNode)
-		}, ev.Options.GetUninterpretedOption(), append(evPath, internal.EnumVal_optionsTag))
-	}
-
-	// reserved ranges
-	for i, rr := range enum.GetReservedRange() {
-		rangePath := append(path, internal.Enum_reservedRangeTag, int32(i))
-		rn := r.getEnumReservedRangeNode(rr).(*rangeNode)
-		sci.newLoc(rn, rangePath)
-		sci.newLoc(rn.stNode, append(rangePath, internal.ReservedRange_startTag))
-		if rn.stNode != rn.enNode {
-			sci.newLoc(rn.enNode, append(rangePath, internal.ReservedRange_endTag))
+	var optIndex, valIndex, reservedNameIndex, reservedRangeIndex int32
+	for _, child := range n.decls {
+		switch {
+		case child.option != nil:
+			r.generateSourceCodeInfoForOption(sci, child.option, false, &optIndex, append(path, internal.Enum_optionsTag))
+		case child.value != nil:
+			r.generateSourceCodeInfoForEnumValue(sci, child.value, append(path, internal.Enum_valuesTag, valIndex))
+			valIndex++
+		case child.reserved != nil:
+			if len(child.reserved.names) > 0 {
+				resPath := append(path, internal.Enum_reservedNameTag)
+				sci.newLoc(child.reserved, resPath)
+				for _, rn := range child.reserved.names {
+					sci.newLoc(rn, append(resPath, reservedNameIndex))
+					reservedNameIndex++
+				}
+			}
+			if len(child.reserved.ranges) > 0 {
+				resPath := append(path, internal.Enum_reservedRangeTag)
+				sci.newLoc(child.reserved, resPath)
+				for _, rr := range child.reserved.ranges {
+					r.generateSourceCodeInfoForReservedRange(sci, rr, append(resPath, reservedRangeIndex))
+					reservedRangeIndex++
+				}
+			}
 		}
 	}
-
-	// reserved names
-	for i, rn := range n.reserved {
-		sci.newLoc(rn, append(path, internal.Enum_reservedNameTag, int32(i)))
-	}
 }
 
-func (r *parseResult) generateSourceCodeInfoForField(sci *sourceCodeInfo, fld *dpb.FieldDescriptorProto, path []int32) {
-	n := r.getFieldNode(fld)
+func (r *parseResult) generateSourceCodeInfoForEnumValue(sci *sourceCodeInfo, n *enumValueNode, path []int32) {
+	sci.newLoc(n, path)
+	sci.newLoc(n.name, append(path, internal.EnumVal_nameTag))
+	sci.newLoc(n.getNumber(), append(path, internal.EnumVal_numberTag))
 
+	// enum value options
+	if n.options != nil {
+		optsPath := append(path, internal.EnumVal_optionsTag)
+		sci.newLoc(n.options, optsPath)
+		var optIndex int32
+		for _, opt := range n.options.decls {
+			r.generateSourceCodeInfoForOption(sci, opt, true, &optIndex, optsPath)
+		}
+	}
+}
+
+func (r *parseResult) generateSourceCodeInfoForReservedRange(sci *sourceCodeInfo, n *rangeNode, path []int32) {
+	sci.newLoc(n, path)
+	sci.newLoc(n.stNode, append(path, internal.ReservedRange_startTag))
+	if n.stNode != n.enNode {
+		sci.newLoc(n.enNode, append(path, internal.ReservedRange_endTag))
+	}
+}
+
+func (r *parseResult) generateSourceCodeInfoForExtensions(sci *sourceCodeInfo, n *extendNode, extendIndex, msgIndex *int32, extendPath, msgPath []int32) {
+	sci.newLoc(n, extendPath)
+	for _, decl := range n.decls {
+		switch {
+		case decl.field != nil:
+			r.generateSourceCodeInfoForField(sci, decl.field, append(extendPath, *extendIndex))
+			*extendIndex++
+		case decl.group != nil:
+			fldPath := append(extendPath, *extendIndex)
+			r.generateSourceCodeInfoForField(sci, decl.group, fldPath)
+			*extendIndex++
+			r.generateSourceCodeInfoForMessage(sci, decl.group, fldPath, append(msgPath, *msgIndex))
+			*msgIndex++
+		}
+	}
+}
+
+func (r *parseResult) generateSourceCodeInfoForOneOf(sci *sourceCodeInfo, n *oneOfNode, fieldIndex, nestedMsgIndex *int32, fieldPath, nestedMsgPath, oneOfPath []int32) {
+	sci.newLoc(n, oneOfPath)
+	sci.newLoc(n.name, append(oneOfPath, internal.OneOf_nameTag))
+
+	var optIndex int32
+	for _, child := range n.decls {
+		switch {
+		case child.option != nil:
+			r.generateSourceCodeInfoForOption(sci, child.option, false, &optIndex, append(oneOfPath, internal.OneOf_optionsTag))
+		case child.field != nil:
+			r.generateSourceCodeInfoForField(sci, child.field, append(fieldPath, *fieldIndex))
+			*fieldIndex++
+		case child.group != nil:
+			fldPath := append(fieldPath, *fieldIndex)
+			r.generateSourceCodeInfoForField(sci, child.group, fldPath)
+			*fieldIndex++
+			r.generateSourceCodeInfoForMessage(sci, child.group, fldPath, append(nestedMsgPath, *nestedMsgIndex))
+			*nestedMsgIndex++
+		}
+	}
+}
+
+func (r *parseResult) generateSourceCodeInfoForField(sci *sourceCodeInfo, n fieldDecl, path []int32) {
 	isGroup := false
-	var opts []*optionNode
+	var opts *compactOptionsNode
 	var extendee *extendNode
+	var fieldType string
 	switch n := n.(type) {
 	case *fieldNode:
 		opts = n.options
 		extendee = n.extendee
+		fieldType = n.fldType.val
 	case *mapFieldNode:
 		opts = n.options
 	case *groupNode:
@@ -315,22 +293,105 @@
 		return
 	}
 
-	sci.newLoc(n, path)
-	if !isGroup {
-		sci.newLoc(n.fieldName(), append(path, internal.Field_nameTag))
+	if isGroup {
+		// comments will appear on group message
+		sci.newLocWithoutComments(n, path)
+		if extendee != nil {
+			sci.newLoc(extendee.extendee, append(path, internal.Field_extendeeTag))
+		}
+		if n.fieldLabel() != nil {
+			// no comments here either (label is first token for group, so we want
+			// to leave the comments to be associated with the group message instead)
+			sci.newLocWithoutComments(n.fieldLabel(), append(path, internal.Field_labelTag))
+		}
 		sci.newLoc(n.fieldType(), append(path, internal.Field_typeTag))
-	}
-	if n.fieldLabel() != nil {
-		sci.newLoc(n.fieldLabel(), append(path, internal.Field_labelTag))
+		// let the name comments be attributed to the group name
+		sci.newLocWithoutComments(n.fieldName(), append(path, internal.Field_nameTag))
+	} else {
+		sci.newLoc(n, path)
+		if extendee != nil {
+			sci.newLoc(extendee.extendee, append(path, internal.Field_extendeeTag))
+		}
+		if n.fieldLabel() != nil {
+			sci.newLoc(n.fieldLabel(), append(path, internal.Field_labelTag))
+		}
+		n.fieldType()
+		var tag int32
+		if _, isScalar := fieldTypes[fieldType]; isScalar {
+			tag = internal.Field_typeTag
+		} else {
+			// this is a message or an enum, so attribute type location
+			// to the type name field
+			tag = internal.Field_typeNameTag
+		}
+		sci.newLoc(n.fieldType(), append(path, tag))
+		sci.newLoc(n.fieldName(), append(path, internal.Field_nameTag))
 	}
 	sci.newLoc(n.fieldTag(), append(path, internal.Field_numberTag))
-	if extendee != nil {
-		sci.newLoc(extendee.extendee, append(path, internal.Field_extendeeTag))
-	}
 
-	r.generateSourceCodeInfoForOptions(sci, opts, func(n interface{}) *optionNode {
-		return n.(*optionNode)
-	}, fld.Options.GetUninterpretedOption(), append(path, internal.Field_optionsTag))
+	if opts != nil {
+		optsPath := append(path, internal.Field_optionsTag)
+		sci.newLoc(opts, optsPath)
+		var optIndex int32
+		for _, opt := range opts.decls {
+			r.generateSourceCodeInfoForOption(sci, opt, true, &optIndex, optsPath)
+		}
+	}
+}
+
+func (r *parseResult) generateSourceCodeInfoForExtensionRanges(sci *sourceCodeInfo, n *extensionRangeNode, extRangeIndex *int32, path []int32) {
+	sci.newLoc(n, path)
+	for _, child := range n.ranges {
+		path := append(path, *extRangeIndex)
+		*extRangeIndex++
+		sci.newLoc(child, path)
+		sci.newLoc(child.stNode, append(path, internal.ExtensionRange_startTag))
+		if child.stNode != child.enNode {
+			sci.newLoc(child.enNode, append(path, internal.ExtensionRange_endTag))
+		}
+		if n.options != nil {
+			optsPath := append(path, internal.ExtensionRange_optionsTag)
+			sci.newLoc(n.options, optsPath)
+			var optIndex int32
+			for _, opt := range n.options.decls {
+				r.generateSourceCodeInfoForOption(sci, opt, true, &optIndex, optsPath)
+			}
+		}
+	}
+}
+
+func (r *parseResult) generateSourceCodeInfoForService(sci *sourceCodeInfo, n *serviceNode, path []int32) {
+	sci.newLoc(n, path)
+	sci.newLoc(n.name, append(path, internal.Service_nameTag))
+	var optIndex, rpcIndex int32
+	for _, child := range n.decls {
+		switch {
+		case child.option != nil:
+			r.generateSourceCodeInfoForOption(sci, child.option, false, &optIndex, append(path, internal.Service_optionsTag))
+		case child.rpc != nil:
+			r.generateSourceCodeInfoForMethod(sci, child.rpc, append(path, internal.Service_methodsTag, rpcIndex))
+			rpcIndex++
+		}
+	}
+}
+
+func (r *parseResult) generateSourceCodeInfoForMethod(sci *sourceCodeInfo, n *methodNode, path []int32) {
+	sci.newLoc(n, path)
+	sci.newLoc(n.name, append(path, internal.Method_nameTag))
+	if n.input.streamKeyword != nil {
+		sci.newLoc(n.input.streamKeyword, append(path, internal.Method_inputStreamTag))
+	}
+	sci.newLoc(n.input.msgType, append(path, internal.Method_inputTag))
+	if n.output.streamKeyword != nil {
+		sci.newLoc(n.output.streamKeyword, append(path, internal.Method_outputStreamTag))
+	}
+	sci.newLoc(n.output.msgType, append(path, internal.Method_outputTag))
+
+	optsPath := append(path, internal.Method_optionsTag)
+	var optIndex int32
+	for _, opt := range n.options {
+		r.generateSourceCodeInfoForOption(sci, opt, false, &optIndex, optsPath)
+	}
 }
 
 type sourceCodeInfo struct {
@@ -338,6 +399,15 @@
 	commentsUsed map[*comment]struct{}
 }
 
+func (sci *sourceCodeInfo) newLocWithoutComments(n node, path []int32) {
+	dup := make([]int32, len(path))
+	copy(dup, path)
+	sci.locs = append(sci.locs, &dpb.SourceCodeInfo_Location{
+		Path: dup,
+		Span: makeSpan(n.start(), n.end()),
+	})
+}
+
 func (sci *sourceCodeInfo) newLoc(n node, path []int32) {
 	leadingComments := n.leadingComments()
 	trailingComments := n.trailingComments()
@@ -348,7 +418,10 @@
 		trailingComments = nil
 	}
 	detached := groupComments(leadingComments)
-	trail := combineComments(trailingComments)
+	var trail *string
+	if str, ok := combineComments(trailingComments); ok {
+		trail = proto.String(str)
+	}
 	var lead *string
 	if len(leadingComments) > 0 && leadingComments[len(leadingComments)-1].end.Line >= n.start().Line-1 {
 		lead = proto.String(detached[len(detached)-1])
@@ -356,34 +429,35 @@
 	}
 	dup := make([]int32, len(path))
 	copy(dup, path)
-	var span []int32
-	if n.start().Line == n.end().Line {
-		span = []int32{int32(n.start().Line) - 1, int32(n.start().Col) - 1, int32(n.end().Col) - 1}
-	} else {
-		span = []int32{int32(n.start().Line) - 1, int32(n.start().Col) - 1, int32(n.end().Line) - 1, int32(n.end().Col) - 1}
-	}
 	sci.locs = append(sci.locs, &dpb.SourceCodeInfo_Location{
 		LeadingDetachedComments: detached,
 		LeadingComments:         lead,
 		TrailingComments:        trail,
 		Path:                    dup,
-		Span:                    span,
+		Span:                    makeSpan(n.start(), n.end()),
 	})
 }
 
-func (sci *sourceCodeInfo) commentUsed(c []*comment) bool {
+func makeSpan(start, end *SourcePos) []int32 {
+	if start.Line == end.Line {
+		return []int32{int32(start.Line) - 1, int32(start.Col) - 1, int32(end.Col) - 1}
+	}
+	return []int32{int32(start.Line) - 1, int32(start.Col) - 1, int32(end.Line) - 1, int32(end.Col) - 1}
+}
+
+func (sci *sourceCodeInfo) commentUsed(c []comment) bool {
 	if len(c) == 0 {
 		return false
 	}
-	if _, ok := sci.commentsUsed[c[0]]; ok {
+	if _, ok := sci.commentsUsed[&c[0]]; ok {
 		return true
 	}
 
-	sci.commentsUsed[c[0]] = struct{}{}
+	sci.commentsUsed[&c[0]] = struct{}{}
 	return false
 }
 
-func groupComments(comments []*comment) []string {
+func groupComments(comments []comment) []string {
 	if len(comments) == 0 {
 		return nil
 	}
@@ -398,29 +472,26 @@
 		singleLineStyle = strings.HasPrefix(comments[i].text, "//")
 		if !singleLineStyle || prevSingleLine != singleLineStyle || c.start.Line > line+1 {
 			// new group!
-			groups = append(groups, *combineComments(comments[start:i]))
+			if str, ok := combineComments(comments[start:i]); ok {
+				groups = append(groups, str)
+			}
 			start = i
 		}
 		line = c.end.Line
 	}
 	// don't forget last group
-	groups = append(groups, *combineComments(comments[start:]))
-
+	if str, ok := combineComments(comments[start:]); ok {
+		groups = append(groups, str)
+	}
 	return groups
 }
 
-func combineComments(comments []*comment) *string {
+func combineComments(comments []comment) (string, bool) {
 	if len(comments) == 0 {
-		return nil
+		return "", false
 	}
-	first := true
 	var buf bytes.Buffer
 	for _, c := range comments {
-		if first {
-			first = false
-		} else {
-			buf.WriteByte('\n')
-		}
 		if c.text[:2] == "//" {
 			buf.WriteString(c.text[2:])
 		} else {
@@ -453,160 +524,9 @@
 			}
 		}
 	}
-	return proto.String(buf.String())
+	return buf.String(), true
 }
 
-func (sci *sourceCodeInfo) generateLocs() []*dpb.SourceCodeInfo_Location {
-	// generate intermediate locations: paths between root (inclusive) and the
-	// leaf locations already created, these will not have comments but will
-	// have aggregate span, than runs from min(start pos) to max(end pos) for
-	// all descendent paths.
-
-	if len(sci.locs) == 0 {
-		// nothing to generate
-		return nil
-	}
-
-	var root locTrie
-	for _, loc := range sci.locs {
-		root.add(loc.Path, loc)
-	}
-	root.fillIn()
-	locs := make([]*dpb.SourceCodeInfo_Location, 0, root.countLocs())
-	root.aggregate(&locs)
-	// finally, sort the resulting slice by location
-	sort.Slice(locs, func(i, j int) bool {
-		startI, endI := getSpanPositions(locs[i].Span)
-		startJ, endJ := getSpanPositions(locs[j].Span)
-		cmp := compareSlice(startI, startJ)
-		if cmp == 0 {
-			// if start position is the same, sort by end position _decreasing_
-			// (so enclosing locations will appear before leaves)
-			cmp = -compareSlice(endI, endJ)
-			if cmp == 0 {
-				// start and end position are the same? so break ties using path
-				cmp = compareSlice(locs[i].Path, locs[j].Path)
-			}
-		}
-		return cmp < 0
-	})
-	return locs
-}
-
-type locTrie struct {
-	children map[int32]*locTrie
-	loc      *dpb.SourceCodeInfo_Location
-}
-
-func (t *locTrie) add(path []int32, loc *dpb.SourceCodeInfo_Location) {
-	if len(path) == 0 {
-		t.loc = loc
-		return
-	}
-	child := t.children[path[0]]
-	if child == nil {
-		if t.children == nil {
-			t.children = map[int32]*locTrie{}
-		}
-		child = &locTrie{}
-		t.children[path[0]] = child
-	}
-	child.add(path[1:], loc)
-}
-
-func (t *locTrie) fillIn() {
-	var path []int32
-	var start, end []int32
-	for _, child := range t.children {
-		// recurse
-		child.fillIn()
-		if t.loc == nil {
-			// maintain min(start) and max(end) so we can
-			// populate t.loc below
-			childStart, childEnd := getSpanPositions(child.loc.Span)
-
-			if start == nil {
-				if path == nil {
-					path = child.loc.Path[:len(child.loc.Path)-1]
-				}
-				start = childStart
-				end = childEnd
-			} else {
-				if compareSlice(childStart, start) < 0 {
-					start = childStart
-				}
-				if compareSlice(childEnd, end) > 0 {
-					end = childEnd
-				}
-			}
-		}
-	}
-
-	if t.loc == nil {
-		var span []int32
-		// we don't use append below because we want a new slice
-		// that doesn't share underlying buffer with spans from
-		// any other location
-		if start[0] == end[0] {
-			span = []int32{start[0], start[1], end[1]}
-		} else {
-			span = []int32{start[0], start[1], end[0], end[1]}
-		}
-		t.loc = &dpb.SourceCodeInfo_Location{
-			Path: path,
-			Span: span,
-		}
-	}
-}
-
-func (t *locTrie) countLocs() int {
-	count := 0
-	if t.loc != nil {
-		count = 1
-	}
-	for _, ch := range t.children {
-		count += ch.countLocs()
-	}
-	return count
-}
-
-func (t *locTrie) aggregate(dest *[]*dpb.SourceCodeInfo_Location) {
-	if t.loc != nil {
-		*dest = append(*dest, t.loc)
-	}
-	for _, child := range t.children {
-		child.aggregate(dest)
-	}
-}
-
-func getSpanPositions(span []int32) (start, end []int32) {
-	start = span[:2]
-	if len(span) == 3 {
-		end = []int32{span[0], span[2]}
-	} else {
-		end = span[2:]
-	}
-	return
-}
-
-func compareSlice(a, b []int32) int {
-	end := len(a)
-	if len(b) < end {
-		end = len(b)
-	}
-	for i := 0; i < end; i++ {
-		if a[i] < b[i] {
-			return -1
-		}
-		if a[i] > b[i] {
-			return 1
-		}
-	}
-	if len(a) < len(b) {
-		return -1
-	}
-	if len(a) > len(b) {
-		return 1
-	}
-	return 0
+func dup(p []int32) []int32 {
+	return append(([]int32)(nil), p...)
 }
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/std_imports.go b/vendor/github.com/jhump/protoreflect/desc/protoparse/std_imports.go
index 59bcdd3..8fbc1fc 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/std_imports.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/std_imports.go
@@ -42,8 +42,9 @@
 	standardImports = map[string]*dpb.FileDescriptorProto{}
 	for _, fn := range standardFilenames {
 		fd, err := internal.LoadFileDescriptor(fn)
-		if err == nil {
-			standardImports[fn] = fd
+		if err != nil {
+			panic(err.Error())
 		}
+		standardImports[fn] = fd
 	}
 }
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoparse/test-source-info.txt b/vendor/github.com/jhump/protoreflect/desc/protoparse/test-source-info.txt
index c03fd64..324fb19 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoparse/test-source-info.txt
+++ b/vendor/github.com/jhump/protoreflect/desc/protoparse/test-source-info.txt
@@ -3,7 +3,7 @@
 
 :
 desc_test_comments.proto:8:1
-desc_test_comments.proto:119:2
+desc_test_comments.proto:141:2
 
 
  > syntax:
@@ -11,18 +11,22 @@
 desc_test_comments.proto:8:19
     Leading detached comment [0]:
  This is the first detached comment for the syntax.
+
     Leading detached comment [1]:
 
  This is a second detached comment.
 
     Leading detached comment [2]:
  This is a third.
+
     Leading comments:
  Syntax comment...
+
     Trailing comments:
  Syntax trailer.
 
 
+
  > package:
 desc_test_comments.proto:12:1
 desc_test_comments.proto:12:17
@@ -30,6 +34,7 @@
  And now the package declaration
 
 
+
  > options:
 desc_test_comments.proto:15:1
 desc_test_comments.proto:15:75
@@ -42,10 +47,6 @@
  option comments FTW!!!
 
 
- > dependency:
-desc_test_comments.proto:17:1
-desc_test_comments.proto:18:34
-
 
  > dependency[0]:
 desc_test_comments.proto:17:1
@@ -57,23 +58,21 @@
 desc_test_comments.proto:18:34
 
 
- > message_type:
-desc_test_comments.proto:25:1
-desc_test_comments.proto:89:2
-
-
  > message_type[0]:
 desc_test_comments.proto:25:1
-desc_test_comments.proto:89:2
+desc_test_comments.proto:105:2
     Leading detached comment [0]:
  Multiple white space lines (like above) cannot
  be preserved...
+
     Leading comments:
  We need a request for our RPC service below.
+
     Trailing comments:
  And next we'll need some extensions...
 
 
+
  > message_type[0] > name:
 desc_test_comments.proto:25:68
 desc_test_comments.proto:25:75
@@ -85,48 +84,49 @@
  trailer
 
 
+
  > message_type[0] > options:
-desc_test_comments.proto:26:3
-desc_test_comments.proto:35:54
+desc_test_comments.proto:26:9
+desc_test_comments.proto:26:34
 
 
  > message_type[0] > options > deprecated:
-desc_test_comments.proto:26:3
-desc_test_comments.proto:26:28
+desc_test_comments.proto:26:9
+desc_test_comments.proto:26:34
+    Trailing comments:
+ deprecated!
 
 
- > message_type[0] > field:
-desc_test_comments.proto:29:2
-desc_test_comments.proto:66:3
-
 
  > message_type[0] > field[0]:
-desc_test_comments.proto:29:2
-desc_test_comments.proto:32:92
+desc_test_comments.proto:29:9
+desc_test_comments.proto:32:132
     Leading comments:
  A field comment
+
     Trailing comments:
  field trailer #1...
 
 
+
  > message_type[0] > field[0] > label:
-desc_test_comments.proto:29:2
-desc_test_comments.proto:29:10
+desc_test_comments.proto:29:9
+desc_test_comments.proto:29:17
 
 
  > message_type[0] > field[0] > type:
-desc_test_comments.proto:29:11
-desc_test_comments.proto:29:16
+desc_test_comments.proto:29:18
+desc_test_comments.proto:29:23
 
 
  > message_type[0] > field[0] > name:
-desc_test_comments.proto:29:17
-desc_test_comments.proto:29:20
+desc_test_comments.proto:29:24
+desc_test_comments.proto:29:27
 
 
  > message_type[0] > field[0] > number:
-desc_test_comments.proto:29:63
-desc_test_comments.proto:29:64
+desc_test_comments.proto:29:70
+desc_test_comments.proto:29:71
     Leading detached comment [0]:
  detached tag 
     Leading comments:
@@ -138,84 +138,97 @@
 
 
  > message_type[0] > field[0] > options:
-desc_test_comments.proto:32:5
-desc_test_comments.proto:32:90
+desc_test_comments.proto:32:11
+desc_test_comments.proto:32:131
 
 
  > message_type[0] > field[0] > options > packed:
-desc_test_comments.proto:32:5
-desc_test_comments.proto:32:16
+desc_test_comments.proto:32:12
+desc_test_comments.proto:32:23
+    Trailing comments:
+ packed! 
 
 
  > message_type[0] > field[0] > json_name:
-desc_test_comments.proto:32:18
-desc_test_comments.proto:32:35
-
-
- > message_type[0] > field[0] > options > ffubar:
-desc_test_comments.proto:32:37
-desc_test_comments.proto:32:62
+desc_test_comments.proto:32:39
+desc_test_comments.proto:32:56
+    Trailing comments:
+ custom JSON! 
 
 
  > message_type[0] > field[0] > options > ffubar[0]:
-desc_test_comments.proto:32:37
-desc_test_comments.proto:32:62
+desc_test_comments.proto:32:77
+desc_test_comments.proto:32:102
 
 
  > message_type[0] > field[0] > options > ffubarb:
-desc_test_comments.proto:32:64
-desc_test_comments.proto:32:90
+desc_test_comments.proto:32:104
+desc_test_comments.proto:32:130
+
+
+ > message_type[0] > options:
+desc_test_comments.proto:35:27
+desc_test_comments.proto:35:61
 
 
  > message_type[0] > options > mfubar:
-desc_test_comments.proto:35:20
-desc_test_comments.proto:35:54
+desc_test_comments.proto:35:27
+desc_test_comments.proto:35:61
     Leading comments:
  lead mfubar 
     Trailing comments:
  trailing mfubar
 
 
+
  > message_type[0] > field[1]:
-desc_test_comments.proto:42:22
-desc_test_comments.proto:43:63
+desc_test_comments.proto:42:29
+desc_test_comments.proto:43:77
     Leading detached comment [0]:
  some detached comments
+
     Leading detached comment [1]:
  some detached comments
+
     Leading detached comment [2]:
  Another field comment
+
     Leading comments:
  label comment 
 
 
  > message_type[0] > field[1] > label:
-desc_test_comments.proto:42:22
-desc_test_comments.proto:42:30
+desc_test_comments.proto:42:29
+desc_test_comments.proto:42:37
 
 
  > message_type[0] > field[1] > type:
-desc_test_comments.proto:42:50
-desc_test_comments.proto:42:56
+desc_test_comments.proto:42:57
+desc_test_comments.proto:42:63
     Leading comments:
  type comment 
 
 
  > message_type[0] > field[1] > name:
-desc_test_comments.proto:42:76
-desc_test_comments.proto:42:80
+desc_test_comments.proto:42:83
+desc_test_comments.proto:42:87
     Leading comments:
  name comment 
 
 
  > message_type[0] > field[1] > number:
-desc_test_comments.proto:42:83
-desc_test_comments.proto:42:84
+desc_test_comments.proto:42:90
+desc_test_comments.proto:42:91
+
+
+ > message_type[0] > field[1] > options:
+desc_test_comments.proto:43:17
+desc_test_comments.proto:43:76
 
 
  > message_type[0] > field[1] > default_value:
-desc_test_comments.proto:43:23
-desc_test_comments.proto:43:40
+desc_test_comments.proto:43:37
+desc_test_comments.proto:43:54
     Leading comments:
  default lead 
     Trailing comments:
@@ -223,627 +236,826 @@
 
 
  > message_type[0] > extension_range:
-desc_test_comments.proto:46:13
-desc_test_comments.proto:47:23
+desc_test_comments.proto:46:9
+desc_test_comments.proto:46:31
+    Leading comments:
+ extension range comments are (sadly) not preserved
+
 
 
  > message_type[0] > extension_range[0]:
-desc_test_comments.proto:46:13
-desc_test_comments.proto:46:23
+desc_test_comments.proto:46:20
+desc_test_comments.proto:46:30
 
 
  > message_type[0] > extension_range[0] > start:
-desc_test_comments.proto:46:13
-desc_test_comments.proto:46:16
-
-
- > message_type[0] > extension_range[0] > end:
 desc_test_comments.proto:46:20
 desc_test_comments.proto:46:23
 
 
+ > message_type[0] > extension_range[0] > end:
+desc_test_comments.proto:46:27
+desc_test_comments.proto:46:30
+
+
+ > message_type[0] > extension_range:
+desc_test_comments.proto:47:9
+desc_test_comments.proto:47:109
+
+
  > message_type[0] > extension_range[1]:
-desc_test_comments.proto:47:13
-desc_test_comments.proto:47:23
+desc_test_comments.proto:47:20
+desc_test_comments.proto:47:30
 
 
  > message_type[0] > extension_range[1] > start:
-desc_test_comments.proto:47:13
-desc_test_comments.proto:47:16
-
-
- > message_type[0] > extension_range[1] > end:
 desc_test_comments.proto:47:20
 desc_test_comments.proto:47:23
 
 
+ > message_type[0] > extension_range[1] > end:
+desc_test_comments.proto:47:27
+desc_test_comments.proto:47:30
+
+
  > message_type[0] > extension_range[1] > options:
-desc_test_comments.proto:47:25
-desc_test_comments.proto:47:100
+desc_test_comments.proto:47:31
+desc_test_comments.proto:47:108
 
 
  > message_type[0] > extension_range[1] > options > exfubarb:
-desc_test_comments.proto:47:25
-desc_test_comments.proto:47:67
-
-
- > message_type[0] > extension_range[1] > options > exfubar:
-desc_test_comments.proto:47:69
-desc_test_comments.proto:47:100
+desc_test_comments.proto:47:32
+desc_test_comments.proto:47:74
 
 
  > message_type[0] > extension_range[1] > options > exfubar[0]:
-desc_test_comments.proto:47:69
-desc_test_comments.proto:47:100
+desc_test_comments.proto:47:76
+desc_test_comments.proto:47:107
 
 
  > message_type[0] > reserved_range:
-desc_test_comments.proto:51:50
-desc_test_comments.proto:51:68
+desc_test_comments.proto:51:48
+desc_test_comments.proto:51:77
+    Leading detached comment [0]:
+ another detached comment
+
+    Leading comments:
+ same for reserved range comments 
 
 
  > message_type[0] > reserved_range[0]:
-desc_test_comments.proto:51:50
-desc_test_comments.proto:51:58
+desc_test_comments.proto:51:57
+desc_test_comments.proto:51:65
 
 
  > message_type[0] > reserved_range[0] > start:
-desc_test_comments.proto:51:50
-desc_test_comments.proto:51:52
+desc_test_comments.proto:51:57
+desc_test_comments.proto:51:59
 
 
  > message_type[0] > reserved_range[0] > end:
-desc_test_comments.proto:51:56
-desc_test_comments.proto:51:58
+desc_test_comments.proto:51:63
+desc_test_comments.proto:51:65
 
 
  > message_type[0] > reserved_range[1]:
-desc_test_comments.proto:51:60
-desc_test_comments.proto:51:68
+desc_test_comments.proto:51:67
+desc_test_comments.proto:51:75
 
 
  > message_type[0] > reserved_range[1] > start:
-desc_test_comments.proto:51:60
-desc_test_comments.proto:51:62
+desc_test_comments.proto:51:67
+desc_test_comments.proto:51:69
 
 
  > message_type[0] > reserved_range[1] > end:
-desc_test_comments.proto:51:66
-desc_test_comments.proto:51:68
+desc_test_comments.proto:51:73
+desc_test_comments.proto:51:75
 
 
  > message_type[0] > reserved_name:
-desc_test_comments.proto:52:11
-desc_test_comments.proto:52:30
+desc_test_comments.proto:52:9
+desc_test_comments.proto:52:38
+    Trailing comments:
+ reserved trailers 
 
 
  > message_type[0] > reserved_name[0]:
-desc_test_comments.proto:52:11
-desc_test_comments.proto:52:16
-
-
- > message_type[0] > reserved_name[1]:
 desc_test_comments.proto:52:18
 desc_test_comments.proto:52:23
 
 
- > message_type[0] > reserved_name[2]:
+ > message_type[0] > reserved_name[1]:
 desc_test_comments.proto:52:25
 desc_test_comments.proto:52:30
 
 
+ > message_type[0] > reserved_name[2]:
+desc_test_comments.proto:52:32
+desc_test_comments.proto:52:37
+
+
  > message_type[0] > field[2]:
-desc_test_comments.proto:55:2
-desc_test_comments.proto:66:3
+desc_test_comments.proto:55:9
+desc_test_comments.proto:67:10
+
+
+ > message_type[0] > field[2] > label:
+desc_test_comments.proto:55:9
+desc_test_comments.proto:55:17
+
+
+ > message_type[0] > field[2] > type:
+desc_test_comments.proto:55:18
+desc_test_comments.proto:55:23
+
+
+ > message_type[0] > field[2] > name:
+desc_test_comments.proto:55:41
+desc_test_comments.proto:55:47
+
+
+ > message_type[0] > field[2] > number:
+desc_test_comments.proto:55:50
+desc_test_comments.proto:55:51
+
+
+ > message_type[0] > nested_type[0]:
+desc_test_comments.proto:55:9
+desc_test_comments.proto:67:10
     Leading comments:
  Group comment
 
 
- > message_type[0] > nested_type:
-desc_test_comments.proto:55:2
-desc_test_comments.proto:66:3
-
-
- > message_type[0] > nested_type[0]:
-desc_test_comments.proto:55:2
-desc_test_comments.proto:66:3
-
-
- > message_type[0] > field[2] > label:
-desc_test_comments.proto:55:2
-desc_test_comments.proto:55:10
-
 
  > message_type[0] > nested_type[0] > name:
-desc_test_comments.proto:55:34
-desc_test_comments.proto:55:40
+desc_test_comments.proto:55:41
+desc_test_comments.proto:55:47
     Leading comments:
  group name 
 
 
- > message_type[0] > field[2] > number:
-desc_test_comments.proto:55:43
-desc_test_comments.proto:55:44
+ > message_type[0] > field[2] > type_name:
+desc_test_comments.proto:55:41
+desc_test_comments.proto:55:47
 
 
  > message_type[0] > nested_type[0] > options:
-desc_test_comments.proto:56:3
-desc_test_comments.proto:61:50
+desc_test_comments.proto:57:17
+desc_test_comments.proto:57:52
 
 
  > message_type[0] > nested_type[0] > options > mfubar:
-desc_test_comments.proto:56:3
-desc_test_comments.proto:56:38
+desc_test_comments.proto:57:17
+desc_test_comments.proto:57:52
+    Leading comments:
+ this is a custom option
 
 
- > message_type[0] > nested_type[0] > field:
-desc_test_comments.proto:58:3
-desc_test_comments.proto:64:27
-
 
  > message_type[0] > nested_type[0] > field[0]:
-desc_test_comments.proto:58:3
-desc_test_comments.proto:58:27
+desc_test_comments.proto:59:17
+desc_test_comments.proto:59:41
 
 
  > message_type[0] > nested_type[0] > field[0] > label:
-desc_test_comments.proto:58:3
-desc_test_comments.proto:58:11
-
-
- > message_type[0] > nested_type[0] > field[0] > type:
-desc_test_comments.proto:58:12
-desc_test_comments.proto:58:18
-
-
- > message_type[0] > nested_type[0] > field[0] > name:
-desc_test_comments.proto:58:19
-desc_test_comments.proto:58:22
-
-
- > message_type[0] > nested_type[0] > field[0] > number:
-desc_test_comments.proto:58:25
-desc_test_comments.proto:58:26
-
-
- > message_type[0] > nested_type[0] > field[1]:
-desc_test_comments.proto:59:3
-desc_test_comments.proto:59:26
-
-
- > message_type[0] > nested_type[0] > field[1] > label:
-desc_test_comments.proto:59:3
-desc_test_comments.proto:59:11
-
-
- > message_type[0] > nested_type[0] > field[1] > type:
-desc_test_comments.proto:59:12
 desc_test_comments.proto:59:17
-
-
- > message_type[0] > nested_type[0] > field[1] > name:
-desc_test_comments.proto:59:18
-desc_test_comments.proto:59:21
-
-
- > message_type[0] > nested_type[0] > field[1] > number:
-desc_test_comments.proto:59:24
 desc_test_comments.proto:59:25
 
 
+ > message_type[0] > nested_type[0] > field[0] > type:
+desc_test_comments.proto:59:26
+desc_test_comments.proto:59:32
+
+
+ > message_type[0] > nested_type[0] > field[0] > name:
+desc_test_comments.proto:59:33
+desc_test_comments.proto:59:36
+
+
+ > message_type[0] > nested_type[0] > field[0] > number:
+desc_test_comments.proto:59:39
+desc_test_comments.proto:59:40
+
+
+ > message_type[0] > nested_type[0] > field[1]:
+desc_test_comments.proto:60:17
+desc_test_comments.proto:60:40
+
+
+ > message_type[0] > nested_type[0] > field[1] > label:
+desc_test_comments.proto:60:17
+desc_test_comments.proto:60:25
+
+
+ > message_type[0] > nested_type[0] > field[1] > type:
+desc_test_comments.proto:60:26
+desc_test_comments.proto:60:31
+
+
+ > message_type[0] > nested_type[0] > field[1] > name:
+desc_test_comments.proto:60:32
+desc_test_comments.proto:60:35
+
+
+ > message_type[0] > nested_type[0] > field[1] > number:
+desc_test_comments.proto:60:38
+desc_test_comments.proto:60:39
+
+
+ > message_type[0] > nested_type[0] > options:
+desc_test_comments.proto:62:17
+desc_test_comments.proto:62:64
+
+
  > message_type[0] > nested_type[0] > options > no_standard_descriptor_accessor:
-desc_test_comments.proto:61:3
-desc_test_comments.proto:61:50
+desc_test_comments.proto:62:17
+desc_test_comments.proto:62:64
 
 
  > message_type[0] > nested_type[0] > field[2]:
-desc_test_comments.proto:64:3
-desc_test_comments.proto:64:27
+desc_test_comments.proto:65:17
+desc_test_comments.proto:65:41
     Leading comments:
  Leading comment...
+
     Trailing comments:
  Trailing comment...
 
 
+
  > message_type[0] > nested_type[0] > field[2] > label:
-desc_test_comments.proto:64:3
-desc_test_comments.proto:64:11
+desc_test_comments.proto:65:17
+desc_test_comments.proto:65:25
 
 
  > message_type[0] > nested_type[0] > field[2] > type:
-desc_test_comments.proto:64:12
-desc_test_comments.proto:64:18
+desc_test_comments.proto:65:26
+desc_test_comments.proto:65:32
 
 
  > message_type[0] > nested_type[0] > field[2] > name:
-desc_test_comments.proto:64:19
-desc_test_comments.proto:64:22
+desc_test_comments.proto:65:33
+desc_test_comments.proto:65:36
 
 
  > message_type[0] > nested_type[0] > field[2] > number:
-desc_test_comments.proto:64:25
-desc_test_comments.proto:64:26
-
-
- > message_type[0] > enum_type:
-desc_test_comments.proto:68:2
-desc_test_comments.proto:88:3
+desc_test_comments.proto:65:39
+desc_test_comments.proto:65:40
 
 
  > message_type[0] > enum_type[0]:
-desc_test_comments.proto:68:2
-desc_test_comments.proto:88:3
+desc_test_comments.proto:69:9
+desc_test_comments.proto:90:10
 
 
  > message_type[0] > enum_type[0] > name:
-desc_test_comments.proto:68:7
-desc_test_comments.proto:68:22
+desc_test_comments.proto:69:14
+desc_test_comments.proto:69:29
     Trailing comments:
  "super"!
 
 
- > message_type[0] > enum_type[0] > value:
-desc_test_comments.proto:72:3
-desc_test_comments.proto:85:17
+
+ > message_type[0] > enum_type[0] > options:
+desc_test_comments.proto:72:17
+desc_test_comments.proto:72:43
+
+
+ > message_type[0] > enum_type[0] > options > allow_alias:
+desc_test_comments.proto:72:17
+desc_test_comments.proto:72:43
+    Leading comments:
+ allow_alias comments!
+
 
 
  > message_type[0] > enum_type[0] > value[0]:
-desc_test_comments.proto:72:3
-desc_test_comments.proto:72:72
+desc_test_comments.proto:74:17
+desc_test_comments.proto:74:86
 
 
  > message_type[0] > enum_type[0] > value[0] > name:
-desc_test_comments.proto:72:3
-desc_test_comments.proto:72:8
+desc_test_comments.proto:74:17
+desc_test_comments.proto:74:22
 
 
  > message_type[0] > enum_type[0] > value[0] > number:
-desc_test_comments.proto:72:11
-desc_test_comments.proto:72:12
+desc_test_comments.proto:74:25
+desc_test_comments.proto:74:26
 
 
  > message_type[0] > enum_type[0] > value[0] > options:
-desc_test_comments.proto:72:14
-desc_test_comments.proto:72:70
+desc_test_comments.proto:74:27
+desc_test_comments.proto:74:85
 
 
  > message_type[0] > enum_type[0] > value[0] > options > evfubars:
-desc_test_comments.proto:72:14
-desc_test_comments.proto:72:42
+desc_test_comments.proto:74:28
+desc_test_comments.proto:74:56
 
 
  > message_type[0] > enum_type[0] > value[0] > options > evfubar:
-desc_test_comments.proto:72:44
-desc_test_comments.proto:72:70
+desc_test_comments.proto:74:58
+desc_test_comments.proto:74:84
 
 
  > message_type[0] > enum_type[0] > value[1]:
-desc_test_comments.proto:73:3
-desc_test_comments.proto:73:86
+desc_test_comments.proto:75:17
+desc_test_comments.proto:75:100
 
 
  > message_type[0] > enum_type[0] > value[1] > name:
-desc_test_comments.proto:73:3
-desc_test_comments.proto:73:8
+desc_test_comments.proto:75:17
+desc_test_comments.proto:75:22
 
 
  > message_type[0] > enum_type[0] > value[1] > number:
-desc_test_comments.proto:73:11
-desc_test_comments.proto:73:12
+desc_test_comments.proto:75:25
+desc_test_comments.proto:75:26
 
 
  > message_type[0] > enum_type[0] > value[1] > options:
-desc_test_comments.proto:73:15
-desc_test_comments.proto:73:84
+desc_test_comments.proto:75:27
+desc_test_comments.proto:75:99
 
 
  > message_type[0] > enum_type[0] > value[1] > options > evfubaruf:
-desc_test_comments.proto:73:15
-desc_test_comments.proto:73:43
+desc_test_comments.proto:75:29
+desc_test_comments.proto:75:57
 
 
  > message_type[0] > enum_type[0] > value[1] > options > evfubaru:
-desc_test_comments.proto:73:59
-desc_test_comments.proto:73:84
+desc_test_comments.proto:75:73
+desc_test_comments.proto:75:98
 
 
  > message_type[0] > enum_type[0] > value[2]:
-desc_test_comments.proto:74:3
-desc_test_comments.proto:74:13
+desc_test_comments.proto:76:17
+desc_test_comments.proto:76:27
 
 
  > message_type[0] > enum_type[0] > value[2] > name:
-desc_test_comments.proto:74:3
-desc_test_comments.proto:74:8
+desc_test_comments.proto:76:17
+desc_test_comments.proto:76:22
 
 
  > message_type[0] > enum_type[0] > value[2] > number:
-desc_test_comments.proto:74:11
-desc_test_comments.proto:74:12
+desc_test_comments.proto:76:25
+desc_test_comments.proto:76:26
 
 
  > message_type[0] > enum_type[0] > value[3]:
-desc_test_comments.proto:75:3
-desc_test_comments.proto:75:14
+desc_test_comments.proto:77:17
+desc_test_comments.proto:77:28
 
 
  > message_type[0] > enum_type[0] > value[3] > name:
-desc_test_comments.proto:75:3
-desc_test_comments.proto:75:9
+desc_test_comments.proto:77:17
+desc_test_comments.proto:77:23
 
 
  > message_type[0] > enum_type[0] > value[3] > number:
-desc_test_comments.proto:75:12
-desc_test_comments.proto:75:13
+desc_test_comments.proto:77:26
+desc_test_comments.proto:77:27
 
 
  > message_type[0] > enum_type[0] > options:
-desc_test_comments.proto:77:3
-desc_test_comments.proto:87:36
+desc_test_comments.proto:79:17
+desc_test_comments.proto:79:52
 
 
  > message_type[0] > enum_type[0] > options > efubars:
-desc_test_comments.proto:77:3
-desc_test_comments.proto:77:38
+desc_test_comments.proto:79:17
+desc_test_comments.proto:79:52
 
 
  > message_type[0] > enum_type[0] > value[4]:
-desc_test_comments.proto:79:3
-desc_test_comments.proto:79:13
+desc_test_comments.proto:81:17
+desc_test_comments.proto:81:27
 
 
  > message_type[0] > enum_type[0] > value[4] > name:
-desc_test_comments.proto:79:3
-desc_test_comments.proto:79:8
+desc_test_comments.proto:81:17
+desc_test_comments.proto:81:22
 
 
  > message_type[0] > enum_type[0] > value[4] > number:
-desc_test_comments.proto:79:11
-desc_test_comments.proto:79:12
+desc_test_comments.proto:81:25
+desc_test_comments.proto:81:26
 
 
  > message_type[0] > enum_type[0] > value[5]:
-desc_test_comments.proto:80:3
-desc_test_comments.proto:80:15
+desc_test_comments.proto:82:17
+desc_test_comments.proto:82:29
 
 
  > message_type[0] > enum_type[0] > value[5] > name:
-desc_test_comments.proto:80:3
-desc_test_comments.proto:80:10
+desc_test_comments.proto:82:17
+desc_test_comments.proto:82:24
 
 
  > message_type[0] > enum_type[0] > value[5] > number:
-desc_test_comments.proto:80:13
-desc_test_comments.proto:80:14
+desc_test_comments.proto:82:27
+desc_test_comments.proto:82:28
 
 
  > message_type[0] > enum_type[0] > value[6]:
-desc_test_comments.proto:81:3
-desc_test_comments.proto:81:46
+desc_test_comments.proto:83:17
+desc_test_comments.proto:83:60
 
 
  > message_type[0] > enum_type[0] > value[6] > name:
-desc_test_comments.proto:81:3
-desc_test_comments.proto:81:10
+desc_test_comments.proto:83:17
+desc_test_comments.proto:83:24
 
 
  > message_type[0] > enum_type[0] > value[6] > number:
-desc_test_comments.proto:81:13
-desc_test_comments.proto:81:14
+desc_test_comments.proto:83:27
+desc_test_comments.proto:83:28
 
 
  > message_type[0] > enum_type[0] > value[6] > options:
-desc_test_comments.proto:81:16
-desc_test_comments.proto:81:44
+desc_test_comments.proto:83:29
+desc_test_comments.proto:83:59
 
 
  > message_type[0] > enum_type[0] > value[6] > options > evfubarsf:
-desc_test_comments.proto:81:16
-desc_test_comments.proto:81:44
+desc_test_comments.proto:83:30
+desc_test_comments.proto:83:58
 
 
  > message_type[0] > enum_type[0] > value[7]:
-desc_test_comments.proto:82:3
-desc_test_comments.proto:82:14
+desc_test_comments.proto:84:17
+desc_test_comments.proto:84:28
 
 
  > message_type[0] > enum_type[0] > value[7] > name:
-desc_test_comments.proto:82:3
-desc_test_comments.proto:82:9
+desc_test_comments.proto:84:17
+desc_test_comments.proto:84:23
 
 
  > message_type[0] > enum_type[0] > value[7] > number:
-desc_test_comments.proto:82:12
-desc_test_comments.proto:82:13
+desc_test_comments.proto:84:26
+desc_test_comments.proto:84:27
 
 
  > message_type[0] > enum_type[0] > value[8]:
-desc_test_comments.proto:83:3
-desc_test_comments.proto:83:17
+desc_test_comments.proto:85:17
+desc_test_comments.proto:85:31
 
 
  > message_type[0] > enum_type[0] > value[8] > name:
-desc_test_comments.proto:83:3
-desc_test_comments.proto:83:12
+desc_test_comments.proto:85:17
+desc_test_comments.proto:85:26
 
 
  > message_type[0] > enum_type[0] > value[8] > number:
-desc_test_comments.proto:83:15
-desc_test_comments.proto:83:16
+desc_test_comments.proto:85:29
+desc_test_comments.proto:85:30
 
 
  > message_type[0] > enum_type[0] > value[9]:
-desc_test_comments.proto:84:3
-desc_test_comments.proto:84:13
+desc_test_comments.proto:86:17
+desc_test_comments.proto:86:27
 
 
  > message_type[0] > enum_type[0] > value[9] > name:
-desc_test_comments.proto:84:3
-desc_test_comments.proto:84:8
+desc_test_comments.proto:86:17
+desc_test_comments.proto:86:22
 
 
  > message_type[0] > enum_type[0] > value[9] > number:
-desc_test_comments.proto:84:11
-desc_test_comments.proto:84:12
+desc_test_comments.proto:86:25
+desc_test_comments.proto:86:26
 
 
  > message_type[0] > enum_type[0] > value[10]:
-desc_test_comments.proto:85:3
-desc_test_comments.proto:85:17
+desc_test_comments.proto:87:17
+desc_test_comments.proto:87:31
 
 
  > message_type[0] > enum_type[0] > value[10] > name:
-desc_test_comments.proto:85:3
-desc_test_comments.proto:85:9
+desc_test_comments.proto:87:17
+desc_test_comments.proto:87:23
 
 
  > message_type[0] > enum_type[0] > value[10] > number:
-desc_test_comments.proto:85:12
-desc_test_comments.proto:85:16
+desc_test_comments.proto:87:26
+desc_test_comments.proto:87:30
+
+
+ > message_type[0] > enum_type[0] > options:
+desc_test_comments.proto:89:17
+desc_test_comments.proto:89:50
 
 
  > message_type[0] > enum_type[0] > options > efubar:
-desc_test_comments.proto:87:3
-desc_test_comments.proto:87:36
+desc_test_comments.proto:89:17
+desc_test_comments.proto:89:50
 
 
- > extension[0] > extendee:
-desc_test_comments.proto:94:1
-desc_test_comments.proto:94:8
+ > message_type[0] > oneof_decl[0]:
+desc_test_comments.proto:93:9
+desc_test_comments.proto:96:10
     Leading comments:
- extendee comment
+ can be this or that
 
 
- > extension[1] > extendee:
-desc_test_comments.proto:94:1
-desc_test_comments.proto:94:8
+
+ > message_type[0] > oneof_decl[0] > name:
+desc_test_comments.proto:93:15
+desc_test_comments.proto:93:18
+
+
+ > message_type[0] > field[3]:
+desc_test_comments.proto:94:17
+desc_test_comments.proto:94:33
+
+
+ > message_type[0] > field[3] > type:
+desc_test_comments.proto:94:17
+desc_test_comments.proto:94:23
+
+
+ > message_type[0] > field[3] > name:
+desc_test_comments.proto:94:24
+desc_test_comments.proto:94:28
+
+
+ > message_type[0] > field[3] > number:
+desc_test_comments.proto:94:31
+desc_test_comments.proto:94:32
+
+
+ > message_type[0] > field[4]:
+desc_test_comments.proto:95:17
+desc_test_comments.proto:95:32
+
+
+ > message_type[0] > field[4] > type:
+desc_test_comments.proto:95:17
+desc_test_comments.proto:95:22
+
+
+ > message_type[0] > field[4] > name:
+desc_test_comments.proto:95:23
+desc_test_comments.proto:95:27
+
+
+ > message_type[0] > field[4] > number:
+desc_test_comments.proto:95:30
+desc_test_comments.proto:95:31
+
+
+ > message_type[0] > oneof_decl[1]:
+desc_test_comments.proto:98:9
+desc_test_comments.proto:101:10
+    Leading comments:
+ can be these or those
+
+
+
+ > message_type[0] > oneof_decl[1] > name:
+desc_test_comments.proto:98:15
+desc_test_comments.proto:98:18
+
+
+ > message_type[0] > field[5]:
+desc_test_comments.proto:99:17
+desc_test_comments.proto:99:34
+
+
+ > message_type[0] > field[5] > type:
+desc_test_comments.proto:99:17
+desc_test_comments.proto:99:23
+
+
+ > message_type[0] > field[5] > name:
+desc_test_comments.proto:99:24
+desc_test_comments.proto:99:29
+
+
+ > message_type[0] > field[5] > number:
+desc_test_comments.proto:99:32
+desc_test_comments.proto:99:33
+
+
+ > message_type[0] > field[6]:
+desc_test_comments.proto:100:17
+desc_test_comments.proto:100:33
+
+
+ > message_type[0] > field[6] > type:
+desc_test_comments.proto:100:17
+desc_test_comments.proto:100:22
+
+
+ > message_type[0] > field[6] > name:
+desc_test_comments.proto:100:23
+desc_test_comments.proto:100:28
+
+
+ > message_type[0] > field[6] > number:
+desc_test_comments.proto:100:31
+desc_test_comments.proto:100:32
+
+
+ > message_type[0] > field[7]:
+desc_test_comments.proto:104:9
+desc_test_comments.proto:104:40
+    Leading comments:
+ map field
+
+
+
+ > message_type[0] > field[7] > type_name:
+desc_test_comments.proto:104:9
+desc_test_comments.proto:104:28
+
+
+ > message_type[0] > field[7] > name:
+desc_test_comments.proto:104:29
+desc_test_comments.proto:104:35
+
+
+ > message_type[0] > field[7] > number:
+desc_test_comments.proto:104:38
+desc_test_comments.proto:104:39
 
 
  > extension:
-desc_test_comments.proto:96:2
-desc_test_comments.proto:98:30
+desc_test_comments.proto:108:1
+desc_test_comments.proto:117:2
+    Trailing comments:
+ extend trailer...
+
 
 
  > extension[0]:
-desc_test_comments.proto:96:2
-desc_test_comments.proto:96:30
+desc_test_comments.proto:114:9
+desc_test_comments.proto:114:37
     Leading comments:
  comment for guid1
 
 
+
+ > extension[0] > extendee:
+desc_test_comments.proto:110:1
+desc_test_comments.proto:110:8
+    Leading comments:
+ extendee comment
+
+    Trailing comments:
+ extendee trailer
+
+
+
  > extension[0] > label:
-desc_test_comments.proto:96:2
-desc_test_comments.proto:96:10
+desc_test_comments.proto:114:9
+desc_test_comments.proto:114:17
 
 
  > extension[0] > type:
-desc_test_comments.proto:96:11
-desc_test_comments.proto:96:17
+desc_test_comments.proto:114:18
+desc_test_comments.proto:114:24
 
 
  > extension[0] > name:
-desc_test_comments.proto:96:18
-desc_test_comments.proto:96:23
+desc_test_comments.proto:114:25
+desc_test_comments.proto:114:30
 
 
  > extension[0] > number:
-desc_test_comments.proto:96:26
-desc_test_comments.proto:96:29
+desc_test_comments.proto:114:33
+desc_test_comments.proto:114:36
 
 
  > extension[1]:
-desc_test_comments.proto:98:2
-desc_test_comments.proto:98:30
+desc_test_comments.proto:116:9
+desc_test_comments.proto:116:37
     Leading comments:
  ... and a comment for guid2
 
 
+
+ > extension[1] > extendee:
+desc_test_comments.proto:110:1
+desc_test_comments.proto:110:8
+
+
  > extension[1] > label:
-desc_test_comments.proto:98:2
-desc_test_comments.proto:98:10
+desc_test_comments.proto:116:9
+desc_test_comments.proto:116:17
 
 
  > extension[1] > type:
-desc_test_comments.proto:98:11
-desc_test_comments.proto:98:17
+desc_test_comments.proto:116:18
+desc_test_comments.proto:116:24
 
 
  > extension[1] > name:
-desc_test_comments.proto:98:18
-desc_test_comments.proto:98:23
+desc_test_comments.proto:116:25
+desc_test_comments.proto:116:30
 
 
  > extension[1] > number:
-desc_test_comments.proto:98:26
-desc_test_comments.proto:98:29
+desc_test_comments.proto:116:33
+desc_test_comments.proto:116:36
 
 
- > service:
-desc_test_comments.proto:103:1
-desc_test_comments.proto:119:2
+ > message_type[1]:
+desc_test_comments.proto:120:1
+desc_test_comments.proto:120:81
+
+
+ > message_type[1] > name:
+desc_test_comments.proto:120:36
+desc_test_comments.proto:120:50
+    Leading comments:
+ name leading comment 
+    Trailing comments:
+ name trailing comment 
 
 
  > service[0]:
-desc_test_comments.proto:103:1
-desc_test_comments.proto:119:2
+desc_test_comments.proto:123:1
+desc_test_comments.proto:141:2
     Leading comments:
  Service comment
+
     Trailing comments:
  service trailer
 
 
+
  > service[0] > name:
-desc_test_comments.proto:103:28
-desc_test_comments.proto:103:38
+desc_test_comments.proto:123:28
+desc_test_comments.proto:123:38
     Leading comments:
  service name 
 
 
  > service[0] > options:
-desc_test_comments.proto:104:2
-desc_test_comments.proto:108:38
-
-
- > service[0] > options > sfubar:
-desc_test_comments.proto:104:2
-desc_test_comments.proto:105:40
+desc_test_comments.proto:125:9
+desc_test_comments.proto:125:43
 
 
  > service[0] > options > sfubar > id:
-desc_test_comments.proto:104:2
-desc_test_comments.proto:104:36
+desc_test_comments.proto:125:9
+desc_test_comments.proto:125:43
+    Leading comments:
+ option that sets field
+
+
+
+ > service[0] > options:
+desc_test_comments.proto:127:9
+desc_test_comments.proto:127:47
 
 
  > service[0] > options > sfubar > name:
-desc_test_comments.proto:105:2
-desc_test_comments.proto:105:40
+desc_test_comments.proto:127:9
+desc_test_comments.proto:127:47
+    Leading comments:
+ another option that sets field
+
+
+
+ > service[0] > options:
+desc_test_comments.proto:128:9
+desc_test_comments.proto:128:35
 
 
  > service[0] > options > deprecated:
-desc_test_comments.proto:106:2
-desc_test_comments.proto:106:28
+desc_test_comments.proto:128:9
+desc_test_comments.proto:128:35
+    Trailing comments:
+ DEPRECATED!
+
+
+
+ > service[0] > options:
+desc_test_comments.proto:130:9
+desc_test_comments.proto:130:45
 
 
  > service[0] > options > sfubare:
-desc_test_comments.proto:108:2
-desc_test_comments.proto:108:38
-
-
- > service[0] > method:
-desc_test_comments.proto:111:2
-desc_test_comments.proto:118:3
+desc_test_comments.proto:130:9
+desc_test_comments.proto:130:45
 
 
  > service[0] > method[0]:
-desc_test_comments.proto:111:2
-desc_test_comments.proto:112:70
+desc_test_comments.proto:133:9
+desc_test_comments.proto:134:84
     Leading comments:
  Method comment
 
 
+
  > service[0] > method[0] > name:
-desc_test_comments.proto:111:21
-desc_test_comments.proto:111:33
+desc_test_comments.proto:133:28
+desc_test_comments.proto:133:40
     Leading comments:
  rpc name 
     Trailing comments:
@@ -851,75 +1063,4304 @@
 
 
  > service[0] > method[0] > client_streaming:
-desc_test_comments.proto:111:66
-desc_test_comments.proto:111:72
+desc_test_comments.proto:133:73
+desc_test_comments.proto:133:79
     Leading comments:
  comment B 
 
 
  > service[0] > method[0] > input_type:
-desc_test_comments.proto:111:89
-desc_test_comments.proto:111:96
+desc_test_comments.proto:133:96
+desc_test_comments.proto:133:103
     Leading comments:
  comment C 
 
 
  > service[0] > method[0] > output_type:
-desc_test_comments.proto:112:43
-desc_test_comments.proto:112:50
+desc_test_comments.proto:134:57
+desc_test_comments.proto:134:64
     Leading comments:
 comment E 
 
 
  > service[0] > method[1]:
-desc_test_comments.proto:114:2
-desc_test_comments.proto:118:3
+desc_test_comments.proto:136:9
+desc_test_comments.proto:140:10
 
 
  > service[0] > method[1] > name:
-desc_test_comments.proto:114:6
-desc_test_comments.proto:114:14
+desc_test_comments.proto:136:13
+desc_test_comments.proto:136:21
 
 
  > service[0] > method[1] > input_type:
-desc_test_comments.proto:114:16
-desc_test_comments.proto:114:23
+desc_test_comments.proto:136:23
+desc_test_comments.proto:136:30
 
 
  > service[0] > method[1] > output_type:
-desc_test_comments.proto:114:34
-desc_test_comments.proto:114:55
+desc_test_comments.proto:136:41
+desc_test_comments.proto:136:62
 
 
  > service[0] > method[1] > options:
-desc_test_comments.proto:115:3
-desc_test_comments.proto:117:42
+desc_test_comments.proto:137:17
+desc_test_comments.proto:137:42
 
 
  > service[0] > method[1] > options > deprecated:
-desc_test_comments.proto:115:3
-desc_test_comments.proto:115:28
+desc_test_comments.proto:137:17
+desc_test_comments.proto:137:42
 
 
- > service[0] > method[1] > options > mtfubar:
-desc_test_comments.proto:116:3
-desc_test_comments.proto:116:39
+ > service[0] > method[1] > options:
+desc_test_comments.proto:138:17
+desc_test_comments.proto:138:53
 
 
  > service[0] > method[1] > options > mtfubar[0]:
-desc_test_comments.proto:116:3
-desc_test_comments.proto:116:39
+desc_test_comments.proto:138:17
+desc_test_comments.proto:138:53
+
+
+ > service[0] > method[1] > options:
+desc_test_comments.proto:139:17
+desc_test_comments.proto:139:56
 
 
  > service[0] > method[1] > options > mtfubard:
-desc_test_comments.proto:117:3
-desc_test_comments.proto:117:42
+desc_test_comments.proto:139:17
+desc_test_comments.proto:139:56
+---- desc_test_complex.proto ----
+
+
+:
+desc_test_complex.proto:1:1
+desc_test_complex.proto:286:2
+
+
+ > syntax:
+desc_test_complex.proto:1:1
+desc_test_complex.proto:1:19
+
+
+ > package:
+desc_test_complex.proto:3:1
+desc_test_complex.proto:3:17
+
+
+ > options:
+desc_test_complex.proto:5:1
+desc_test_complex.proto:5:73
+
+
+ > options > go_package:
+desc_test_complex.proto:5:1
+desc_test_complex.proto:5:73
+
+
+ > dependency[0]:
+desc_test_complex.proto:7:1
+desc_test_complex.proto:7:43
+
+
+ > message_type[0]:
+desc_test_complex.proto:9:1
+desc_test_complex.proto:12:2
+
+
+ > message_type[0] > name:
+desc_test_complex.proto:9:9
+desc_test_complex.proto:9:15
+
+
+ > message_type[0] > field[0]:
+desc_test_complex.proto:10:9
+desc_test_complex.proto:10:34
+
+
+ > message_type[0] > field[0] > label:
+desc_test_complex.proto:10:9
+desc_test_complex.proto:10:17
+
+
+ > message_type[0] > field[0] > type:
+desc_test_complex.proto:10:18
+desc_test_complex.proto:10:24
+
+
+ > message_type[0] > field[0] > name:
+desc_test_complex.proto:10:25
+desc_test_complex.proto:10:29
+
+
+ > message_type[0] > field[0] > number:
+desc_test_complex.proto:10:32
+desc_test_complex.proto:10:33
+
+
+ > message_type[0] > field[1]:
+desc_test_complex.proto:11:9
+desc_test_complex.proto:11:32
+
+
+ > message_type[0] > field[1] > label:
+desc_test_complex.proto:11:9
+desc_test_complex.proto:11:17
+
+
+ > message_type[0] > field[1] > type:
+desc_test_complex.proto:11:18
+desc_test_complex.proto:11:24
+
+
+ > message_type[0] > field[1] > name:
+desc_test_complex.proto:11:25
+desc_test_complex.proto:11:27
+
+
+ > message_type[0] > field[1] > number:
+desc_test_complex.proto:11:30
+desc_test_complex.proto:11:31
+
+
+ > extension:
+desc_test_complex.proto:14:1
+desc_test_complex.proto:18:2
+
+
+ > extension[0]:
+desc_test_complex.proto:17:9
+desc_test_complex.proto:17:39
+
+
+ > extension[0] > extendee:
+desc_test_complex.proto:14:8
+desc_test_complex.proto:16:25
+
+
+ > extension[0] > label:
+desc_test_complex.proto:17:9
+desc_test_complex.proto:17:17
+
+
+ > extension[0] > type:
+desc_test_complex.proto:17:18
+desc_test_complex.proto:17:24
+
+
+ > extension[0] > name:
+desc_test_complex.proto:17:25
+desc_test_complex.proto:17:30
+
+
+ > extension[0] > number:
+desc_test_complex.proto:17:33
+desc_test_complex.proto:17:38
+
+
+ > message_type[1]:
+desc_test_complex.proto:20:1
+desc_test_complex.proto:59:2
+
+
+ > message_type[1] > name:
+desc_test_complex.proto:20:9
+desc_test_complex.proto:20:13
+
+
+ > message_type[1] > field[0]:
+desc_test_complex.proto:21:9
+desc_test_complex.proto:21:55
+
+
+ > message_type[1] > field[0] > label:
+desc_test_complex.proto:21:9
+desc_test_complex.proto:21:17
+
+
+ > message_type[1] > field[0] > type:
+desc_test_complex.proto:21:18
+desc_test_complex.proto:21:24
+
+
+ > message_type[1] > field[0] > name:
+desc_test_complex.proto:21:25
+desc_test_complex.proto:21:28
+
+
+ > message_type[1] > field[0] > number:
+desc_test_complex.proto:21:31
+desc_test_complex.proto:21:32
+
+
+ > message_type[1] > field[0] > options:
+desc_test_complex.proto:21:33
+desc_test_complex.proto:21:54
+
+
+ > message_type[1] > field[0] > json_name:
+desc_test_complex.proto:21:34
+desc_test_complex.proto:21:53
+
+
+ > message_type[1] > field[1]:
+desc_test_complex.proto:22:9
+desc_test_complex.proto:22:34
+
+
+ > message_type[1] > field[1] > label:
+desc_test_complex.proto:22:9
+desc_test_complex.proto:22:17
+
+
+ > message_type[1] > field[1] > type:
+desc_test_complex.proto:22:18
+desc_test_complex.proto:22:23
+
+
+ > message_type[1] > field[1] > name:
+desc_test_complex.proto:22:24
+desc_test_complex.proto:22:29
+
+
+ > message_type[1] > field[1] > number:
+desc_test_complex.proto:22:32
+desc_test_complex.proto:22:33
+
+
+ > message_type[1] > field[2]:
+desc_test_complex.proto:23:9
+desc_test_complex.proto:23:31
+
+
+ > message_type[1] > field[2] > label:
+desc_test_complex.proto:23:9
+desc_test_complex.proto:23:17
+
+
+ > message_type[1] > field[2] > type_name:
+desc_test_complex.proto:23:18
+desc_test_complex.proto:23:24
+
+
+ > message_type[1] > field[2] > name:
+desc_test_complex.proto:23:25
+desc_test_complex.proto:23:26
+
+
+ > message_type[1] > field[2] > number:
+desc_test_complex.proto:23:29
+desc_test_complex.proto:23:30
+
+
+ > message_type[1] > field[3]:
+desc_test_complex.proto:24:9
+desc_test_complex.proto:24:31
+
+
+ > message_type[1] > field[3] > label:
+desc_test_complex.proto:24:9
+desc_test_complex.proto:24:17
+
+
+ > message_type[1] > field[3] > type_name:
+desc_test_complex.proto:24:18
+desc_test_complex.proto:24:24
+
+
+ > message_type[1] > field[3] > name:
+desc_test_complex.proto:24:25
+desc_test_complex.proto:24:26
+
+
+ > message_type[1] > field[3] > number:
+desc_test_complex.proto:24:29
+desc_test_complex.proto:24:30
+
+
+ > message_type[1] > field[4]:
+desc_test_complex.proto:25:9
+desc_test_complex.proto:25:34
+
+
+ > message_type[1] > field[4] > type_name:
+desc_test_complex.proto:25:9
+desc_test_complex.proto:25:27
+
+
+ > message_type[1] > field[4] > name:
+desc_test_complex.proto:25:28
+desc_test_complex.proto:25:29
+
+
+ > message_type[1] > field[4] > number:
+desc_test_complex.proto:25:32
+desc_test_complex.proto:25:33
+
+
+ > message_type[1] > field[5]:
+desc_test_complex.proto:27:9
+desc_test_complex.proto:27:67
+
+
+ > message_type[1] > field[5] > label:
+desc_test_complex.proto:27:9
+desc_test_complex.proto:27:17
+
+
+ > message_type[1] > field[5] > type:
+desc_test_complex.proto:27:18
+desc_test_complex.proto:27:23
+
+
+ > message_type[1] > field[5] > name:
+desc_test_complex.proto:27:24
+desc_test_complex.proto:27:25
+
+
+ > message_type[1] > field[5] > number:
+desc_test_complex.proto:27:28
+desc_test_complex.proto:27:29
+
+
+ > message_type[1] > field[5] > options:
+desc_test_complex.proto:27:30
+desc_test_complex.proto:27:66
+
+
+ > message_type[1] > field[5] > default_value:
+desc_test_complex.proto:27:31
+desc_test_complex.proto:27:65
+
+
+ > message_type[1] > extension_range:
+desc_test_complex.proto:29:9
+desc_test_complex.proto:29:31
+
+
+ > message_type[1] > extension_range[0]:
+desc_test_complex.proto:29:20
+desc_test_complex.proto:29:30
+
+
+ > message_type[1] > extension_range[0] > start:
+desc_test_complex.proto:29:20
+desc_test_complex.proto:29:23
+
+
+ > message_type[1] > extension_range[0] > end:
+desc_test_complex.proto:29:27
+desc_test_complex.proto:29:30
+
+
+ > message_type[1] > extension_range:
+desc_test_complex.proto:31:9
+desc_test_complex.proto:31:62
+
+
+ > message_type[1] > extension_range[1]:
+desc_test_complex.proto:31:20
+desc_test_complex.proto:31:30
+
+
+ > message_type[1] > extension_range[1] > start:
+desc_test_complex.proto:31:20
+desc_test_complex.proto:31:23
+
+
+ > message_type[1] > extension_range[1] > end:
+desc_test_complex.proto:31:27
+desc_test_complex.proto:31:30
+
+
+ > message_type[1] > extension_range[1] > options:
+desc_test_complex.proto:31:43
+desc_test_complex.proto:31:61
+
+
+ > message_type[1] > extension_range[1] > options > label:
+desc_test_complex.proto:31:44
+desc_test_complex.proto:31:60
+
+
+ > message_type[1] > extension_range[2]:
+desc_test_complex.proto:31:32
+desc_test_complex.proto:31:42
+
+
+ > message_type[1] > extension_range[2] > start:
+desc_test_complex.proto:31:32
+desc_test_complex.proto:31:35
+
+
+ > message_type[1] > extension_range[2] > end:
+desc_test_complex.proto:31:39
+desc_test_complex.proto:31:42
+
+
+ > message_type[1] > extension_range[2] > options:
+desc_test_complex.proto:31:43
+desc_test_complex.proto:31:61
+
+
+ > message_type[1] > extension_range[2] > options > label:
+desc_test_complex.proto:31:44
+desc_test_complex.proto:31:60
+
+
+ > message_type[1] > nested_type[0]:
+desc_test_complex.proto:33:9
+desc_test_complex.proto:58:10
+
+
+ > message_type[1] > nested_type[0] > name:
+desc_test_complex.proto:33:17
+desc_test_complex.proto:33:23
+
+
+ > message_type[1] > nested_type[0] > extension:
+desc_test_complex.proto:34:17
+desc_test_complex.proto:36:18
+
+
+ > message_type[1] > nested_type[0] > extension[0]:
+desc_test_complex.proto:35:25
+desc_test_complex.proto:35:56
+
+
+ > message_type[1] > nested_type[0] > extension[0] !!!  > extendee:
+desc_test_complex.proto:34:24
+desc_test_complex.proto:34:54
+
+
+ > message_type[1] > nested_type[0] > extension[0] !!!  > label:
+desc_test_complex.proto:35:25
+desc_test_complex.proto:35:33
+
+
+ > message_type[1] > nested_type[0] > extension[0] !!!  > type:
+desc_test_complex.proto:35:34
+desc_test_complex.proto:35:39
+
+
+ > message_type[1] > nested_type[0] > extension[0] !!!  > name:
+desc_test_complex.proto:35:40
+desc_test_complex.proto:35:47
+
+
+ > message_type[1] > nested_type[0] > extension[0] !!!  > number:
+desc_test_complex.proto:35:50
+desc_test_complex.proto:35:55
+
+
+ > message_type[1] > nested_type[0] > nested_type[0]:
+desc_test_complex.proto:37:17
+desc_test_complex.proto:57:18
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > name:
+desc_test_complex.proto:37:25
+desc_test_complex.proto:37:38
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0]:
+desc_test_complex.proto:38:25
+desc_test_complex.proto:46:26
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > name:
+desc_test_complex.proto:38:30
+desc_test_complex.proto:38:33
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[0]:
+desc_test_complex.proto:39:33
+desc_test_complex.proto:39:40
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[0] > name:
+desc_test_complex.proto:39:33
+desc_test_complex.proto:39:35
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[0] > number:
+desc_test_complex.proto:39:38
+desc_test_complex.proto:39:39
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[1]:
+desc_test_complex.proto:40:33
+desc_test_complex.proto:40:40
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[1] > name:
+desc_test_complex.proto:40:33
+desc_test_complex.proto:40:35
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[1] > number:
+desc_test_complex.proto:40:38
+desc_test_complex.proto:40:39
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[2]:
+desc_test_complex.proto:41:33
+desc_test_complex.proto:41:40
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[2] > name:
+desc_test_complex.proto:41:33
+desc_test_complex.proto:41:35
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[2] > number:
+desc_test_complex.proto:41:38
+desc_test_complex.proto:41:39
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[3]:
+desc_test_complex.proto:42:33
+desc_test_complex.proto:42:40
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[3] > name:
+desc_test_complex.proto:42:33
+desc_test_complex.proto:42:35
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[3] > number:
+desc_test_complex.proto:42:38
+desc_test_complex.proto:42:39
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[4]:
+desc_test_complex.proto:43:33
+desc_test_complex.proto:43:40
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[4] > name:
+desc_test_complex.proto:43:33
+desc_test_complex.proto:43:35
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[4] > number:
+desc_test_complex.proto:43:38
+desc_test_complex.proto:43:39
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[5]:
+desc_test_complex.proto:44:33
+desc_test_complex.proto:44:40
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[5] > name:
+desc_test_complex.proto:44:33
+desc_test_complex.proto:44:35
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[5] > number:
+desc_test_complex.proto:44:38
+desc_test_complex.proto:44:39
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[6]:
+desc_test_complex.proto:45:33
+desc_test_complex.proto:45:40
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[6] > name:
+desc_test_complex.proto:45:33
+desc_test_complex.proto:45:35
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > enum_type[0] > value[6] > number:
+desc_test_complex.proto:45:38
+desc_test_complex.proto:45:39
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > options:
+desc_test_complex.proto:47:25
+desc_test_complex.proto:47:50
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > options > fooblez:
+desc_test_complex.proto:47:25
+desc_test_complex.proto:47:50
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > extension:
+desc_test_complex.proto:48:25
+desc_test_complex.proto:50:26
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > extension[0]:
+desc_test_complex.proto:49:33
+desc_test_complex.proto:49:64
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > extension[0] > extendee:
+desc_test_complex.proto:48:32
+desc_test_complex.proto:48:36
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > extension[0] > label:
+desc_test_complex.proto:49:33
+desc_test_complex.proto:49:41
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > extension[0] > type:
+desc_test_complex.proto:49:42
+desc_test_complex.proto:49:48
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > extension[0] > name:
+desc_test_complex.proto:49:49
+desc_test_complex.proto:49:57
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > extension[0] > number:
+desc_test_complex.proto:49:60
+desc_test_complex.proto:49:63
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > options:
+desc_test_complex.proto:51:25
+desc_test_complex.proto:51:108
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > options > rept[0]:
+desc_test_complex.proto:51:25
+desc_test_complex.proto:51:108
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0]:
+desc_test_complex.proto:52:25
+desc_test_complex.proto:56:26
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > name:
+desc_test_complex.proto:52:33
+desc_test_complex.proto:52:51
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > options:
+desc_test_complex.proto:53:33
+desc_test_complex.proto:53:109
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > options > rept[0]:
+desc_test_complex.proto:53:33
+desc_test_complex.proto:53:109
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > field[0]:
+desc_test_complex.proto:55:33
+desc_test_complex.proto:55:56
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > field[0] > label:
+desc_test_complex.proto:55:33
+desc_test_complex.proto:55:41
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > field[0] > type_name:
+desc_test_complex.proto:55:42
+desc_test_complex.proto:55:46
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > field[0] > name:
+desc_test_complex.proto:55:47
+desc_test_complex.proto:55:51
+
+
+ > message_type[1] > nested_type[0] > nested_type[0] !!!  > nested_type[0] > field[0] > number:
+desc_test_complex.proto:55:54
+desc_test_complex.proto:55:55
+
+
+ > enum_type[0]:
+desc_test_complex.proto:61:1
+desc_test_complex.proto:70:2
+
+
+ > enum_type[0] > name:
+desc_test_complex.proto:61:6
+desc_test_complex.proto:61:26
+
+
+ > enum_type[0] > value[0]:
+desc_test_complex.proto:62:9
+desc_test_complex.proto:62:15
+
+
+ > enum_type[0] > value[0] > name:
+desc_test_complex.proto:62:9
+desc_test_complex.proto:62:10
+
+
+ > enum_type[0] > value[0] > number:
+desc_test_complex.proto:62:13
+desc_test_complex.proto:62:14
+
+
+ > enum_type[0] > value[1]:
+desc_test_complex.proto:63:9
+desc_test_complex.proto:63:15
+
+
+ > enum_type[0] > value[1] > name:
+desc_test_complex.proto:63:9
+desc_test_complex.proto:63:10
+
+
+ > enum_type[0] > value[1] > number:
+desc_test_complex.proto:63:13
+desc_test_complex.proto:63:14
+
+
+ > enum_type[0] > value[2]:
+desc_test_complex.proto:64:9
+desc_test_complex.proto:64:15
+
+
+ > enum_type[0] > value[2] > name:
+desc_test_complex.proto:64:9
+desc_test_complex.proto:64:10
+
+
+ > enum_type[0] > value[2] > number:
+desc_test_complex.proto:64:13
+desc_test_complex.proto:64:14
+
+
+ > enum_type[0] > reserved_range:
+desc_test_complex.proto:65:9
+desc_test_complex.proto:65:30
+
+
+ > enum_type[0] > reserved_range[0]:
+desc_test_complex.proto:65:18
+desc_test_complex.proto:65:29
+
+
+ > enum_type[0] > reserved_range[0] > start:
+desc_test_complex.proto:65:18
+desc_test_complex.proto:65:22
+
+
+ > enum_type[0] > reserved_range[0] > end:
+desc_test_complex.proto:65:26
+desc_test_complex.proto:65:29
+
+
+ > enum_type[0] > reserved_range:
+desc_test_complex.proto:66:9
+desc_test_complex.proto:66:26
+
+
+ > enum_type[0] > reserved_range[1]:
+desc_test_complex.proto:66:18
+desc_test_complex.proto:66:25
+
+
+ > enum_type[0] > reserved_range[1] > start:
+desc_test_complex.proto:66:18
+desc_test_complex.proto:66:20
+
+
+ > enum_type[0] > reserved_range[1] > end:
+desc_test_complex.proto:66:24
+desc_test_complex.proto:66:25
+
+
+ > enum_type[0] > reserved_range:
+desc_test_complex.proto:67:9
+desc_test_complex.proto:67:40
+
+
+ > enum_type[0] > reserved_range[2]:
+desc_test_complex.proto:67:18
+desc_test_complex.proto:67:25
+
+
+ > enum_type[0] > reserved_range[2] > start:
+desc_test_complex.proto:67:18
+desc_test_complex.proto:67:19
+
+
+ > enum_type[0] > reserved_range[2] > end:
+desc_test_complex.proto:67:23
+desc_test_complex.proto:67:25
+
+
+ > enum_type[0] > reserved_range[3]:
+desc_test_complex.proto:67:27
+desc_test_complex.proto:67:35
+
+
+ > enum_type[0] > reserved_range[3] > start:
+desc_test_complex.proto:67:27
+desc_test_complex.proto:67:29
+
+
+ > enum_type[0] > reserved_range[3] > end:
+desc_test_complex.proto:67:33
+desc_test_complex.proto:67:35
+
+
+ > enum_type[0] > reserved_range[4]:
+desc_test_complex.proto:67:37
+desc_test_complex.proto:67:39
+
+
+ > enum_type[0] > reserved_range[4] > start:
+desc_test_complex.proto:67:37
+desc_test_complex.proto:67:39
+
+
+ > enum_type[0] > reserved_range:
+desc_test_complex.proto:68:9
+desc_test_complex.proto:68:27
+
+
+ > enum_type[0] > reserved_range[5]:
+desc_test_complex.proto:68:18
+desc_test_complex.proto:68:26
+
+
+ > enum_type[0] > reserved_range[5] > start:
+desc_test_complex.proto:68:18
+desc_test_complex.proto:68:20
+
+
+ > enum_type[0] > reserved_range[5] > end:
+desc_test_complex.proto:68:24
+desc_test_complex.proto:68:26
+
+
+ > enum_type[0] > reserved_name:
+desc_test_complex.proto:69:9
+desc_test_complex.proto:69:32
+
+
+ > enum_type[0] > reserved_name[0]:
+desc_test_complex.proto:69:18
+desc_test_complex.proto:69:21
+
+
+ > enum_type[0] > reserved_name[1]:
+desc_test_complex.proto:69:23
+desc_test_complex.proto:69:26
+
+
+ > enum_type[0] > reserved_name[2]:
+desc_test_complex.proto:69:28
+desc_test_complex.proto:69:31
+
+
+ > message_type[2]:
+desc_test_complex.proto:72:1
+desc_test_complex.proto:76:2
+
+
+ > message_type[2] > name:
+desc_test_complex.proto:72:9
+desc_test_complex.proto:72:32
+
+
+ > message_type[2] > reserved_range:
+desc_test_complex.proto:73:9
+desc_test_complex.proto:73:40
+
+
+ > message_type[2] > reserved_range[0]:
+desc_test_complex.proto:73:18
+desc_test_complex.proto:73:25
+
+
+ > message_type[2] > reserved_range[0] > start:
+desc_test_complex.proto:73:18
+desc_test_complex.proto:73:19
+
+
+ > message_type[2] > reserved_range[0] > end:
+desc_test_complex.proto:73:23
+desc_test_complex.proto:73:25
+
+
+ > message_type[2] > reserved_range[1]:
+desc_test_complex.proto:73:27
+desc_test_complex.proto:73:35
+
+
+ > message_type[2] > reserved_range[1] > start:
+desc_test_complex.proto:73:27
+desc_test_complex.proto:73:29
+
+
+ > message_type[2] > reserved_range[1] > end:
+desc_test_complex.proto:73:33
+desc_test_complex.proto:73:35
+
+
+ > message_type[2] > reserved_range[2]:
+desc_test_complex.proto:73:37
+desc_test_complex.proto:73:39
+
+
+ > message_type[2] > reserved_range[2] > start:
+desc_test_complex.proto:73:37
+desc_test_complex.proto:73:39
+
+
+ > message_type[2] > reserved_range:
+desc_test_complex.proto:74:9
+desc_test_complex.proto:74:30
+
+
+ > message_type[2] > reserved_range[3]:
+desc_test_complex.proto:74:18
+desc_test_complex.proto:74:29
+
+
+ > message_type[2] > reserved_range[3] > start:
+desc_test_complex.proto:74:18
+desc_test_complex.proto:74:22
+
+
+ > message_type[2] > reserved_range[3] > end:
+desc_test_complex.proto:74:26
+desc_test_complex.proto:74:29
+
+
+ > message_type[2] > reserved_name:
+desc_test_complex.proto:75:9
+desc_test_complex.proto:75:32
+
+
+ > message_type[2] > reserved_name[0]:
+desc_test_complex.proto:75:18
+desc_test_complex.proto:75:21
+
+
+ > message_type[2] > reserved_name[1]:
+desc_test_complex.proto:75:23
+desc_test_complex.proto:75:26
+
+
+ > message_type[2] > reserved_name[2]:
+desc_test_complex.proto:75:28
+desc_test_complex.proto:75:31
+
+
+ > extension:
+desc_test_complex.proto:78:1
+desc_test_complex.proto:82:2
+
+
+ > extension[1]:
+desc_test_complex.proto:79:9
+desc_test_complex.proto:79:36
+
+
+ > extension[1] > extendee:
+desc_test_complex.proto:78:8
+desc_test_complex.proto:78:38
+
+
+ > extension[1] > label:
+desc_test_complex.proto:79:9
+desc_test_complex.proto:79:17
+
+
+ > extension[1] > type_name:
+desc_test_complex.proto:79:18
+desc_test_complex.proto:79:22
+
+
+ > extension[1] > name:
+desc_test_complex.proto:79:23
+desc_test_complex.proto:79:27
+
+
+ > extension[1] > number:
+desc_test_complex.proto:79:30
+desc_test_complex.proto:79:35
+
+
+ > extension[2]:
+desc_test_complex.proto:80:9
+desc_test_complex.proto:80:60
+
+
+ > extension[2] > extendee:
+desc_test_complex.proto:78:8
+desc_test_complex.proto:78:38
+
+
+ > extension[2] > label:
+desc_test_complex.proto:80:9
+desc_test_complex.proto:80:17
+
+
+ > extension[2] > type_name:
+desc_test_complex.proto:80:18
+desc_test_complex.proto:80:47
+
+
+ > extension[2] > name:
+desc_test_complex.proto:80:48
+desc_test_complex.proto:80:51
+
+
+ > extension[2] > number:
+desc_test_complex.proto:80:54
+desc_test_complex.proto:80:59
+
+
+ > extension[3]:
+desc_test_complex.proto:81:9
+desc_test_complex.proto:81:36
+
+
+ > extension[3] > extendee:
+desc_test_complex.proto:78:8
+desc_test_complex.proto:78:38
+
+
+ > extension[3] > label:
+desc_test_complex.proto:81:9
+desc_test_complex.proto:81:17
+
+
+ > extension[3] > type_name:
+desc_test_complex.proto:81:18
+desc_test_complex.proto:81:25
+
+
+ > extension[3] > name:
+desc_test_complex.proto:81:26
+desc_test_complex.proto:81:27
+
+
+ > extension[3] > number:
+desc_test_complex.proto:81:30
+desc_test_complex.proto:81:35
+
+
+ > message_type[3]:
+desc_test_complex.proto:84:1
+desc_test_complex.proto:99:2
+
+
+ > message_type[3] > name:
+desc_test_complex.proto:84:9
+desc_test_complex.proto:84:16
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:85:5
+desc_test_complex.proto:85:130
+
+
+ > message_type[3] > options > rept[0]:
+desc_test_complex.proto:85:5
+desc_test_complex.proto:85:130
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:86:5
+desc_test_complex.proto:86:115
+
+
+ > message_type[3] > options > rept[1]:
+desc_test_complex.proto:86:5
+desc_test_complex.proto:86:115
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:87:5
+desc_test_complex.proto:87:36
+
+
+ > message_type[3] > options > rept[2]:
+desc_test_complex.proto:87:5
+desc_test_complex.proto:87:36
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:88:5
+desc_test_complex.proto:88:23
+
+
+ > message_type[3] > options > eee:
+desc_test_complex.proto:88:5
+desc_test_complex.proto:88:23
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:89:9
+desc_test_complex.proto:89:34
+
+
+ > message_type[3] > options > a:
+desc_test_complex.proto:89:9
+desc_test_complex.proto:89:34
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:90:9
+desc_test_complex.proto:90:86
+
+
+ > message_type[3] > options > a > test:
+desc_test_complex.proto:90:9
+desc_test_complex.proto:90:86
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:91:9
+desc_test_complex.proto:91:37
+
+
+ > message_type[3] > options > a > test > foo:
+desc_test_complex.proto:91:9
+desc_test_complex.proto:91:37
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:92:9
+desc_test_complex.proto:92:41
+
+
+ > message_type[3] > options > a > test > s > name:
+desc_test_complex.proto:92:9
+desc_test_complex.proto:92:41
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:93:5
+desc_test_complex.proto:93:34
+
+
+ > message_type[3] > options > a > test > s > id:
+desc_test_complex.proto:93:5
+desc_test_complex.proto:93:34
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:94:5
+desc_test_complex.proto:94:31
+
+
+ > message_type[3] > options > a > test > array[0]:
+desc_test_complex.proto:94:5
+desc_test_complex.proto:94:31
+
+
+ > message_type[3] > options:
+desc_test_complex.proto:95:5
+desc_test_complex.proto:95:31
+
+
+ > message_type[3] > options > a > test > array[1]:
+desc_test_complex.proto:95:5
+desc_test_complex.proto:95:31
+
+
+ > message_type[3] > field[0]:
+desc_test_complex.proto:97:5
+desc_test_complex.proto:97:28
+
+
+ > message_type[3] > field[0] > label:
+desc_test_complex.proto:97:5
+desc_test_complex.proto:97:13
+
+
+ > message_type[3] > field[0] > type_name:
+desc_test_complex.proto:97:14
+desc_test_complex.proto:97:18
+
+
+ > message_type[3] > field[0] > name:
+desc_test_complex.proto:97:19
+desc_test_complex.proto:97:23
+
+
+ > message_type[3] > field[0] > number:
+desc_test_complex.proto:97:26
+desc_test_complex.proto:97:27
+
+
+ > message_type[3] > field[1]:
+desc_test_complex.proto:98:5
+desc_test_complex.proto:98:67
+
+
+ > message_type[3] > field[1] > label:
+desc_test_complex.proto:98:5
+desc_test_complex.proto:98:13
+
+
+ > message_type[3] > field[1] > type_name:
+desc_test_complex.proto:98:14
+desc_test_complex.proto:98:43
+
+
+ > message_type[3] > field[1] > name:
+desc_test_complex.proto:98:44
+desc_test_complex.proto:98:47
+
+
+ > message_type[3] > field[1] > number:
+desc_test_complex.proto:98:50
+desc_test_complex.proto:98:51
+
+
+ > message_type[3] > field[1] > options:
+desc_test_complex.proto:98:52
+desc_test_complex.proto:98:66
+
+
+ > message_type[3] > field[1] > default_value:
+desc_test_complex.proto:98:53
+desc_test_complex.proto:98:65
+
+
+ > message_type[4]:
+desc_test_complex.proto:101:1
+desc_test_complex.proto:115:2
+
+
+ > message_type[4] > name:
+desc_test_complex.proto:101:9
+desc_test_complex.proto:101:18
+
+
+ > message_type[4] > field[0]:
+desc_test_complex.proto:102:9
+desc_test_complex.proto:102:41
+
+
+ > message_type[4] > field[0] > label:
+desc_test_complex.proto:102:9
+desc_test_complex.proto:102:17
+
+
+ > message_type[4] > field[0] > type:
+desc_test_complex.proto:102:18
+desc_test_complex.proto:102:22
+
+
+ > message_type[4] > field[0] > name:
+desc_test_complex.proto:102:23
+desc_test_complex.proto:102:36
+
+
+ > message_type[4] > field[0] > number:
+desc_test_complex.proto:102:39
+desc_test_complex.proto:102:40
+
+
+ > message_type[4] > enum_type[0]:
+desc_test_complex.proto:104:9
+desc_test_complex.proto:108:10
+
+
+ > message_type[4] > enum_type[0] > name:
+desc_test_complex.proto:104:14
+desc_test_complex.proto:104:20
+
+
+ > message_type[4] > enum_type[0] > value[0]:
+desc_test_complex.proto:105:17
+desc_test_complex.proto:105:27
+
+
+ > message_type[4] > enum_type[0] > value[0] > name:
+desc_test_complex.proto:105:17
+desc_test_complex.proto:105:22
+
+
+ > message_type[4] > enum_type[0] > value[0] > number:
+desc_test_complex.proto:105:25
+desc_test_complex.proto:105:26
+
+
+ > message_type[4] > enum_type[0] > value[1]:
+desc_test_complex.proto:106:17
+desc_test_complex.proto:106:26
+
+
+ > message_type[4] > enum_type[0] > value[1] > name:
+desc_test_complex.proto:106:17
+desc_test_complex.proto:106:21
+
+
+ > message_type[4] > enum_type[0] > value[1] > number:
+desc_test_complex.proto:106:24
+desc_test_complex.proto:106:25
+
+
+ > message_type[4] > enum_type[0] > value[2]:
+desc_test_complex.proto:107:17
+desc_test_complex.proto:107:27
+
+
+ > message_type[4] > enum_type[0] > value[2] > name:
+desc_test_complex.proto:107:17
+desc_test_complex.proto:107:22
+
+
+ > message_type[4] > enum_type[0] > value[2] > number:
+desc_test_complex.proto:107:25
+desc_test_complex.proto:107:26
+
+
+ > message_type[4] > nested_type[0]:
+desc_test_complex.proto:109:9
+desc_test_complex.proto:112:10
+
+
+ > message_type[4] > nested_type[0] > name:
+desc_test_complex.proto:109:17
+desc_test_complex.proto:109:27
+
+
+ > message_type[4] > nested_type[0] > field[0]:
+desc_test_complex.proto:110:17
+desc_test_complex.proto:110:44
+
+
+ > message_type[4] > nested_type[0] > field[0] > label:
+desc_test_complex.proto:110:17
+desc_test_complex.proto:110:25
+
+
+ > message_type[4] > nested_type[0] > field[0] > type_name:
+desc_test_complex.proto:110:26
+desc_test_complex.proto:110:32
+
+
+ > message_type[4] > nested_type[0] > field[0] > name:
+desc_test_complex.proto:110:33
+desc_test_complex.proto:110:39
+
+
+ > message_type[4] > nested_type[0] > field[0] > number:
+desc_test_complex.proto:110:42
+desc_test_complex.proto:110:43
+
+
+ > message_type[4] > nested_type[0] > field[1]:
+desc_test_complex.proto:111:17
+desc_test_complex.proto:111:44
+
+
+ > message_type[4] > nested_type[0] > field[1] > label:
+desc_test_complex.proto:111:17
+desc_test_complex.proto:111:25
+
+
+ > message_type[4] > nested_type[0] > field[1] > type:
+desc_test_complex.proto:111:26
+desc_test_complex.proto:111:32
+
+
+ > message_type[4] > nested_type[0] > field[1] > name:
+desc_test_complex.proto:111:33
+desc_test_complex.proto:111:39
+
+
+ > message_type[4] > nested_type[0] > field[1] > number:
+desc_test_complex.proto:111:42
+desc_test_complex.proto:111:43
+
+
+ > message_type[4] > field[1]:
+desc_test_complex.proto:114:9
+desc_test_complex.proto:114:44
+
+
+ > message_type[4] > field[1] > label:
+desc_test_complex.proto:114:9
+desc_test_complex.proto:114:17
+
+
+ > message_type[4] > field[1] > type_name:
+desc_test_complex.proto:114:18
+desc_test_complex.proto:114:28
+
+
+ > message_type[4] > field[1] > name:
+desc_test_complex.proto:114:29
+desc_test_complex.proto:114:39
+
+
+ > message_type[4] > field[1] > number:
+desc_test_complex.proto:114:42
+desc_test_complex.proto:114:43
+
+
+ > extension:
+desc_test_complex.proto:117:1
+desc_test_complex.proto:119:2
+
+
+ > extension[4]:
+desc_test_complex.proto:118:9
+desc_test_complex.proto:118:46
+
+
+ > extension[4] > extendee:
+desc_test_complex.proto:117:8
+desc_test_complex.proto:117:37
+
+
+ > extension[4] > label:
+desc_test_complex.proto:118:9
+desc_test_complex.proto:118:17
+
+
+ > extension[4] > type_name:
+desc_test_complex.proto:118:18
+desc_test_complex.proto:118:27
+
+
+ > extension[4] > name:
+desc_test_complex.proto:118:28
+desc_test_complex.proto:118:37
+
+
+ > extension[4] > number:
+desc_test_complex.proto:118:40
+desc_test_complex.proto:118:45
+
+
+ > service[0]:
+desc_test_complex.proto:121:1
+desc_test_complex.proto:140:2
+
+
+ > service[0] > name:
+desc_test_complex.proto:121:9
+desc_test_complex.proto:121:24
+
+
+ > service[0] > method[0]:
+desc_test_complex.proto:122:9
+desc_test_complex.proto:130:10
+
+
+ > service[0] > method[0] > name:
+desc_test_complex.proto:122:13
+desc_test_complex.proto:122:21
+
+
+ > service[0] > method[0] > input_type:
+desc_test_complex.proto:122:22
+desc_test_complex.proto:122:26
+
+
+ > service[0] > method[0] > output_type:
+desc_test_complex.proto:122:37
+desc_test_complex.proto:122:41
+
+
+ > service[0] > method[0] > options:
+desc_test_complex.proto:123:17
+desc_test_complex.proto:129:19
+
+
+ > service[0] > method[0] > options > validator:
+desc_test_complex.proto:123:17
+desc_test_complex.proto:129:19
+
+
+ > service[0] > method[1]:
+desc_test_complex.proto:131:9
+desc_test_complex.proto:139:10
+
+
+ > service[0] > method[1] > name:
+desc_test_complex.proto:131:13
+desc_test_complex.proto:131:16
+
+
+ > service[0] > method[1] > input_type:
+desc_test_complex.proto:131:17
+desc_test_complex.proto:131:21
+
+
+ > service[0] > method[1] > output_type:
+desc_test_complex.proto:131:32
+desc_test_complex.proto:131:36
+
+
+ > service[0] > method[1] > options:
+desc_test_complex.proto:132:17
+desc_test_complex.proto:138:19
+
+
+ > service[0] > method[1] > options > validator:
+desc_test_complex.proto:132:17
+desc_test_complex.proto:138:19
+
+
+ > message_type[5]:
+desc_test_complex.proto:142:1
+desc_test_complex.proto:168:2
+
+
+ > message_type[5] > name:
+desc_test_complex.proto:142:9
+desc_test_complex.proto:142:13
+
+
+ > message_type[5] > nested_type[0]:
+desc_test_complex.proto:143:3
+desc_test_complex.proto:148:4
+
+
+ > message_type[5] > nested_type[0] > name:
+desc_test_complex.proto:143:11
+desc_test_complex.proto:143:21
+
+
+ > message_type[5] > nested_type[0] > field[0]:
+desc_test_complex.proto:144:5
+desc_test_complex.proto:144:33
+
+
+ > message_type[5] > nested_type[0] > field[0] > label:
+desc_test_complex.proto:144:5
+desc_test_complex.proto:144:13
+
+
+ > message_type[5] > nested_type[0] > field[0] > type:
+desc_test_complex.proto:144:14
+desc_test_complex.proto:144:20
+
+
+ > message_type[5] > nested_type[0] > field[0] > name:
+desc_test_complex.proto:144:21
+desc_test_complex.proto:144:28
+
+
+ > message_type[5] > nested_type[0] > field[0] > number:
+desc_test_complex.proto:144:31
+desc_test_complex.proto:144:32
+
+
+ > message_type[5] > nested_type[0] > field[1]:
+desc_test_complex.proto:145:5
+desc_test_complex.proto:145:35
+
+
+ > message_type[5] > nested_type[0] > field[1] > label:
+desc_test_complex.proto:145:5
+desc_test_complex.proto:145:13
+
+
+ > message_type[5] > nested_type[0] > field[1] > type:
+desc_test_complex.proto:145:14
+desc_test_complex.proto:145:18
+
+
+ > message_type[5] > nested_type[0] > field[1] > name:
+desc_test_complex.proto:145:19
+desc_test_complex.proto:145:30
+
+
+ > message_type[5] > nested_type[0] > field[1] > number:
+desc_test_complex.proto:145:33
+desc_test_complex.proto:145:34
+
+
+ > message_type[5] > nested_type[0] > field[2]:
+desc_test_complex.proto:146:5
+desc_test_complex.proto:146:32
+
+
+ > message_type[5] > nested_type[0] > field[2] > label:
+desc_test_complex.proto:146:5
+desc_test_complex.proto:146:13
+
+
+ > message_type[5] > nested_type[0] > field[2] > type:
+desc_test_complex.proto:146:14
+desc_test_complex.proto:146:19
+
+
+ > message_type[5] > nested_type[0] > field[2] > name:
+desc_test_complex.proto:146:20
+desc_test_complex.proto:146:27
+
+
+ > message_type[5] > nested_type[0] > field[2] > number:
+desc_test_complex.proto:146:30
+desc_test_complex.proto:146:31
+
+
+ > message_type[5] > nested_type[0] > field[3]:
+desc_test_complex.proto:147:5
+desc_test_complex.proto:147:32
+
+
+ > message_type[5] > nested_type[0] > field[3] > label:
+desc_test_complex.proto:147:5
+desc_test_complex.proto:147:13
+
+
+ > message_type[5] > nested_type[0] > field[3] > type:
+desc_test_complex.proto:147:14
+desc_test_complex.proto:147:19
+
+
+ > message_type[5] > nested_type[0] > field[3] > name:
+desc_test_complex.proto:147:20
+desc_test_complex.proto:147:27
+
+
+ > message_type[5] > nested_type[0] > field[3] > number:
+desc_test_complex.proto:147:30
+desc_test_complex.proto:147:31
+
+
+ > message_type[5] > nested_type[1]:
+desc_test_complex.proto:149:3
+desc_test_complex.proto:152:4
+
+
+ > message_type[5] > nested_type[1] > name:
+desc_test_complex.proto:149:11
+desc_test_complex.proto:149:18
+
+
+ > message_type[5] > nested_type[1] > field[0]:
+desc_test_complex.proto:150:5
+desc_test_complex.proto:150:32
+
+
+ > message_type[5] > nested_type[1] > field[0] > label:
+desc_test_complex.proto:150:5
+desc_test_complex.proto:150:13
+
+
+ > message_type[5] > nested_type[1] > field[0] > type:
+desc_test_complex.proto:150:14
+desc_test_complex.proto:150:19
+
+
+ > message_type[5] > nested_type[1] > field[0] > name:
+desc_test_complex.proto:150:20
+desc_test_complex.proto:150:27
+
+
+ > message_type[5] > nested_type[1] > field[0] > number:
+desc_test_complex.proto:150:30
+desc_test_complex.proto:150:31
+
+
+ > message_type[5] > nested_type[1] > field[1]:
+desc_test_complex.proto:151:5
+desc_test_complex.proto:151:33
+
+
+ > message_type[5] > nested_type[1] > field[1] > label:
+desc_test_complex.proto:151:5
+desc_test_complex.proto:151:13
+
+
+ > message_type[5] > nested_type[1] > field[1] > type:
+desc_test_complex.proto:151:14
+desc_test_complex.proto:151:20
+
+
+ > message_type[5] > nested_type[1] > field[1] > name:
+desc_test_complex.proto:151:21
+desc_test_complex.proto:151:28
+
+
+ > message_type[5] > nested_type[1] > field[1] > number:
+desc_test_complex.proto:151:31
+desc_test_complex.proto:151:32
+
+
+ > message_type[5] > nested_type[2]:
+desc_test_complex.proto:153:3
+desc_test_complex.proto:158:4
+
+
+ > message_type[5] > nested_type[2] > name:
+desc_test_complex.proto:153:11
+desc_test_complex.proto:153:23
+
+
+ > message_type[5] > nested_type[2] > field[0]:
+desc_test_complex.proto:154:5
+desc_test_complex.proto:154:35
+
+
+ > message_type[5] > nested_type[2] > field[0] > label:
+desc_test_complex.proto:154:5
+desc_test_complex.proto:154:13
+
+
+ > message_type[5] > nested_type[2] > field[0] > type:
+desc_test_complex.proto:154:14
+desc_test_complex.proto:154:18
+
+
+ > message_type[5] > nested_type[2] > field[0] > name:
+desc_test_complex.proto:154:19
+desc_test_complex.proto:154:30
+
+
+ > message_type[5] > nested_type[2] > field[0] > number:
+desc_test_complex.proto:154:33
+desc_test_complex.proto:154:34
+
+
+ > message_type[5] > nested_type[2] > field[1]:
+desc_test_complex.proto:155:5
+desc_test_complex.proto:155:34
+
+
+ > message_type[5] > nested_type[2] > field[1] > label:
+desc_test_complex.proto:155:5
+desc_test_complex.proto:155:13
+
+
+ > message_type[5] > nested_type[2] > field[1] > type:
+desc_test_complex.proto:155:14
+desc_test_complex.proto:155:19
+
+
+ > message_type[5] > nested_type[2] > field[1] > name:
+desc_test_complex.proto:155:20
+desc_test_complex.proto:155:29
+
+
+ > message_type[5] > nested_type[2] > field[1] > number:
+desc_test_complex.proto:155:32
+desc_test_complex.proto:155:33
+
+
+ > message_type[5] > nested_type[2] > field[2]:
+desc_test_complex.proto:156:5
+desc_test_complex.proto:156:34
+
+
+ > message_type[5] > nested_type[2] > field[2] > label:
+desc_test_complex.proto:156:5
+desc_test_complex.proto:156:13
+
+
+ > message_type[5] > nested_type[2] > field[2] > type:
+desc_test_complex.proto:156:14
+desc_test_complex.proto:156:19
+
+
+ > message_type[5] > nested_type[2] > field[2] > name:
+desc_test_complex.proto:156:20
+desc_test_complex.proto:156:29
+
+
+ > message_type[5] > nested_type[2] > field[2] > number:
+desc_test_complex.proto:156:32
+desc_test_complex.proto:156:33
+
+
+ > message_type[5] > nested_type[2] > field[3]:
+desc_test_complex.proto:157:5
+desc_test_complex.proto:157:29
+
+
+ > message_type[5] > nested_type[2] > field[3] > label:
+desc_test_complex.proto:157:5
+desc_test_complex.proto:157:13
+
+
+ > message_type[5] > nested_type[2] > field[3] > type_name:
+desc_test_complex.proto:157:14
+desc_test_complex.proto:157:18
+
+
+ > message_type[5] > nested_type[2] > field[3] > name:
+desc_test_complex.proto:157:19
+desc_test_complex.proto:157:24
+
+
+ > message_type[5] > nested_type[2] > field[3] > number:
+desc_test_complex.proto:157:27
+desc_test_complex.proto:157:28
+
+
+ > message_type[5] > oneof_decl[0]:
+desc_test_complex.proto:159:3
+desc_test_complex.proto:167:4
+
+
+ > message_type[5] > oneof_decl[0] > name:
+desc_test_complex.proto:159:9
+desc_test_complex.proto:159:13
+
+
+ > message_type[5] > field[0]:
+desc_test_complex.proto:160:5
+desc_test_complex.proto:160:27
+
+
+ > message_type[5] > field[0] > type_name:
+desc_test_complex.proto:160:5
+desc_test_complex.proto:160:15
+
+
+ > message_type[5] > field[0] > name:
+desc_test_complex.proto:160:16
+desc_test_complex.proto:160:22
+
+
+ > message_type[5] > field[0] > number:
+desc_test_complex.proto:160:25
+desc_test_complex.proto:160:26
+
+
+ > message_type[5] > field[1]:
+desc_test_complex.proto:161:5
+desc_test_complex.proto:161:31
+
+
+ > message_type[5] > field[1] > type_name:
+desc_test_complex.proto:161:5
+desc_test_complex.proto:161:17
+
+
+ > message_type[5] > field[1] > name:
+desc_test_complex.proto:161:18
+desc_test_complex.proto:161:26
+
+
+ > message_type[5] > field[1] > number:
+desc_test_complex.proto:161:29
+desc_test_complex.proto:161:30
+
+
+ > message_type[5] > field[2]:
+desc_test_complex.proto:162:5
+desc_test_complex.proto:162:21
+
+
+ > message_type[5] > field[2] > type_name:
+desc_test_complex.proto:162:5
+desc_test_complex.proto:162:12
+
+
+ > message_type[5] > field[2] > name:
+desc_test_complex.proto:162:13
+desc_test_complex.proto:162:16
+
+
+ > message_type[5] > field[2] > number:
+desc_test_complex.proto:162:19
+desc_test_complex.proto:162:20
+
+
+ > message_type[5] > field[3]:
+desc_test_complex.proto:163:9
+desc_test_complex.proto:166:10
+
+
+ > message_type[5] > field[3] > type:
+desc_test_complex.proto:163:9
+desc_test_complex.proto:163:14
+
+
+ > message_type[5] > field[3] > name:
+desc_test_complex.proto:163:15
+desc_test_complex.proto:163:24
+
+
+ > message_type[5] > field[3] > number:
+desc_test_complex.proto:163:27
+desc_test_complex.proto:163:28
+
+
+ > message_type[5] > nested_type[3]:
+desc_test_complex.proto:163:9
+desc_test_complex.proto:166:10
+
+
+ > message_type[5] > nested_type[3] > name:
+desc_test_complex.proto:163:15
+desc_test_complex.proto:163:24
+
+
+ > message_type[5] > field[3] > type_name:
+desc_test_complex.proto:163:15
+desc_test_complex.proto:163:24
+
+
+ > message_type[5] > nested_type[3] > field[0]:
+desc_test_complex.proto:164:17
+desc_test_complex.proto:164:45
+
+
+ > message_type[5] > nested_type[3] > field[0] > label:
+desc_test_complex.proto:164:17
+desc_test_complex.proto:164:25
+
+
+ > message_type[5] > nested_type[3] > field[0] > type:
+desc_test_complex.proto:164:26
+desc_test_complex.proto:164:32
+
+
+ > message_type[5] > nested_type[3] > field[0] > name:
+desc_test_complex.proto:164:33
+desc_test_complex.proto:164:40
+
+
+ > message_type[5] > nested_type[3] > field[0] > number:
+desc_test_complex.proto:164:43
+desc_test_complex.proto:164:44
+
+
+ > message_type[5] > nested_type[3] > field[1]:
+desc_test_complex.proto:165:17
+desc_test_complex.proto:165:45
+
+
+ > message_type[5] > nested_type[3] > field[1] > label:
+desc_test_complex.proto:165:17
+desc_test_complex.proto:165:25
+
+
+ > message_type[5] > nested_type[3] > field[1] > type:
+desc_test_complex.proto:165:26
+desc_test_complex.proto:165:32
+
+
+ > message_type[5] > nested_type[3] > field[1] > name:
+desc_test_complex.proto:165:33
+desc_test_complex.proto:165:40
+
+
+ > message_type[5] > nested_type[3] > field[1] > number:
+desc_test_complex.proto:165:43
+desc_test_complex.proto:165:44
+
+
+ > extension:
+desc_test_complex.proto:170:1
+desc_test_complex.proto:172:2
+
+
+ > extension[5]:
+desc_test_complex.proto:171:3
+desc_test_complex.proto:171:30
+
+
+ > extension[5] > extendee:
+desc_test_complex.proto:170:8
+desc_test_complex.proto:170:36
+
+
+ > extension[5] > label:
+desc_test_complex.proto:171:3
+desc_test_complex.proto:171:11
+
+
+ > extension[5] > type_name:
+desc_test_complex.proto:171:12
+desc_test_complex.proto:171:16
+
+
+ > extension[5] > name:
+desc_test_complex.proto:171:17
+desc_test_complex.proto:171:22
+
+
+ > extension[5] > number:
+desc_test_complex.proto:171:25
+desc_test_complex.proto:171:29
+
+
+ > message_type[6]:
+desc_test_complex.proto:174:1
+desc_test_complex.proto:180:2
+
+
+ > message_type[6] > name:
+desc_test_complex.proto:174:9
+desc_test_complex.proto:174:24
+
+
+ > message_type[6] > field[0]:
+desc_test_complex.proto:175:5
+desc_test_complex.proto:179:11
+
+
+ > message_type[6] > field[0] > label:
+desc_test_complex.proto:175:5
+desc_test_complex.proto:175:13
+
+
+ > message_type[6] > field[0] > type:
+desc_test_complex.proto:175:14
+desc_test_complex.proto:175:20
+
+
+ > message_type[6] > field[0] > name:
+desc_test_complex.proto:175:21
+desc_test_complex.proto:175:29
+
+
+ > message_type[6] > field[0] > number:
+desc_test_complex.proto:175:32
+desc_test_complex.proto:175:33
+
+
+ > message_type[6] > field[0] > options:
+desc_test_complex.proto:176:7
+desc_test_complex.proto:179:10
+
+
+ > message_type[6] > field[0] > options > rules > repeated:
+desc_test_complex.proto:176:8
+desc_test_complex.proto:179:9
+
+
+ > message_type[7]:
+desc_test_complex.proto:184:1
+desc_test_complex.proto:220:2
+    Leading detached comment [0]:
+ tests cases where field names collide with keywords
+
+
+
+ > message_type[7] > name:
+desc_test_complex.proto:184:9
+desc_test_complex.proto:184:26
+
+
+ > message_type[7] > field[0]:
+desc_test_complex.proto:185:9
+desc_test_complex.proto:185:34
+
+
+ > message_type[7] > field[0] > label:
+desc_test_complex.proto:185:9
+desc_test_complex.proto:185:17
+
+
+ > message_type[7] > field[0] > type:
+desc_test_complex.proto:185:18
+desc_test_complex.proto:185:22
+
+
+ > message_type[7] > field[0] > name:
+desc_test_complex.proto:185:23
+desc_test_complex.proto:185:29
+
+
+ > message_type[7] > field[0] > number:
+desc_test_complex.proto:185:32
+desc_test_complex.proto:185:33
+
+
+ > message_type[7] > field[1]:
+desc_test_complex.proto:186:9
+desc_test_complex.proto:186:34
+
+
+ > message_type[7] > field[1] > label:
+desc_test_complex.proto:186:9
+desc_test_complex.proto:186:17
+
+
+ > message_type[7] > field[1] > type:
+desc_test_complex.proto:186:18
+desc_test_complex.proto:186:22
+
+
+ > message_type[7] > field[1] > name:
+desc_test_complex.proto:186:23
+desc_test_complex.proto:186:29
+
+
+ > message_type[7] > field[1] > number:
+desc_test_complex.proto:186:32
+desc_test_complex.proto:186:33
+
+
+ > message_type[7] > field[2]:
+desc_test_complex.proto:187:9
+desc_test_complex.proto:187:34
+
+
+ > message_type[7] > field[2] > label:
+desc_test_complex.proto:187:9
+desc_test_complex.proto:187:17
+
+
+ > message_type[7] > field[2] > type:
+desc_test_complex.proto:187:18
+desc_test_complex.proto:187:22
+
+
+ > message_type[7] > field[2] > name:
+desc_test_complex.proto:187:23
+desc_test_complex.proto:187:29
+
+
+ > message_type[7] > field[2] > number:
+desc_test_complex.proto:187:32
+desc_test_complex.proto:187:33
+
+
+ > message_type[7] > field[3]:
+desc_test_complex.proto:188:9
+desc_test_complex.proto:188:32
+
+
+ > message_type[7] > field[3] > label:
+desc_test_complex.proto:188:9
+desc_test_complex.proto:188:17
+
+
+ > message_type[7] > field[3] > type:
+desc_test_complex.proto:188:18
+desc_test_complex.proto:188:22
+
+
+ > message_type[7] > field[3] > name:
+desc_test_complex.proto:188:23
+desc_test_complex.proto:188:27
+
+
+ > message_type[7] > field[3] > number:
+desc_test_complex.proto:188:30
+desc_test_complex.proto:188:31
+
+
+ > message_type[7] > field[4]:
+desc_test_complex.proto:189:9
+desc_test_complex.proto:189:35
+
+
+ > message_type[7] > field[4] > label:
+desc_test_complex.proto:189:9
+desc_test_complex.proto:189:17
+
+
+ > message_type[7] > field[4] > type:
+desc_test_complex.proto:189:18
+desc_test_complex.proto:189:22
+
+
+ > message_type[7] > field[4] > name:
+desc_test_complex.proto:189:23
+desc_test_complex.proto:189:30
+
+
+ > message_type[7] > field[4] > number:
+desc_test_complex.proto:189:33
+desc_test_complex.proto:189:34
+
+
+ > message_type[7] > field[5]:
+desc_test_complex.proto:190:9
+desc_test_complex.proto:190:36
+
+
+ > message_type[7] > field[5] > label:
+desc_test_complex.proto:190:9
+desc_test_complex.proto:190:17
+
+
+ > message_type[7] > field[5] > type:
+desc_test_complex.proto:190:18
+desc_test_complex.proto:190:24
+
+
+ > message_type[7] > field[5] > name:
+desc_test_complex.proto:190:25
+desc_test_complex.proto:190:31
+
+
+ > message_type[7] > field[5] > number:
+desc_test_complex.proto:190:34
+desc_test_complex.proto:190:35
+
+
+ > message_type[7] > field[6]:
+desc_test_complex.proto:191:9
+desc_test_complex.proto:191:34
+
+
+ > message_type[7] > field[6] > label:
+desc_test_complex.proto:191:9
+desc_test_complex.proto:191:17
+
+
+ > message_type[7] > field[6] > type:
+desc_test_complex.proto:191:18
+desc_test_complex.proto:191:23
+
+
+ > message_type[7] > field[6] > name:
+desc_test_complex.proto:191:24
+desc_test_complex.proto:191:29
+
+
+ > message_type[7] > field[6] > number:
+desc_test_complex.proto:191:32
+desc_test_complex.proto:191:33
+
+
+ > message_type[7] > field[7]:
+desc_test_complex.proto:192:9
+desc_test_complex.proto:192:34
+
+
+ > message_type[7] > field[7] > label:
+desc_test_complex.proto:192:9
+desc_test_complex.proto:192:17
+
+
+ > message_type[7] > field[7] > type:
+desc_test_complex.proto:192:18
+desc_test_complex.proto:192:23
+
+
+ > message_type[7] > field[7] > name:
+desc_test_complex.proto:192:24
+desc_test_complex.proto:192:29
+
+
+ > message_type[7] > field[7] > number:
+desc_test_complex.proto:192:32
+desc_test_complex.proto:192:33
+
+
+ > message_type[7] > field[8]:
+desc_test_complex.proto:193:9
+desc_test_complex.proto:193:34
+
+
+ > message_type[7] > field[8] > label:
+desc_test_complex.proto:193:9
+desc_test_complex.proto:193:17
+
+
+ > message_type[7] > field[8] > type:
+desc_test_complex.proto:193:18
+desc_test_complex.proto:193:23
+
+
+ > message_type[7] > field[8] > name:
+desc_test_complex.proto:193:24
+desc_test_complex.proto:193:29
+
+
+ > message_type[7] > field[8] > number:
+desc_test_complex.proto:193:32
+desc_test_complex.proto:193:33
+
+
+ > message_type[7] > field[9]:
+desc_test_complex.proto:194:9
+desc_test_complex.proto:194:37
+
+
+ > message_type[7] > field[9] > label:
+desc_test_complex.proto:194:9
+desc_test_complex.proto:194:17
+
+
+ > message_type[7] > field[9] > type:
+desc_test_complex.proto:194:18
+desc_test_complex.proto:194:24
+
+
+ > message_type[7] > field[9] > name:
+desc_test_complex.proto:194:25
+desc_test_complex.proto:194:31
+
+
+ > message_type[7] > field[9] > number:
+desc_test_complex.proto:194:34
+desc_test_complex.proto:194:36
+
+
+ > message_type[7] > field[10]:
+desc_test_complex.proto:195:9
+desc_test_complex.proto:195:37
+
+
+ > message_type[7] > field[10] > label:
+desc_test_complex.proto:195:9
+desc_test_complex.proto:195:17
+
+
+ > message_type[7] > field[10] > type:
+desc_test_complex.proto:195:18
+desc_test_complex.proto:195:24
+
+
+ > message_type[7] > field[10] > name:
+desc_test_complex.proto:195:25
+desc_test_complex.proto:195:31
+
+
+ > message_type[7] > field[10] > number:
+desc_test_complex.proto:195:34
+desc_test_complex.proto:195:36
+
+
+ > message_type[7] > field[11]:
+desc_test_complex.proto:196:9
+desc_test_complex.proto:196:37
+
+
+ > message_type[7] > field[11] > label:
+desc_test_complex.proto:196:9
+desc_test_complex.proto:196:17
+
+
+ > message_type[7] > field[11] > type:
+desc_test_complex.proto:196:18
+desc_test_complex.proto:196:24
+
+
+ > message_type[7] > field[11] > name:
+desc_test_complex.proto:196:25
+desc_test_complex.proto:196:31
+
+
+ > message_type[7] > field[11] > number:
+desc_test_complex.proto:196:34
+desc_test_complex.proto:196:36
+
+
+ > message_type[7] > field[12]:
+desc_test_complex.proto:197:9
+desc_test_complex.proto:197:37
+
+
+ > message_type[7] > field[12] > label:
+desc_test_complex.proto:197:9
+desc_test_complex.proto:197:17
+
+
+ > message_type[7] > field[12] > type:
+desc_test_complex.proto:197:18
+desc_test_complex.proto:197:24
+
+
+ > message_type[7] > field[12] > name:
+desc_test_complex.proto:197:25
+desc_test_complex.proto:197:31
+
+
+ > message_type[7] > field[12] > number:
+desc_test_complex.proto:197:34
+desc_test_complex.proto:197:36
+
+
+ > message_type[7] > field[13]:
+desc_test_complex.proto:198:9
+desc_test_complex.proto:198:39
+
+
+ > message_type[7] > field[13] > label:
+desc_test_complex.proto:198:9
+desc_test_complex.proto:198:17
+
+
+ > message_type[7] > field[13] > type:
+desc_test_complex.proto:198:18
+desc_test_complex.proto:198:25
+
+
+ > message_type[7] > field[13] > name:
+desc_test_complex.proto:198:26
+desc_test_complex.proto:198:33
+
+
+ > message_type[7] > field[13] > number:
+desc_test_complex.proto:198:36
+desc_test_complex.proto:198:38
+
+
+ > message_type[7] > field[14]:
+desc_test_complex.proto:199:9
+desc_test_complex.proto:199:39
+
+
+ > message_type[7] > field[14] > label:
+desc_test_complex.proto:199:9
+desc_test_complex.proto:199:17
+
+
+ > message_type[7] > field[14] > type:
+desc_test_complex.proto:199:18
+desc_test_complex.proto:199:25
+
+
+ > message_type[7] > field[14] > name:
+desc_test_complex.proto:199:26
+desc_test_complex.proto:199:33
+
+
+ > message_type[7] > field[14] > number:
+desc_test_complex.proto:199:36
+desc_test_complex.proto:199:38
+
+
+ > message_type[7] > field[15]:
+desc_test_complex.proto:200:9
+desc_test_complex.proto:200:41
+
+
+ > message_type[7] > field[15] > label:
+desc_test_complex.proto:200:9
+desc_test_complex.proto:200:17
+
+
+ > message_type[7] > field[15] > type:
+desc_test_complex.proto:200:18
+desc_test_complex.proto:200:26
+
+
+ > message_type[7] > field[15] > name:
+desc_test_complex.proto:200:27
+desc_test_complex.proto:200:35
+
+
+ > message_type[7] > field[15] > number:
+desc_test_complex.proto:200:38
+desc_test_complex.proto:200:40
+
+
+ > message_type[7] > field[16]:
+desc_test_complex.proto:201:9
+desc_test_complex.proto:201:41
+
+
+ > message_type[7] > field[16] > label:
+desc_test_complex.proto:201:9
+desc_test_complex.proto:201:17
+
+
+ > message_type[7] > field[16] > type:
+desc_test_complex.proto:201:18
+desc_test_complex.proto:201:26
+
+
+ > message_type[7] > field[16] > name:
+desc_test_complex.proto:201:27
+desc_test_complex.proto:201:35
+
+
+ > message_type[7] > field[16] > number:
+desc_test_complex.proto:201:38
+desc_test_complex.proto:201:40
+
+
+ > message_type[7] > field[17]:
+desc_test_complex.proto:202:9
+desc_test_complex.proto:202:33
+
+
+ > message_type[7] > field[17] > label:
+desc_test_complex.proto:202:9
+desc_test_complex.proto:202:17
+
+
+ > message_type[7] > field[17] > type:
+desc_test_complex.proto:202:18
+desc_test_complex.proto:202:22
+
+
+ > message_type[7] > field[17] > name:
+desc_test_complex.proto:202:23
+desc_test_complex.proto:202:27
+
+
+ > message_type[7] > field[17] > number:
+desc_test_complex.proto:202:30
+desc_test_complex.proto:202:32
+
+
+ > message_type[7] > field[18]:
+desc_test_complex.proto:203:9
+desc_test_complex.proto:203:35
+
+
+ > message_type[7] > field[18] > label:
+desc_test_complex.proto:203:9
+desc_test_complex.proto:203:17
+
+
+ > message_type[7] > field[18] > type:
+desc_test_complex.proto:203:18
+desc_test_complex.proto:203:23
+
+
+ > message_type[7] > field[18] > name:
+desc_test_complex.proto:203:24
+desc_test_complex.proto:203:29
+
+
+ > message_type[7] > field[18] > number:
+desc_test_complex.proto:203:32
+desc_test_complex.proto:203:34
+
+
+ > message_type[7] > field[19]:
+desc_test_complex.proto:204:9
+desc_test_complex.proto:204:37
+
+
+ > message_type[7] > field[19] > label:
+desc_test_complex.proto:204:9
+desc_test_complex.proto:204:17
+
+
+ > message_type[7] > field[19] > type:
+desc_test_complex.proto:204:18
+desc_test_complex.proto:204:24
+
+
+ > message_type[7] > field[19] > name:
+desc_test_complex.proto:204:25
+desc_test_complex.proto:204:31
+
+
+ > message_type[7] > field[19] > number:
+desc_test_complex.proto:204:34
+desc_test_complex.proto:204:36
+
+
+ > message_type[7] > field[20]:
+desc_test_complex.proto:205:9
+desc_test_complex.proto:205:37
+
+
+ > message_type[7] > field[20] > label:
+desc_test_complex.proto:205:9
+desc_test_complex.proto:205:17
+
+
+ > message_type[7] > field[20] > type:
+desc_test_complex.proto:205:18
+desc_test_complex.proto:205:22
+
+
+ > message_type[7] > field[20] > name:
+desc_test_complex.proto:205:23
+desc_test_complex.proto:205:31
+
+
+ > message_type[7] > field[20] > number:
+desc_test_complex.proto:205:34
+desc_test_complex.proto:205:36
+
+
+ > message_type[7] > field[21]:
+desc_test_complex.proto:206:9
+desc_test_complex.proto:206:37
+
+
+ > message_type[7] > field[21] > label:
+desc_test_complex.proto:206:9
+desc_test_complex.proto:206:17
+
+
+ > message_type[7] > field[21] > type:
+desc_test_complex.proto:206:18
+desc_test_complex.proto:206:22
+
+
+ > message_type[7] > field[21] > name:
+desc_test_complex.proto:206:23
+desc_test_complex.proto:206:31
+
+
+ > message_type[7] > field[21] > number:
+desc_test_complex.proto:206:34
+desc_test_complex.proto:206:36
+
+
+ > message_type[7] > field[22]:
+desc_test_complex.proto:207:9
+desc_test_complex.proto:207:37
+
+
+ > message_type[7] > field[22] > label:
+desc_test_complex.proto:207:9
+desc_test_complex.proto:207:17
+
+
+ > message_type[7] > field[22] > type:
+desc_test_complex.proto:207:18
+desc_test_complex.proto:207:22
+
+
+ > message_type[7] > field[22] > name:
+desc_test_complex.proto:207:23
+desc_test_complex.proto:207:31
+
+
+ > message_type[7] > field[22] > number:
+desc_test_complex.proto:207:34
+desc_test_complex.proto:207:36
+
+
+ > message_type[7] > field[23]:
+desc_test_complex.proto:208:9
+desc_test_complex.proto:208:36
+
+
+ > message_type[7] > field[23] > label:
+desc_test_complex.proto:208:9
+desc_test_complex.proto:208:17
+
+
+ > message_type[7] > field[23] > type:
+desc_test_complex.proto:208:18
+desc_test_complex.proto:208:22
+
+
+ > message_type[7] > field[23] > name:
+desc_test_complex.proto:208:23
+desc_test_complex.proto:208:30
+
+
+ > message_type[7] > field[23] > number:
+desc_test_complex.proto:208:33
+desc_test_complex.proto:208:35
+
+
+ > message_type[7] > field[24]:
+desc_test_complex.proto:209:9
+desc_test_complex.proto:209:33
+
+
+ > message_type[7] > field[24] > label:
+desc_test_complex.proto:209:9
+desc_test_complex.proto:209:17
+
+
+ > message_type[7] > field[24] > type:
+desc_test_complex.proto:209:18
+desc_test_complex.proto:209:22
+
+
+ > message_type[7] > field[24] > name:
+desc_test_complex.proto:209:23
+desc_test_complex.proto:209:27
+
+
+ > message_type[7] > field[24] > number:
+desc_test_complex.proto:209:30
+desc_test_complex.proto:209:32
+
+
+ > message_type[7] > field[25]:
+desc_test_complex.proto:210:9
+desc_test_complex.proto:210:36
+
+
+ > message_type[7] > field[25] > label:
+desc_test_complex.proto:210:9
+desc_test_complex.proto:210:17
+
+
+ > message_type[7] > field[25] > type:
+desc_test_complex.proto:210:18
+desc_test_complex.proto:210:22
+
+
+ > message_type[7] > field[25] > name:
+desc_test_complex.proto:210:23
+desc_test_complex.proto:210:30
+
+
+ > message_type[7] > field[25] > number:
+desc_test_complex.proto:210:33
+desc_test_complex.proto:210:35
+
+
+ > message_type[7] > field[26]:
+desc_test_complex.proto:211:9
+desc_test_complex.proto:211:32
+
+
+ > message_type[7] > field[26] > label:
+desc_test_complex.proto:211:9
+desc_test_complex.proto:211:17
+
+
+ > message_type[7] > field[26] > type:
+desc_test_complex.proto:211:18
+desc_test_complex.proto:211:22
+
+
+ > message_type[7] > field[26] > name:
+desc_test_complex.proto:211:23
+desc_test_complex.proto:211:26
+
+
+ > message_type[7] > field[26] > number:
+desc_test_complex.proto:211:29
+desc_test_complex.proto:211:31
+
+
+ > message_type[7] > field[27]:
+desc_test_complex.proto:212:9
+desc_test_complex.proto:212:35
+
+
+ > message_type[7] > field[27] > label:
+desc_test_complex.proto:212:9
+desc_test_complex.proto:212:17
+
+
+ > message_type[7] > field[27] > type:
+desc_test_complex.proto:212:18
+desc_test_complex.proto:212:22
+
+
+ > message_type[7] > field[27] > name:
+desc_test_complex.proto:212:23
+desc_test_complex.proto:212:29
+
+
+ > message_type[7] > field[27] > number:
+desc_test_complex.proto:212:32
+desc_test_complex.proto:212:34
+
+
+ > message_type[7] > field[28]:
+desc_test_complex.proto:213:9
+desc_test_complex.proto:213:35
+
+
+ > message_type[7] > field[28] > label:
+desc_test_complex.proto:213:9
+desc_test_complex.proto:213:17
+
+
+ > message_type[7] > field[28] > type:
+desc_test_complex.proto:213:18
+desc_test_complex.proto:213:22
+
+
+ > message_type[7] > field[28] > name:
+desc_test_complex.proto:213:23
+desc_test_complex.proto:213:29
+
+
+ > message_type[7] > field[28] > number:
+desc_test_complex.proto:213:32
+desc_test_complex.proto:213:34
+
+
+ > message_type[7] > field[29]:
+desc_test_complex.proto:214:9
+desc_test_complex.proto:214:39
+
+
+ > message_type[7] > field[29] > label:
+desc_test_complex.proto:214:9
+desc_test_complex.proto:214:17
+
+
+ > message_type[7] > field[29] > type:
+desc_test_complex.proto:214:18
+desc_test_complex.proto:214:22
+
+
+ > message_type[7] > field[29] > name:
+desc_test_complex.proto:214:23
+desc_test_complex.proto:214:33
+
+
+ > message_type[7] > field[29] > number:
+desc_test_complex.proto:214:36
+desc_test_complex.proto:214:38
+
+
+ > message_type[7] > field[30]:
+desc_test_complex.proto:215:9
+desc_test_complex.proto:215:37
+
+
+ > message_type[7] > field[30] > label:
+desc_test_complex.proto:215:9
+desc_test_complex.proto:215:17
+
+
+ > message_type[7] > field[30] > type:
+desc_test_complex.proto:215:18
+desc_test_complex.proto:215:22
+
+
+ > message_type[7] > field[30] > name:
+desc_test_complex.proto:215:23
+desc_test_complex.proto:215:31
+
+
+ > message_type[7] > field[30] > number:
+desc_test_complex.proto:215:34
+desc_test_complex.proto:215:36
+
+
+ > message_type[7] > field[31]:
+desc_test_complex.proto:216:9
+desc_test_complex.proto:216:31
+
+
+ > message_type[7] > field[31] > label:
+desc_test_complex.proto:216:9
+desc_test_complex.proto:216:17
+
+
+ > message_type[7] > field[31] > type:
+desc_test_complex.proto:216:18
+desc_test_complex.proto:216:22
+
+
+ > message_type[7] > field[31] > name:
+desc_test_complex.proto:216:23
+desc_test_complex.proto:216:25
+
+
+ > message_type[7] > field[31] > number:
+desc_test_complex.proto:216:28
+desc_test_complex.proto:216:30
+
+
+ > message_type[7] > field[32]:
+desc_test_complex.proto:217:9
+desc_test_complex.proto:217:34
+
+
+ > message_type[7] > field[32] > label:
+desc_test_complex.proto:217:9
+desc_test_complex.proto:217:17
+
+
+ > message_type[7] > field[32] > type:
+desc_test_complex.proto:217:18
+desc_test_complex.proto:217:23
+
+
+ > message_type[7] > field[32] > name:
+desc_test_complex.proto:217:24
+desc_test_complex.proto:217:28
+
+
+ > message_type[7] > field[32] > number:
+desc_test_complex.proto:217:31
+desc_test_complex.proto:217:33
+
+
+ > message_type[7] > field[33]:
+desc_test_complex.proto:218:9
+desc_test_complex.proto:218:35
+
+
+ > message_type[7] > field[33] > label:
+desc_test_complex.proto:218:9
+desc_test_complex.proto:218:17
+
+
+ > message_type[7] > field[33] > type:
+desc_test_complex.proto:218:18
+desc_test_complex.proto:218:23
+
+
+ > message_type[7] > field[33] > name:
+desc_test_complex.proto:218:24
+desc_test_complex.proto:218:29
+
+
+ > message_type[7] > field[33] > number:
+desc_test_complex.proto:218:32
+desc_test_complex.proto:218:34
+
+
+ > message_type[7] > field[34]:
+desc_test_complex.proto:219:9
+desc_test_complex.proto:219:37
+
+
+ > message_type[7] > field[34] > label:
+desc_test_complex.proto:219:9
+desc_test_complex.proto:219:17
+
+
+ > message_type[7] > field[34] > type:
+desc_test_complex.proto:219:18
+desc_test_complex.proto:219:23
+
+
+ > message_type[7] > field[34] > name:
+desc_test_complex.proto:219:24
+desc_test_complex.proto:219:31
+
+
+ > message_type[7] > field[34] > number:
+desc_test_complex.proto:219:34
+desc_test_complex.proto:219:36
+
+
+ > extension:
+desc_test_complex.proto:222:1
+desc_test_complex.proto:259:2
+
+
+ > extension[6]:
+desc_test_complex.proto:223:9
+desc_test_complex.proto:223:38
+
+
+ > extension[6] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[6] > label:
+desc_test_complex.proto:223:9
+desc_test_complex.proto:223:17
+
+
+ > extension[6] > type:
+desc_test_complex.proto:223:18
+desc_test_complex.proto:223:22
+
+
+ > extension[6] > name:
+desc_test_complex.proto:223:23
+desc_test_complex.proto:223:29
+
+
+ > extension[6] > number:
+desc_test_complex.proto:223:32
+desc_test_complex.proto:223:37
+
+
+ > extension[7]:
+desc_test_complex.proto:224:9
+desc_test_complex.proto:224:38
+
+
+ > extension[7] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[7] > label:
+desc_test_complex.proto:224:9
+desc_test_complex.proto:224:17
+
+
+ > extension[7] > type:
+desc_test_complex.proto:224:18
+desc_test_complex.proto:224:22
+
+
+ > extension[7] > name:
+desc_test_complex.proto:224:23
+desc_test_complex.proto:224:29
+
+
+ > extension[7] > number:
+desc_test_complex.proto:224:32
+desc_test_complex.proto:224:37
+
+
+ > extension[8]:
+desc_test_complex.proto:225:9
+desc_test_complex.proto:225:38
+
+
+ > extension[8] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[8] > label:
+desc_test_complex.proto:225:9
+desc_test_complex.proto:225:17
+
+
+ > extension[8] > type:
+desc_test_complex.proto:225:18
+desc_test_complex.proto:225:22
+
+
+ > extension[8] > name:
+desc_test_complex.proto:225:23
+desc_test_complex.proto:225:29
+
+
+ > extension[8] > number:
+desc_test_complex.proto:225:32
+desc_test_complex.proto:225:37
+
+
+ > extension[9]:
+desc_test_complex.proto:226:9
+desc_test_complex.proto:226:36
+
+
+ > extension[9] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[9] > label:
+desc_test_complex.proto:226:9
+desc_test_complex.proto:226:17
+
+
+ > extension[9] > type:
+desc_test_complex.proto:226:18
+desc_test_complex.proto:226:22
+
+
+ > extension[9] > name:
+desc_test_complex.proto:226:23
+desc_test_complex.proto:226:27
+
+
+ > extension[9] > number:
+desc_test_complex.proto:226:30
+desc_test_complex.proto:226:35
+
+
+ > extension[10]:
+desc_test_complex.proto:227:9
+desc_test_complex.proto:227:39
+
+
+ > extension[10] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[10] > label:
+desc_test_complex.proto:227:9
+desc_test_complex.proto:227:17
+
+
+ > extension[10] > type:
+desc_test_complex.proto:227:18
+desc_test_complex.proto:227:22
+
+
+ > extension[10] > name:
+desc_test_complex.proto:227:23
+desc_test_complex.proto:227:30
+
+
+ > extension[10] > number:
+desc_test_complex.proto:227:33
+desc_test_complex.proto:227:38
+
+
+ > extension[11]:
+desc_test_complex.proto:228:9
+desc_test_complex.proto:228:40
+
+
+ > extension[11] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[11] > label:
+desc_test_complex.proto:228:9
+desc_test_complex.proto:228:17
+
+
+ > extension[11] > type:
+desc_test_complex.proto:228:18
+desc_test_complex.proto:228:24
+
+
+ > extension[11] > name:
+desc_test_complex.proto:228:25
+desc_test_complex.proto:228:31
+
+
+ > extension[11] > number:
+desc_test_complex.proto:228:34
+desc_test_complex.proto:228:39
+
+
+ > extension[12]:
+desc_test_complex.proto:229:9
+desc_test_complex.proto:229:38
+
+
+ > extension[12] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[12] > label:
+desc_test_complex.proto:229:9
+desc_test_complex.proto:229:17
+
+
+ > extension[12] > type:
+desc_test_complex.proto:229:18
+desc_test_complex.proto:229:23
+
+
+ > extension[12] > name:
+desc_test_complex.proto:229:24
+desc_test_complex.proto:229:29
+
+
+ > extension[12] > number:
+desc_test_complex.proto:229:32
+desc_test_complex.proto:229:37
+
+
+ > extension[13]:
+desc_test_complex.proto:230:9
+desc_test_complex.proto:230:38
+
+
+ > extension[13] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[13] > label:
+desc_test_complex.proto:230:9
+desc_test_complex.proto:230:17
+
+
+ > extension[13] > type:
+desc_test_complex.proto:230:18
+desc_test_complex.proto:230:23
+
+
+ > extension[13] > name:
+desc_test_complex.proto:230:24
+desc_test_complex.proto:230:29
+
+
+ > extension[13] > number:
+desc_test_complex.proto:230:32
+desc_test_complex.proto:230:37
+
+
+ > extension[14]:
+desc_test_complex.proto:231:9
+desc_test_complex.proto:231:38
+
+
+ > extension[14] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[14] > label:
+desc_test_complex.proto:231:9
+desc_test_complex.proto:231:17
+
+
+ > extension[14] > type:
+desc_test_complex.proto:231:18
+desc_test_complex.proto:231:23
+
+
+ > extension[14] > name:
+desc_test_complex.proto:231:24
+desc_test_complex.proto:231:29
+
+
+ > extension[14] > number:
+desc_test_complex.proto:231:32
+desc_test_complex.proto:231:37
+
+
+ > extension[15]:
+desc_test_complex.proto:232:9
+desc_test_complex.proto:232:40
+
+
+ > extension[15] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[15] > label:
+desc_test_complex.proto:232:9
+desc_test_complex.proto:232:17
+
+
+ > extension[15] > type:
+desc_test_complex.proto:232:18
+desc_test_complex.proto:232:24
+
+
+ > extension[15] > name:
+desc_test_complex.proto:232:25
+desc_test_complex.proto:232:31
+
+
+ > extension[15] > number:
+desc_test_complex.proto:232:34
+desc_test_complex.proto:232:39
+
+
+ > extension[16]:
+desc_test_complex.proto:233:9
+desc_test_complex.proto:233:40
+
+
+ > extension[16] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[16] > label:
+desc_test_complex.proto:233:9
+desc_test_complex.proto:233:17
+
+
+ > extension[16] > type:
+desc_test_complex.proto:233:18
+desc_test_complex.proto:233:24
+
+
+ > extension[16] > name:
+desc_test_complex.proto:233:25
+desc_test_complex.proto:233:31
+
+
+ > extension[16] > number:
+desc_test_complex.proto:233:34
+desc_test_complex.proto:233:39
+
+
+ > extension[17]:
+desc_test_complex.proto:234:9
+desc_test_complex.proto:234:40
+
+
+ > extension[17] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[17] > label:
+desc_test_complex.proto:234:9
+desc_test_complex.proto:234:17
+
+
+ > extension[17] > type:
+desc_test_complex.proto:234:18
+desc_test_complex.proto:234:24
+
+
+ > extension[17] > name:
+desc_test_complex.proto:234:25
+desc_test_complex.proto:234:31
+
+
+ > extension[17] > number:
+desc_test_complex.proto:234:34
+desc_test_complex.proto:234:39
+
+
+ > extension[18]:
+desc_test_complex.proto:235:9
+desc_test_complex.proto:235:40
+
+
+ > extension[18] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[18] > label:
+desc_test_complex.proto:235:9
+desc_test_complex.proto:235:17
+
+
+ > extension[18] > type:
+desc_test_complex.proto:235:18
+desc_test_complex.proto:235:24
+
+
+ > extension[18] > name:
+desc_test_complex.proto:235:25
+desc_test_complex.proto:235:31
+
+
+ > extension[18] > number:
+desc_test_complex.proto:235:34
+desc_test_complex.proto:235:39
+
+
+ > extension[19]:
+desc_test_complex.proto:236:9
+desc_test_complex.proto:236:42
+
+
+ > extension[19] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[19] > label:
+desc_test_complex.proto:236:9
+desc_test_complex.proto:236:17
+
+
+ > extension[19] > type:
+desc_test_complex.proto:236:18
+desc_test_complex.proto:236:25
+
+
+ > extension[19] > name:
+desc_test_complex.proto:236:26
+desc_test_complex.proto:236:33
+
+
+ > extension[19] > number:
+desc_test_complex.proto:236:36
+desc_test_complex.proto:236:41
+
+
+ > extension[20]:
+desc_test_complex.proto:237:9
+desc_test_complex.proto:237:42
+
+
+ > extension[20] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[20] > label:
+desc_test_complex.proto:237:9
+desc_test_complex.proto:237:17
+
+
+ > extension[20] > type:
+desc_test_complex.proto:237:18
+desc_test_complex.proto:237:25
+
+
+ > extension[20] > name:
+desc_test_complex.proto:237:26
+desc_test_complex.proto:237:33
+
+
+ > extension[20] > number:
+desc_test_complex.proto:237:36
+desc_test_complex.proto:237:41
+
+
+ > extension[21]:
+desc_test_complex.proto:238:9
+desc_test_complex.proto:238:44
+
+
+ > extension[21] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[21] > label:
+desc_test_complex.proto:238:9
+desc_test_complex.proto:238:17
+
+
+ > extension[21] > type:
+desc_test_complex.proto:238:18
+desc_test_complex.proto:238:26
+
+
+ > extension[21] > name:
+desc_test_complex.proto:238:27
+desc_test_complex.proto:238:35
+
+
+ > extension[21] > number:
+desc_test_complex.proto:238:38
+desc_test_complex.proto:238:43
+
+
+ > extension[22]:
+desc_test_complex.proto:239:9
+desc_test_complex.proto:239:44
+
+
+ > extension[22] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[22] > label:
+desc_test_complex.proto:239:9
+desc_test_complex.proto:239:17
+
+
+ > extension[22] > type:
+desc_test_complex.proto:239:18
+desc_test_complex.proto:239:26
+
+
+ > extension[22] > name:
+desc_test_complex.proto:239:27
+desc_test_complex.proto:239:35
+
+
+ > extension[22] > number:
+desc_test_complex.proto:239:38
+desc_test_complex.proto:239:43
+
+
+ > extension[23]:
+desc_test_complex.proto:240:9
+desc_test_complex.proto:240:36
+
+
+ > extension[23] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[23] > label:
+desc_test_complex.proto:240:9
+desc_test_complex.proto:240:17
+
+
+ > extension[23] > type:
+desc_test_complex.proto:240:18
+desc_test_complex.proto:240:22
+
+
+ > extension[23] > name:
+desc_test_complex.proto:240:23
+desc_test_complex.proto:240:27
+
+
+ > extension[23] > number:
+desc_test_complex.proto:240:30
+desc_test_complex.proto:240:35
+
+
+ > extension[24]:
+desc_test_complex.proto:241:9
+desc_test_complex.proto:241:38
+
+
+ > extension[24] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[24] > label:
+desc_test_complex.proto:241:9
+desc_test_complex.proto:241:17
+
+
+ > extension[24] > type:
+desc_test_complex.proto:241:18
+desc_test_complex.proto:241:23
+
+
+ > extension[24] > name:
+desc_test_complex.proto:241:24
+desc_test_complex.proto:241:29
+
+
+ > extension[24] > number:
+desc_test_complex.proto:241:32
+desc_test_complex.proto:241:37
+
+
+ > extension[25]:
+desc_test_complex.proto:242:9
+desc_test_complex.proto:242:40
+
+
+ > extension[25] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[25] > label:
+desc_test_complex.proto:242:9
+desc_test_complex.proto:242:17
+
+
+ > extension[25] > type:
+desc_test_complex.proto:242:18
+desc_test_complex.proto:242:24
+
+
+ > extension[25] > name:
+desc_test_complex.proto:242:25
+desc_test_complex.proto:242:31
+
+
+ > extension[25] > number:
+desc_test_complex.proto:242:34
+desc_test_complex.proto:242:39
+
+
+ > extension[26]:
+desc_test_complex.proto:243:9
+desc_test_complex.proto:243:40
+
+
+ > extension[26] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[26] > label:
+desc_test_complex.proto:243:9
+desc_test_complex.proto:243:17
+
+
+ > extension[26] > type:
+desc_test_complex.proto:243:18
+desc_test_complex.proto:243:22
+
+
+ > extension[26] > name:
+desc_test_complex.proto:243:23
+desc_test_complex.proto:243:31
+
+
+ > extension[26] > number:
+desc_test_complex.proto:243:34
+desc_test_complex.proto:243:39
+
+
+ > extension[27]:
+desc_test_complex.proto:244:9
+desc_test_complex.proto:244:40
+
+
+ > extension[27] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[27] > label:
+desc_test_complex.proto:244:9
+desc_test_complex.proto:244:17
+
+
+ > extension[27] > type:
+desc_test_complex.proto:244:18
+desc_test_complex.proto:244:22
+
+
+ > extension[27] > name:
+desc_test_complex.proto:244:23
+desc_test_complex.proto:244:31
+
+
+ > extension[27] > number:
+desc_test_complex.proto:244:34
+desc_test_complex.proto:244:39
+
+
+ > extension[28]:
+desc_test_complex.proto:245:9
+desc_test_complex.proto:245:40
+
+
+ > extension[28] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[28] > label:
+desc_test_complex.proto:245:9
+desc_test_complex.proto:245:17
+
+
+ > extension[28] > type:
+desc_test_complex.proto:245:18
+desc_test_complex.proto:245:22
+
+
+ > extension[28] > name:
+desc_test_complex.proto:245:23
+desc_test_complex.proto:245:31
+
+
+ > extension[28] > number:
+desc_test_complex.proto:245:34
+desc_test_complex.proto:245:39
+
+
+ > extension[29]:
+desc_test_complex.proto:246:9
+desc_test_complex.proto:246:39
+
+
+ > extension[29] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[29] > label:
+desc_test_complex.proto:246:9
+desc_test_complex.proto:246:17
+
+
+ > extension[29] > type:
+desc_test_complex.proto:246:18
+desc_test_complex.proto:246:22
+
+
+ > extension[29] > name:
+desc_test_complex.proto:246:23
+desc_test_complex.proto:246:30
+
+
+ > extension[29] > number:
+desc_test_complex.proto:246:33
+desc_test_complex.proto:246:38
+
+
+ > extension[30]:
+desc_test_complex.proto:247:9
+desc_test_complex.proto:247:36
+
+
+ > extension[30] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[30] > label:
+desc_test_complex.proto:247:9
+desc_test_complex.proto:247:17
+
+
+ > extension[30] > type:
+desc_test_complex.proto:247:18
+desc_test_complex.proto:247:22
+
+
+ > extension[30] > name:
+desc_test_complex.proto:247:23
+desc_test_complex.proto:247:27
+
+
+ > extension[30] > number:
+desc_test_complex.proto:247:30
+desc_test_complex.proto:247:35
+
+
+ > extension[31]:
+desc_test_complex.proto:248:9
+desc_test_complex.proto:248:39
+
+
+ > extension[31] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[31] > label:
+desc_test_complex.proto:248:9
+desc_test_complex.proto:248:17
+
+
+ > extension[31] > type:
+desc_test_complex.proto:248:18
+desc_test_complex.proto:248:22
+
+
+ > extension[31] > name:
+desc_test_complex.proto:248:23
+desc_test_complex.proto:248:30
+
+
+ > extension[31] > number:
+desc_test_complex.proto:248:33
+desc_test_complex.proto:248:38
+
+
+ > extension[32]:
+desc_test_complex.proto:249:9
+desc_test_complex.proto:249:35
+
+
+ > extension[32] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[32] > label:
+desc_test_complex.proto:249:9
+desc_test_complex.proto:249:17
+
+
+ > extension[32] > type:
+desc_test_complex.proto:249:18
+desc_test_complex.proto:249:22
+
+
+ > extension[32] > name:
+desc_test_complex.proto:249:23
+desc_test_complex.proto:249:26
+
+
+ > extension[32] > number:
+desc_test_complex.proto:249:29
+desc_test_complex.proto:249:34
+
+
+ > extension[33]:
+desc_test_complex.proto:250:9
+desc_test_complex.proto:250:38
+
+
+ > extension[33] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[33] > label:
+desc_test_complex.proto:250:9
+desc_test_complex.proto:250:17
+
+
+ > extension[33] > type:
+desc_test_complex.proto:250:18
+desc_test_complex.proto:250:22
+
+
+ > extension[33] > name:
+desc_test_complex.proto:250:23
+desc_test_complex.proto:250:29
+
+
+ > extension[33] > number:
+desc_test_complex.proto:250:32
+desc_test_complex.proto:250:37
+
+
+ > extension[34]:
+desc_test_complex.proto:251:9
+desc_test_complex.proto:251:38
+
+
+ > extension[34] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[34] > label:
+desc_test_complex.proto:251:9
+desc_test_complex.proto:251:17
+
+
+ > extension[34] > type:
+desc_test_complex.proto:251:18
+desc_test_complex.proto:251:22
+
+
+ > extension[34] > name:
+desc_test_complex.proto:251:23
+desc_test_complex.proto:251:29
+
+
+ > extension[34] > number:
+desc_test_complex.proto:251:32
+desc_test_complex.proto:251:37
+
+
+ > extension[35]:
+desc_test_complex.proto:252:9
+desc_test_complex.proto:252:42
+
+
+ > extension[35] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[35] > label:
+desc_test_complex.proto:252:9
+desc_test_complex.proto:252:17
+
+
+ > extension[35] > type:
+desc_test_complex.proto:252:18
+desc_test_complex.proto:252:22
+
+
+ > extension[35] > name:
+desc_test_complex.proto:252:23
+desc_test_complex.proto:252:33
+
+
+ > extension[35] > number:
+desc_test_complex.proto:252:36
+desc_test_complex.proto:252:41
+
+
+ > extension[36]:
+desc_test_complex.proto:253:9
+desc_test_complex.proto:253:40
+
+
+ > extension[36] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[36] > label:
+desc_test_complex.proto:253:9
+desc_test_complex.proto:253:17
+
+
+ > extension[36] > type:
+desc_test_complex.proto:253:18
+desc_test_complex.proto:253:22
+
+
+ > extension[36] > name:
+desc_test_complex.proto:253:23
+desc_test_complex.proto:253:31
+
+
+ > extension[36] > number:
+desc_test_complex.proto:253:34
+desc_test_complex.proto:253:39
+
+
+ > extension[37]:
+desc_test_complex.proto:254:9
+desc_test_complex.proto:254:34
+
+
+ > extension[37] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[37] > label:
+desc_test_complex.proto:254:9
+desc_test_complex.proto:254:17
+
+
+ > extension[37] > type:
+desc_test_complex.proto:254:18
+desc_test_complex.proto:254:22
+
+
+ > extension[37] > name:
+desc_test_complex.proto:254:23
+desc_test_complex.proto:254:25
+
+
+ > extension[37] > number:
+desc_test_complex.proto:254:28
+desc_test_complex.proto:254:33
+
+
+ > extension[38]:
+desc_test_complex.proto:255:9
+desc_test_complex.proto:255:37
+
+
+ > extension[38] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[38] > label:
+desc_test_complex.proto:255:9
+desc_test_complex.proto:255:17
+
+
+ > extension[38] > type:
+desc_test_complex.proto:255:18
+desc_test_complex.proto:255:23
+
+
+ > extension[38] > name:
+desc_test_complex.proto:255:24
+desc_test_complex.proto:255:28
+
+
+ > extension[38] > number:
+desc_test_complex.proto:255:31
+desc_test_complex.proto:255:36
+
+
+ > extension[39]:
+desc_test_complex.proto:256:9
+desc_test_complex.proto:256:38
+
+
+ > extension[39] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[39] > label:
+desc_test_complex.proto:256:9
+desc_test_complex.proto:256:17
+
+
+ > extension[39] > type:
+desc_test_complex.proto:256:18
+desc_test_complex.proto:256:23
+
+
+ > extension[39] > name:
+desc_test_complex.proto:256:24
+desc_test_complex.proto:256:29
+
+
+ > extension[39] > number:
+desc_test_complex.proto:256:32
+desc_test_complex.proto:256:37
+
+
+ > extension[40]:
+desc_test_complex.proto:257:9
+desc_test_complex.proto:257:40
+
+
+ > extension[40] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[40] > label:
+desc_test_complex.proto:257:9
+desc_test_complex.proto:257:17
+
+
+ > extension[40] > type:
+desc_test_complex.proto:257:18
+desc_test_complex.proto:257:23
+
+
+ > extension[40] > name:
+desc_test_complex.proto:257:24
+desc_test_complex.proto:257:31
+
+
+ > extension[40] > number:
+desc_test_complex.proto:257:34
+desc_test_complex.proto:257:39
+
+
+ > extension[41]:
+desc_test_complex.proto:258:9
+desc_test_complex.proto:258:49
+
+
+ > extension[41] > extendee:
+desc_test_complex.proto:222:8
+desc_test_complex.proto:222:36
+
+
+ > extension[41] > label:
+desc_test_complex.proto:258:9
+desc_test_complex.proto:258:17
+
+
+ > extension[41] > type_name:
+desc_test_complex.proto:258:18
+desc_test_complex.proto:258:35
+
+
+ > extension[41] > name:
+desc_test_complex.proto:258:36
+desc_test_complex.proto:258:40
+
+
+ > extension[41] > number:
+desc_test_complex.proto:258:43
+desc_test_complex.proto:258:48
+
+
+ > message_type[8]:
+desc_test_complex.proto:261:1
+desc_test_complex.proto:286:2
+
+
+ > message_type[8] > name:
+desc_test_complex.proto:261:9
+desc_test_complex.proto:261:32
+
+
+ > message_type[8] > field[0]:
+desc_test_complex.proto:262:9
+desc_test_complex.proto:272:11
+
+
+ > message_type[8] > field[0] > label:
+desc_test_complex.proto:262:9
+desc_test_complex.proto:262:17
+
+
+ > message_type[8] > field[0] > type:
+desc_test_complex.proto:262:18
+desc_test_complex.proto:262:24
+
+
+ > message_type[8] > field[0] > name:
+desc_test_complex.proto:262:25
+desc_test_complex.proto:262:27
+
+
+ > message_type[8] > field[0] > number:
+desc_test_complex.proto:262:30
+desc_test_complex.proto:262:31
+
+
+ > message_type[8] > field[0] > options:
+desc_test_complex.proto:262:32
+desc_test_complex.proto:272:10
+
+
+ > message_type[8] > field[0] > options > syntax:
+desc_test_complex.proto:263:17
+desc_test_complex.proto:263:32
+
+
+ > message_type[8] > field[0] > options > import:
+desc_test_complex.proto:263:34
+desc_test_complex.proto:263:49
+
+
+ > message_type[8] > field[0] > options > public:
+desc_test_complex.proto:263:51
+desc_test_complex.proto:263:66
+
+
+ > message_type[8] > field[0] > options > weak:
+desc_test_complex.proto:263:68
+desc_test_complex.proto:263:81
+
+
+ > message_type[8] > field[0] > options > package:
+desc_test_complex.proto:263:83
+desc_test_complex.proto:263:99
+
+
+ > message_type[8] > field[0] > options > string:
+desc_test_complex.proto:264:17
+desc_test_complex.proto:264:36
+
+
+ > message_type[8] > field[0] > options > bytes:
+desc_test_complex.proto:264:38
+desc_test_complex.proto:264:55
+
+
+ > message_type[8] > field[0] > options > bool:
+desc_test_complex.proto:264:57
+desc_test_complex.proto:264:70
+
+
+ > message_type[8] > field[0] > options > float:
+desc_test_complex.proto:265:17
+desc_test_complex.proto:265:31
+
+
+ > message_type[8] > field[0] > options > double:
+desc_test_complex.proto:265:33
+desc_test_complex.proto:265:51
+
+
+ > message_type[8] > field[0] > options > int32:
+desc_test_complex.proto:266:17
+desc_test_complex.proto:266:29
+
+
+ > message_type[8] > field[0] > options > int64:
+desc_test_complex.proto:266:31
+desc_test_complex.proto:266:43
+
+
+ > message_type[8] > field[0] > options > uint32:
+desc_test_complex.proto:266:45
+desc_test_complex.proto:266:60
+
+
+ > message_type[8] > field[0] > options > uint64:
+desc_test_complex.proto:266:62
+desc_test_complex.proto:266:77
+
+
+ > message_type[8] > field[0] > options > sint32:
+desc_test_complex.proto:266:79
+desc_test_complex.proto:266:93
+
+
+ > message_type[8] > field[0] > options > sint64:
+desc_test_complex.proto:266:95
+desc_test_complex.proto:266:109
+
+
+ > message_type[8] > field[0] > options > fixed32:
+desc_test_complex.proto:267:17
+desc_test_complex.proto:267:33
+
+
+ > message_type[8] > field[0] > options > fixed64:
+desc_test_complex.proto:267:35
+desc_test_complex.proto:267:51
+
+
+ > message_type[8] > field[0] > options > sfixed32:
+desc_test_complex.proto:267:53
+desc_test_complex.proto:267:71
+
+
+ > message_type[8] > field[0] > options > sfixed64:
+desc_test_complex.proto:267:73
+desc_test_complex.proto:267:91
+
+
+ > message_type[8] > field[0] > options > optional:
+desc_test_complex.proto:268:17
+desc_test_complex.proto:268:34
+
+
+ > message_type[8] > field[0] > options > repeated:
+desc_test_complex.proto:268:36
+desc_test_complex.proto:268:53
+
+
+ > message_type[8] > field[0] > options > required:
+desc_test_complex.proto:268:55
+desc_test_complex.proto:268:72
+
+
+ > message_type[8] > field[0] > options > message:
+desc_test_complex.proto:269:17
+desc_test_complex.proto:269:33
+
+
+ > message_type[8] > field[0] > options > enum:
+desc_test_complex.proto:269:35
+desc_test_complex.proto:269:48
+
+
+ > message_type[8] > field[0] > options > service:
+desc_test_complex.proto:269:50
+desc_test_complex.proto:269:66
+
+
+ > message_type[8] > field[0] > options > rpc:
+desc_test_complex.proto:269:68
+desc_test_complex.proto:269:80
+
+
+ > message_type[8] > field[0] > options > option:
+desc_test_complex.proto:270:17
+desc_test_complex.proto:270:32
+
+
+ > message_type[8] > field[0] > options > extend:
+desc_test_complex.proto:270:34
+desc_test_complex.proto:270:49
+
+
+ > message_type[8] > field[0] > options > extensions:
+desc_test_complex.proto:270:51
+desc_test_complex.proto:270:70
+
+
+ > message_type[8] > field[0] > options > reserved:
+desc_test_complex.proto:270:72
+desc_test_complex.proto:270:89
+
+
+ > message_type[8] > field[0] > options > to:
+desc_test_complex.proto:271:17
+desc_test_complex.proto:271:28
+
+
+ > message_type[8] > field[0] > options > true:
+desc_test_complex.proto:271:30
+desc_test_complex.proto:271:42
+
+
+ > message_type[8] > field[0] > options > false:
+desc_test_complex.proto:271:44
+desc_test_complex.proto:271:58
+
+
+ > message_type[8] > field[0] > options > default:
+desc_test_complex.proto:271:60
+desc_test_complex.proto:271:75
+
+
+ > message_type[8] > field[1]:
+desc_test_complex.proto:273:9
+desc_test_complex.proto:285:11
+
+
+ > message_type[8] > field[1] > label:
+desc_test_complex.proto:273:9
+desc_test_complex.proto:273:17
+
+
+ > message_type[8] > field[1] > type:
+desc_test_complex.proto:273:18
+desc_test_complex.proto:273:24
+
+
+ > message_type[8] > field[1] > name:
+desc_test_complex.proto:273:25
+desc_test_complex.proto:273:29
+
+
+ > message_type[8] > field[1] > number:
+desc_test_complex.proto:273:32
+desc_test_complex.proto:273:33
+
+
+ > message_type[8] > field[1] > options:
+desc_test_complex.proto:273:34
+desc_test_complex.proto:285:10
+
+
+ > message_type[8] > field[1] > options > boom:
+desc_test_complex.proto:274:17
+desc_test_complex.proto:284:18
 ---- desc_test_options.proto ----
 
 
 :
 desc_test_options.proto:1:1
-desc_test_options.proto:62:34
+desc_test_options.proto:63:2
 
 
  > syntax:
@@ -942,49 +5383,54 @@
 desc_test_options.proto:5:20
 
 
- > dependency:
-desc_test_options.proto:7:1
-desc_test_options.proto:7:43
-
-
  > dependency[0]:
 desc_test_options.proto:7:1
 desc_test_options.proto:7:43
 
 
+ > extension:
+desc_test_options.proto:9:1
+desc_test_options.proto:11:2
+
+
+ > extension[0]:
+desc_test_options.proto:10:9
+desc_test_options.proto:10:38
+
+
  > extension[0] > extendee:
 desc_test_options.proto:9:8
 desc_test_options.proto:9:38
 
 
- > extension:
-desc_test_options.proto:10:2
-desc_test_options.proto:62:34
-
-
- > extension[0]:
-desc_test_options.proto:10:2
-desc_test_options.proto:10:31
-
-
  > extension[0] > label:
-desc_test_options.proto:10:2
-desc_test_options.proto:10:10
+desc_test_options.proto:10:9
+desc_test_options.proto:10:17
 
 
  > extension[0] > type:
-desc_test_options.proto:10:11
-desc_test_options.proto:10:15
-
-
- > extension[0] > name:
-desc_test_options.proto:10:16
+desc_test_options.proto:10:18
 desc_test_options.proto:10:22
 
 
+ > extension[0] > name:
+desc_test_options.proto:10:23
+desc_test_options.proto:10:29
+
+
  > extension[0] > number:
-desc_test_options.proto:10:25
-desc_test_options.proto:10:30
+desc_test_options.proto:10:32
+desc_test_options.proto:10:37
+
+
+ > extension:
+desc_test_options.proto:13:1
+desc_test_options.proto:16:2
+
+
+ > extension[1]:
+desc_test_options.proto:14:9
+desc_test_options.proto:14:40
 
 
  > extension[1] > extendee:
@@ -992,59 +5438,64 @@
 desc_test_options.proto:13:36
 
 
+ > extension[1] > label:
+desc_test_options.proto:14:9
+desc_test_options.proto:14:17
+
+
+ > extension[1] > type:
+desc_test_options.proto:14:18
+desc_test_options.proto:14:24
+
+
+ > extension[1] > name:
+desc_test_options.proto:14:25
+desc_test_options.proto:14:31
+
+
+ > extension[1] > number:
+desc_test_options.proto:14:34
+desc_test_options.proto:14:39
+
+
+ > extension[2]:
+desc_test_options.proto:15:9
+desc_test_options.proto:15:40
+
+
  > extension[2] > extendee:
 desc_test_options.proto:13:8
 desc_test_options.proto:13:36
 
 
- > extension[1]:
-desc_test_options.proto:14:2
-desc_test_options.proto:14:33
-
-
- > extension[1] > label:
-desc_test_options.proto:14:2
-desc_test_options.proto:14:10
-
-
- > extension[1] > type:
-desc_test_options.proto:14:11
-desc_test_options.proto:14:17
-
-
- > extension[1] > name:
-desc_test_options.proto:14:18
-desc_test_options.proto:14:24
-
-
- > extension[1] > number:
-desc_test_options.proto:14:27
-desc_test_options.proto:14:32
-
-
- > extension[2]:
-desc_test_options.proto:15:2
-desc_test_options.proto:15:33
-
-
  > extension[2] > label:
-desc_test_options.proto:15:2
-desc_test_options.proto:15:10
+desc_test_options.proto:15:9
+desc_test_options.proto:15:17
 
 
  > extension[2] > type:
-desc_test_options.proto:15:11
-desc_test_options.proto:15:16
+desc_test_options.proto:15:18
+desc_test_options.proto:15:23
 
 
  > extension[2] > name:
-desc_test_options.proto:15:17
 desc_test_options.proto:15:24
+desc_test_options.proto:15:31
 
 
  > extension[2] > number:
-desc_test_options.proto:15:27
-desc_test_options.proto:15:32
+desc_test_options.proto:15:34
+desc_test_options.proto:15:39
+
+
+ > extension:
+desc_test_options.proto:18:1
+desc_test_options.proto:24:2
+
+
+ > extension[3]:
+desc_test_options.proto:19:9
+desc_test_options.proto:19:39
 
 
  > extension[3] > extendee:
@@ -1052,149 +5503,154 @@
 desc_test_options.proto:18:35
 
 
+ > extension[3] > label:
+desc_test_options.proto:19:9
+desc_test_options.proto:19:17
+
+
+ > extension[3] > type:
+desc_test_options.proto:19:18
+desc_test_options.proto:19:23
+
+
+ > extension[3] > name:
+desc_test_options.proto:19:24
+desc_test_options.proto:19:30
+
+
+ > extension[3] > number:
+desc_test_options.proto:19:33
+desc_test_options.proto:19:38
+
+
+ > extension[4]:
+desc_test_options.proto:20:9
+desc_test_options.proto:20:41
+
+
  > extension[4] > extendee:
 desc_test_options.proto:18:8
 desc_test_options.proto:18:35
 
 
+ > extension[4] > label:
+desc_test_options.proto:20:9
+desc_test_options.proto:20:17
+
+
+ > extension[4] > type:
+desc_test_options.proto:20:18
+desc_test_options.proto:20:24
+
+
+ > extension[4] > name:
+desc_test_options.proto:20:25
+desc_test_options.proto:20:32
+
+
+ > extension[4] > number:
+desc_test_options.proto:20:35
+desc_test_options.proto:20:40
+
+
+ > extension[5]:
+desc_test_options.proto:21:9
+desc_test_options.proto:21:44
+
+
  > extension[5] > extendee:
 desc_test_options.proto:18:8
 desc_test_options.proto:18:35
 
 
+ > extension[5] > label:
+desc_test_options.proto:21:9
+desc_test_options.proto:21:17
+
+
+ > extension[5] > type:
+desc_test_options.proto:21:18
+desc_test_options.proto:21:26
+
+
+ > extension[5] > name:
+desc_test_options.proto:21:27
+desc_test_options.proto:21:35
+
+
+ > extension[5] > number:
+desc_test_options.proto:21:38
+desc_test_options.proto:21:43
+
+
+ > extension[6]:
+desc_test_options.proto:22:9
+desc_test_options.proto:22:41
+
+
  > extension[6] > extendee:
 desc_test_options.proto:18:8
 desc_test_options.proto:18:35
 
 
+ > extension[6] > label:
+desc_test_options.proto:22:9
+desc_test_options.proto:22:17
+
+
+ > extension[6] > type:
+desc_test_options.proto:22:18
+desc_test_options.proto:22:24
+
+
+ > extension[6] > name:
+desc_test_options.proto:22:25
+desc_test_options.proto:22:32
+
+
+ > extension[6] > number:
+desc_test_options.proto:22:35
+desc_test_options.proto:22:40
+
+
+ > extension[7]:
+desc_test_options.proto:23:9
+desc_test_options.proto:23:43
+
+
  > extension[7] > extendee:
 desc_test_options.proto:18:8
 desc_test_options.proto:18:35
 
 
- > extension[3]:
-desc_test_options.proto:19:2
-desc_test_options.proto:19:32
-
-
- > extension[3] > label:
-desc_test_options.proto:19:2
-desc_test_options.proto:19:10
-
-
- > extension[3] > type:
-desc_test_options.proto:19:11
-desc_test_options.proto:19:16
-
-
- > extension[3] > name:
-desc_test_options.proto:19:17
-desc_test_options.proto:19:23
-
-
- > extension[3] > number:
-desc_test_options.proto:19:26
-desc_test_options.proto:19:31
-
-
- > extension[4]:
-desc_test_options.proto:20:2
-desc_test_options.proto:20:34
-
-
- > extension[4] > label:
-desc_test_options.proto:20:2
-desc_test_options.proto:20:10
-
-
- > extension[4] > type:
-desc_test_options.proto:20:11
-desc_test_options.proto:20:17
-
-
- > extension[4] > name:
-desc_test_options.proto:20:18
-desc_test_options.proto:20:25
-
-
- > extension[4] > number:
-desc_test_options.proto:20:28
-desc_test_options.proto:20:33
-
-
- > extension[5]:
-desc_test_options.proto:21:2
-desc_test_options.proto:21:37
-
-
- > extension[5] > label:
-desc_test_options.proto:21:2
-desc_test_options.proto:21:10
-
-
- > extension[5] > type:
-desc_test_options.proto:21:11
-desc_test_options.proto:21:19
-
-
- > extension[5] > name:
-desc_test_options.proto:21:20
-desc_test_options.proto:21:28
-
-
- > extension[5] > number:
-desc_test_options.proto:21:31
-desc_test_options.proto:21:36
-
-
- > extension[6]:
-desc_test_options.proto:22:2
-desc_test_options.proto:22:34
-
-
- > extension[6] > label:
-desc_test_options.proto:22:2
-desc_test_options.proto:22:10
-
-
- > extension[6] > type:
-desc_test_options.proto:22:11
-desc_test_options.proto:22:17
-
-
- > extension[6] > name:
-desc_test_options.proto:22:18
-desc_test_options.proto:22:25
-
-
- > extension[6] > number:
-desc_test_options.proto:22:28
-desc_test_options.proto:22:33
-
-
- > extension[7]:
-desc_test_options.proto:23:2
-desc_test_options.proto:23:36
-
-
  > extension[7] > label:
-desc_test_options.proto:23:2
-desc_test_options.proto:23:10
+desc_test_options.proto:23:9
+desc_test_options.proto:23:17
 
 
  > extension[7] > type:
-desc_test_options.proto:23:11
 desc_test_options.proto:23:18
+desc_test_options.proto:23:25
 
 
  > extension[7] > name:
-desc_test_options.proto:23:19
-desc_test_options.proto:23:27
+desc_test_options.proto:23:26
+desc_test_options.proto:23:34
 
 
  > extension[7] > number:
-desc_test_options.proto:23:30
-desc_test_options.proto:23:35
+desc_test_options.proto:23:37
+desc_test_options.proto:23:42
+
+
+ > extension:
+desc_test_options.proto:26:1
+desc_test_options.proto:32:2
+
+
+ > extension[8]:
+desc_test_options.proto:27:9
+desc_test_options.proto:27:40
 
 
  > extension[8] > extendee:
@@ -1202,149 +5658,154 @@
 desc_test_options.proto:26:40
 
 
+ > extension[8] > label:
+desc_test_options.proto:27:9
+desc_test_options.proto:27:17
+
+
+ > extension[8] > type:
+desc_test_options.proto:27:18
+desc_test_options.proto:27:23
+
+
+ > extension[8] > name:
+desc_test_options.proto:27:24
+desc_test_options.proto:27:31
+
+
+ > extension[8] > number:
+desc_test_options.proto:27:34
+desc_test_options.proto:27:39
+
+
+ > extension[9]:
+desc_test_options.proto:28:9
+desc_test_options.proto:28:42
+
+
  > extension[9] > extendee:
 desc_test_options.proto:26:8
 desc_test_options.proto:26:40
 
 
+ > extension[9] > label:
+desc_test_options.proto:28:9
+desc_test_options.proto:28:17
+
+
+ > extension[9] > type:
+desc_test_options.proto:28:18
+desc_test_options.proto:28:24
+
+
+ > extension[9] > name:
+desc_test_options.proto:28:25
+desc_test_options.proto:28:33
+
+
+ > extension[9] > number:
+desc_test_options.proto:28:36
+desc_test_options.proto:28:41
+
+
+ > extension[10]:
+desc_test_options.proto:29:9
+desc_test_options.proto:29:45
+
+
  > extension[10] > extendee:
 desc_test_options.proto:26:8
 desc_test_options.proto:26:40
 
 
+ > extension[10] > label:
+desc_test_options.proto:29:9
+desc_test_options.proto:29:17
+
+
+ > extension[10] > type:
+desc_test_options.proto:29:18
+desc_test_options.proto:29:26
+
+
+ > extension[10] > name:
+desc_test_options.proto:29:27
+desc_test_options.proto:29:36
+
+
+ > extension[10] > number:
+desc_test_options.proto:29:39
+desc_test_options.proto:29:44
+
+
+ > extension[11]:
+desc_test_options.proto:30:9
+desc_test_options.proto:30:42
+
+
  > extension[11] > extendee:
 desc_test_options.proto:26:8
 desc_test_options.proto:26:40
 
 
+ > extension[11] > label:
+desc_test_options.proto:30:9
+desc_test_options.proto:30:17
+
+
+ > extension[11] > type:
+desc_test_options.proto:30:18
+desc_test_options.proto:30:24
+
+
+ > extension[11] > name:
+desc_test_options.proto:30:25
+desc_test_options.proto:30:33
+
+
+ > extension[11] > number:
+desc_test_options.proto:30:36
+desc_test_options.proto:30:41
+
+
+ > extension[12]:
+desc_test_options.proto:31:9
+desc_test_options.proto:31:44
+
+
  > extension[12] > extendee:
 desc_test_options.proto:26:8
 desc_test_options.proto:26:40
 
 
- > extension[8]:
-desc_test_options.proto:27:2
-desc_test_options.proto:27:33
-
-
- > extension[8] > label:
-desc_test_options.proto:27:2
-desc_test_options.proto:27:10
-
-
- > extension[8] > type:
-desc_test_options.proto:27:11
-desc_test_options.proto:27:16
-
-
- > extension[8] > name:
-desc_test_options.proto:27:17
-desc_test_options.proto:27:24
-
-
- > extension[8] > number:
-desc_test_options.proto:27:27
-desc_test_options.proto:27:32
-
-
- > extension[9]:
-desc_test_options.proto:28:2
-desc_test_options.proto:28:35
-
-
- > extension[9] > label:
-desc_test_options.proto:28:2
-desc_test_options.proto:28:10
-
-
- > extension[9] > type:
-desc_test_options.proto:28:11
-desc_test_options.proto:28:17
-
-
- > extension[9] > name:
-desc_test_options.proto:28:18
-desc_test_options.proto:28:26
-
-
- > extension[9] > number:
-desc_test_options.proto:28:29
-desc_test_options.proto:28:34
-
-
- > extension[10]:
-desc_test_options.proto:29:2
-desc_test_options.proto:29:38
-
-
- > extension[10] > label:
-desc_test_options.proto:29:2
-desc_test_options.proto:29:10
-
-
- > extension[10] > type:
-desc_test_options.proto:29:11
-desc_test_options.proto:29:19
-
-
- > extension[10] > name:
-desc_test_options.proto:29:20
-desc_test_options.proto:29:29
-
-
- > extension[10] > number:
-desc_test_options.proto:29:32
-desc_test_options.proto:29:37
-
-
- > extension[11]:
-desc_test_options.proto:30:2
-desc_test_options.proto:30:35
-
-
- > extension[11] > label:
-desc_test_options.proto:30:2
-desc_test_options.proto:30:10
-
-
- > extension[11] > type:
-desc_test_options.proto:30:11
-desc_test_options.proto:30:17
-
-
- > extension[11] > name:
-desc_test_options.proto:30:18
-desc_test_options.proto:30:26
-
-
- > extension[11] > number:
-desc_test_options.proto:30:29
-desc_test_options.proto:30:34
-
-
- > extension[12]:
-desc_test_options.proto:31:2
-desc_test_options.proto:31:37
-
-
  > extension[12] > label:
-desc_test_options.proto:31:2
-desc_test_options.proto:31:10
+desc_test_options.proto:31:9
+desc_test_options.proto:31:17
 
 
  > extension[12] > type:
-desc_test_options.proto:31:11
 desc_test_options.proto:31:18
+desc_test_options.proto:31:25
 
 
  > extension[12] > name:
-desc_test_options.proto:31:19
-desc_test_options.proto:31:28
+desc_test_options.proto:31:26
+desc_test_options.proto:31:35
 
 
  > extension[12] > number:
-desc_test_options.proto:31:31
-desc_test_options.proto:31:36
+desc_test_options.proto:31:38
+desc_test_options.proto:31:43
+
+
+ > extension:
+desc_test_options.proto:34:1
+desc_test_options.proto:37:2
+
+
+ > extension[13]:
+desc_test_options.proto:35:9
+desc_test_options.proto:35:53
 
 
  > extension[13] > extendee:
@@ -1352,59 +5813,64 @@
 desc_test_options.proto:34:38
 
 
+ > extension[13] > label:
+desc_test_options.proto:35:9
+desc_test_options.proto:35:17
+
+
+ > extension[13] > type_name:
+desc_test_options.proto:35:18
+desc_test_options.proto:35:37
+
+
+ > extension[13] > name:
+desc_test_options.proto:35:38
+desc_test_options.proto:35:44
+
+
+ > extension[13] > number:
+desc_test_options.proto:35:47
+desc_test_options.proto:35:52
+
+
+ > extension[14]:
+desc_test_options.proto:36:9
+desc_test_options.proto:36:51
+
+
  > extension[14] > extendee:
 desc_test_options.proto:34:8
 desc_test_options.proto:34:38
 
 
- > extension[13]:
-desc_test_options.proto:35:2
-desc_test_options.proto:35:46
-
-
- > extension[13] > label:
-desc_test_options.proto:35:2
-desc_test_options.proto:35:10
-
-
- > extension[13] > type:
-desc_test_options.proto:35:11
-desc_test_options.proto:35:30
-
-
- > extension[13] > name:
-desc_test_options.proto:35:31
-desc_test_options.proto:35:37
-
-
- > extension[13] > number:
-desc_test_options.proto:35:40
-desc_test_options.proto:35:45
-
-
- > extension[14]:
-desc_test_options.proto:36:2
-desc_test_options.proto:36:44
-
-
  > extension[14] > label:
-desc_test_options.proto:36:2
-desc_test_options.proto:36:10
+desc_test_options.proto:36:9
+desc_test_options.proto:36:17
 
 
- > extension[14] > type:
-desc_test_options.proto:36:11
-desc_test_options.proto:36:27
+ > extension[14] > type_name:
+desc_test_options.proto:36:18
+desc_test_options.proto:36:34
 
 
  > extension[14] > name:
-desc_test_options.proto:36:28
 desc_test_options.proto:36:35
+desc_test_options.proto:36:42
 
 
  > extension[14] > number:
-desc_test_options.proto:36:38
-desc_test_options.proto:36:43
+desc_test_options.proto:36:45
+desc_test_options.proto:36:50
+
+
+ > extension:
+desc_test_options.proto:39:1
+desc_test_options.proto:42:2
+
+
+ > extension[15]:
+desc_test_options.proto:40:9
+desc_test_options.proto:40:40
 
 
  > extension[15] > extendee:
@@ -1412,64 +5878,54 @@
 desc_test_options.proto:39:37
 
 
+ > extension[15] > label:
+desc_test_options.proto:40:9
+desc_test_options.proto:40:17
+
+
+ > extension[15] > type:
+desc_test_options.proto:40:18
+desc_test_options.proto:40:23
+
+
+ > extension[15] > name:
+desc_test_options.proto:40:24
+desc_test_options.proto:40:31
+
+
+ > extension[15] > number:
+desc_test_options.proto:40:34
+desc_test_options.proto:40:39
+
+
+ > extension[16]:
+desc_test_options.proto:41:9
+desc_test_options.proto:41:42
+
+
  > extension[16] > extendee:
 desc_test_options.proto:39:8
 desc_test_options.proto:39:37
 
 
- > extension[15]:
-desc_test_options.proto:40:2
-desc_test_options.proto:40:33
-
-
- > extension[15] > label:
-desc_test_options.proto:40:2
-desc_test_options.proto:40:10
-
-
- > extension[15] > type:
-desc_test_options.proto:40:11
-desc_test_options.proto:40:16
-
-
- > extension[15] > name:
-desc_test_options.proto:40:17
-desc_test_options.proto:40:24
-
-
- > extension[15] > number:
-desc_test_options.proto:40:27
-desc_test_options.proto:40:32
-
-
- > extension[16]:
-desc_test_options.proto:41:2
-desc_test_options.proto:41:35
-
-
  > extension[16] > label:
-desc_test_options.proto:41:2
-desc_test_options.proto:41:10
-
-
- > extension[16] > type:
-desc_test_options.proto:41:11
+desc_test_options.proto:41:9
 desc_test_options.proto:41:17
 
 
- > extension[16] > name:
+ > extension[16] > type:
 desc_test_options.proto:41:18
-desc_test_options.proto:41:26
+desc_test_options.proto:41:24
+
+
+ > extension[16] > name:
+desc_test_options.proto:41:25
+desc_test_options.proto:41:33
 
 
  > extension[16] > number:
-desc_test_options.proto:41:29
-desc_test_options.proto:41:34
-
-
- > message_type:
-desc_test_options.proto:45:1
-desc_test_options.proto:48:2
+desc_test_options.proto:41:36
+desc_test_options.proto:41:41
 
 
  > message_type[0]:
@@ -1479,69 +5935,60 @@
  Test message used by custom options
 
 
+
  > message_type[0] > name:
 desc_test_options.proto:45:9
 desc_test_options.proto:45:28
 
 
- > message_type[0] > field:
-desc_test_options.proto:46:2
-desc_test_options.proto:47:27
-
-
  > message_type[0] > field[0]:
-desc_test_options.proto:46:2
-desc_test_options.proto:46:25
+desc_test_options.proto:46:9
+desc_test_options.proto:46:32
 
 
  > message_type[0] > field[0] > label:
-desc_test_options.proto:46:2
-desc_test_options.proto:46:10
-
-
- > message_type[0] > field[0] > type:
-desc_test_options.proto:46:11
+desc_test_options.proto:46:9
 desc_test_options.proto:46:17
 
 
- > message_type[0] > field[0] > name:
+ > message_type[0] > field[0] > type:
 desc_test_options.proto:46:18
-desc_test_options.proto:46:20
-
-
- > message_type[0] > field[0] > number:
-desc_test_options.proto:46:23
 desc_test_options.proto:46:24
 
 
+ > message_type[0] > field[0] > name:
+desc_test_options.proto:46:25
+desc_test_options.proto:46:27
+
+
+ > message_type[0] > field[0] > number:
+desc_test_options.proto:46:30
+desc_test_options.proto:46:31
+
+
  > message_type[0] > field[1]:
-desc_test_options.proto:47:2
-desc_test_options.proto:47:27
+desc_test_options.proto:47:9
+desc_test_options.proto:47:34
 
 
  > message_type[0] > field[1] > label:
-desc_test_options.proto:47:2
-desc_test_options.proto:47:10
-
-
- > message_type[0] > field[1] > type:
-desc_test_options.proto:47:11
+desc_test_options.proto:47:9
 desc_test_options.proto:47:17
 
 
- > message_type[0] > field[1] > name:
+ > message_type[0] > field[1] > type:
 desc_test_options.proto:47:18
-desc_test_options.proto:47:22
+desc_test_options.proto:47:24
+
+
+ > message_type[0] > field[1] > name:
+desc_test_options.proto:47:25
+desc_test_options.proto:47:29
 
 
  > message_type[0] > field[1] > number:
-desc_test_options.proto:47:25
-desc_test_options.proto:47:26
-
-
- > enum_type:
-desc_test_options.proto:51:1
-desc_test_options.proto:53:2
+desc_test_options.proto:47:32
+desc_test_options.proto:47:33
 
 
  > enum_type[0]:
@@ -1551,29 +5998,35 @@
  Test enum used by custom options
 
 
+
  > enum_type[0] > name:
 desc_test_options.proto:51:6
 desc_test_options.proto:51:22
 
 
- > enum_type[0] > value:
-desc_test_options.proto:52:2
-desc_test_options.proto:52:12
-
-
  > enum_type[0] > value[0]:
-desc_test_options.proto:52:2
-desc_test_options.proto:52:12
+desc_test_options.proto:52:9
+desc_test_options.proto:52:19
 
 
  > enum_type[0] > value[0] > name:
-desc_test_options.proto:52:2
-desc_test_options.proto:52:7
+desc_test_options.proto:52:9
+desc_test_options.proto:52:14
 
 
  > enum_type[0] > value[0] > number:
-desc_test_options.proto:52:10
-desc_test_options.proto:52:11
+desc_test_options.proto:52:17
+desc_test_options.proto:52:18
+
+
+ > extension:
+desc_test_options.proto:55:1
+desc_test_options.proto:58:2
+
+
+ > extension[17]:
+desc_test_options.proto:56:9
+desc_test_options.proto:56:41
 
 
  > extension[17] > extendee:
@@ -1581,59 +6034,64 @@
 desc_test_options.proto:55:45
 
 
+ > extension[17] > label:
+desc_test_options.proto:56:9
+desc_test_options.proto:56:17
+
+
+ > extension[17] > type:
+desc_test_options.proto:56:18
+desc_test_options.proto:56:24
+
+
+ > extension[17] > name:
+desc_test_options.proto:56:25
+desc_test_options.proto:56:32
+
+
+ > extension[17] > number:
+desc_test_options.proto:56:35
+desc_test_options.proto:56:40
+
+
+ > extension[18]:
+desc_test_options.proto:57:9
+desc_test_options.proto:57:41
+
+
  > extension[18] > extendee:
 desc_test_options.proto:55:8
 desc_test_options.proto:55:45
 
 
- > extension[17]:
-desc_test_options.proto:56:2
-desc_test_options.proto:56:34
-
-
- > extension[17] > label:
-desc_test_options.proto:56:2
-desc_test_options.proto:56:10
-
-
- > extension[17] > type:
-desc_test_options.proto:56:11
-desc_test_options.proto:56:17
-
-
- > extension[17] > name:
-desc_test_options.proto:56:18
-desc_test_options.proto:56:25
-
-
- > extension[17] > number:
-desc_test_options.proto:56:28
-desc_test_options.proto:56:33
-
-
- > extension[18]:
-desc_test_options.proto:57:2
-desc_test_options.proto:57:34
-
-
  > extension[18] > label:
-desc_test_options.proto:57:2
-desc_test_options.proto:57:10
+desc_test_options.proto:57:9
+desc_test_options.proto:57:17
 
 
  > extension[18] > type:
-desc_test_options.proto:57:11
-desc_test_options.proto:57:16
+desc_test_options.proto:57:18
+desc_test_options.proto:57:23
 
 
  > extension[18] > name:
-desc_test_options.proto:57:17
-desc_test_options.proto:57:25
+desc_test_options.proto:57:24
+desc_test_options.proto:57:32
 
 
  > extension[18] > number:
-desc_test_options.proto:57:28
-desc_test_options.proto:57:33
+desc_test_options.proto:57:35
+desc_test_options.proto:57:40
+
+
+ > extension:
+desc_test_options.proto:60:1
+desc_test_options.proto:63:2
+
+
+ > extension[19]:
+desc_test_options.proto:61:9
+desc_test_options.proto:61:41
 
 
  > extension[19] > extendee:
@@ -1641,56 +6099,51 @@
 desc_test_options.proto:60:36
 
 
+ > extension[19] > label:
+desc_test_options.proto:61:9
+desc_test_options.proto:61:17
+
+
+ > extension[19] > type:
+desc_test_options.proto:61:18
+desc_test_options.proto:61:24
+
+
+ > extension[19] > name:
+desc_test_options.proto:61:25
+desc_test_options.proto:61:32
+
+
+ > extension[19] > number:
+desc_test_options.proto:61:35
+desc_test_options.proto:61:40
+
+
+ > extension[20]:
+desc_test_options.proto:62:9
+desc_test_options.proto:62:41
+
+
  > extension[20] > extendee:
 desc_test_options.proto:60:8
 desc_test_options.proto:60:36
 
 
- > extension[19]:
-desc_test_options.proto:61:2
-desc_test_options.proto:61:34
-
-
- > extension[19] > label:
-desc_test_options.proto:61:2
-desc_test_options.proto:61:10
-
-
- > extension[19] > type:
-desc_test_options.proto:61:11
-desc_test_options.proto:61:17
-
-
- > extension[19] > name:
-desc_test_options.proto:61:18
-desc_test_options.proto:61:25
-
-
- > extension[19] > number:
-desc_test_options.proto:61:28
-desc_test_options.proto:61:33
-
-
- > extension[20]:
-desc_test_options.proto:62:2
-desc_test_options.proto:62:34
-
-
  > extension[20] > label:
-desc_test_options.proto:62:2
-desc_test_options.proto:62:10
+desc_test_options.proto:62:9
+desc_test_options.proto:62:17
 
 
  > extension[20] > type:
-desc_test_options.proto:62:11
-desc_test_options.proto:62:16
+desc_test_options.proto:62:18
+desc_test_options.proto:62:23
 
 
  > extension[20] > name:
-desc_test_options.proto:62:17
-desc_test_options.proto:62:25
+desc_test_options.proto:62:24
+desc_test_options.proto:62:32
 
 
  > extension[20] > number:
-desc_test_options.proto:62:28
-desc_test_options.proto:62:33
+desc_test_options.proto:62:35
+desc_test_options.proto:62:40
diff --git a/vendor/github.com/jhump/protoreflect/desc/protoprint/print.go b/vendor/github.com/jhump/protoreflect/desc/protoprint/print.go
index d8f7f22..0363cf0 100644
--- a/vendor/github.com/jhump/protoreflect/desc/protoprint/print.go
+++ b/vendor/github.com/jhump/protoreflect/desc/protoprint/print.go
@@ -94,7 +94,7 @@
 	TrailingCommentsOnSeparateLine bool
 
 	// If true, the printed output will eschew any blank lines, which otherwise
-	// appear between descriptor elements and comment blocks. Note that this if
+	// appear between descriptor elements and comment blocks. Note that if
 	// detached comments are being printed, this will cause them to be merged
 	// into the subsequent leading comments. Similarly, any element trailing
 	// comments will be merged into the subsequent leading comments.
@@ -266,7 +266,7 @@
 	mf := dynamic.NewMessageFactoryWithExtensionRegistry(&er)
 	fdp := dsc.GetFile().AsFileDescriptorProto()
 	sourceInfo := internal.CreateSourceInfoMap(fdp)
-	extendOptionLocations(sourceInfo)
+	extendOptionLocations(sourceInfo, fdp.GetSourceCodeInfo().GetLocation())
 
 	path := findElement(dsc)
 	switch d := dsc.(type) {
@@ -449,6 +449,8 @@
 	})
 	p.newLine(w)
 
+	skip := map[interface{}]bool{}
+
 	elements := elementAddrs{dsc: fd, opts: opts}
 	if fdp.Package != nil {
 		elements.addrs = append(elements.addrs, elementAddr{elementType: internal.File_packageTag, elementIndex: 0, order: -3})
@@ -466,7 +468,13 @@
 	for i := range fd.GetServices() {
 		elements.addrs = append(elements.addrs, elementAddr{elementType: internal.File_servicesTag, elementIndex: i})
 	}
-	for i := range fd.GetExtensions() {
+	exts := p.computeExtensions(sourceInfo, fd.GetExtensions(), []int32{internal.File_extensionsTag})
+	for i, extd := range fd.GetExtensions() {
+		if extd.GetType() == descriptor.FieldDescriptorProto_TYPE_GROUP {
+			// we don't emit nested messages for groups since
+			// they get special treatment
+			skip[extd.GetMessageType()] = true
+		}
 		elements.addrs = append(elements.addrs, elementAddr{elementType: internal.File_extensionsTag, elementIndex: i})
 	}
 
@@ -474,69 +482,123 @@
 
 	pkgName := fd.GetPackage()
 
-	var ext *desc.FieldDescriptor
 	for i, el := range elements.addrs {
 		d := elements.at(el)
+
+		// skip[d] will panic if d is a slice (which it could be for []option),
+		// so just ignore it since we don't try to skip options
+		if reflect.TypeOf(d).Kind() != reflect.Slice && skip[d] {
+			// skip this element
+			continue
+		}
+
+		if i > 0 {
+			p.newLine(w)
+		}
+
 		path = []int32{el.elementType, int32(el.elementIndex)}
-		if el.elementType == internal.File_extensionsTag {
-			fld := d.(*desc.FieldDescriptor)
-			if ext == nil || ext.GetOwner() != fld.GetOwner() {
-				// need to open a new extend block
-				if ext != nil {
-					// close preceding extend block
-					fmt.Fprintln(w, "}")
-				}
-				if i > 0 {
-					p.newLine(w)
-				}
 
-				ext = fld
-				fmt.Fprint(w, "extend ")
-				extNameSi := sourceInfo.Get(append(path, internal.Field_extendeeTag))
-				p.printElementString(extNameSi, w, 0, p.qualifyName(pkgName, pkgName, fld.GetOwner().GetFullyQualifiedName()))
-				fmt.Fprintln(w, "{")
-			} else {
-				p.newLine(w)
-			}
-			p.printField(fld, mf, w, sourceInfo, path, pkgName, 1)
-		} else {
-			if ext != nil {
-				// close preceding extend block
-				fmt.Fprintln(w, "}")
-				ext = nil
-			}
-
-			if i > 0 {
-				p.newLine(w)
-			}
-
-			switch d := d.(type) {
-			case pkg:
-				si := sourceInfo.Get(path)
-				p.printElement(false, si, w, 0, func(w *writer) {
-					fmt.Fprintf(w, "package %s;", d)
-				})
-			case imp:
-				si := sourceInfo.Get(path)
-				p.printElement(false, si, w, 0, func(w *writer) {
-					fmt.Fprintf(w, "import %q;", d)
-				})
-			case []option:
-				p.printOptionsLong(d, w, sourceInfo, path, 0)
-			case *desc.MessageDescriptor:
-				p.printMessage(d, mf, w, sourceInfo, path, 0)
-			case *desc.EnumDescriptor:
-				p.printEnum(d, mf, w, sourceInfo, path, 0)
-			case *desc.ServiceDescriptor:
-				p.printService(d, mf, w, sourceInfo, path, 0)
+		switch d := d.(type) {
+		case pkg:
+			si := sourceInfo.Get(path)
+			p.printElement(false, si, w, 0, func(w *writer) {
+				fmt.Fprintf(w, "package %s;", d)
+			})
+		case imp:
+			si := sourceInfo.Get(path)
+			p.printElement(false, si, w, 0, func(w *writer) {
+				fmt.Fprintf(w, "import %q;", d)
+			})
+		case []option:
+			p.printOptionsLong(d, w, sourceInfo, path, 0)
+		case *desc.MessageDescriptor:
+			p.printMessage(d, mf, w, sourceInfo, path, 0)
+		case *desc.EnumDescriptor:
+			p.printEnum(d, mf, w, sourceInfo, path, 0)
+		case *desc.ServiceDescriptor:
+			p.printService(d, mf, w, sourceInfo, path, 0)
+		case *desc.FieldDescriptor:
+			extDecl := exts[d]
+			p.printExtensions(extDecl, exts, elements, i, mf, w, sourceInfo, nil, internal.File_extensionsTag, pkgName, pkgName, 0)
+			// we printed all extensions in the group, so we can skip the others
+			for _, fld := range extDecl.fields {
+				skip[fld] = true
 			}
 		}
 	}
+}
 
-	if ext != nil {
-		// close trailing extend block
-		fmt.Fprintln(w, "}")
+func findExtSi(fieldSi *descriptor.SourceCodeInfo_Location, extSis []*descriptor.SourceCodeInfo_Location) *descriptor.SourceCodeInfo_Location {
+	if len(fieldSi.GetSpan()) == 0 {
+		return nil
 	}
+	for _, extSi := range extSis {
+		if isSpanWithin(fieldSi.Span, extSi.Span) {
+			return extSi
+		}
+	}
+	return nil
+}
+
+func isSpanWithin(span, enclosing []int32) bool {
+	start := enclosing[0]
+	var end int32
+	if len(enclosing) == 3 {
+		end = enclosing[0]
+	} else {
+		end = enclosing[2]
+	}
+	if span[0] < start || span[0] > end {
+		return false
+	}
+
+	if span[0] == start {
+		return span[1] >= enclosing[1]
+	} else if span[0] == end {
+		return span[1] <= enclosing[len(enclosing)-1]
+	}
+	return true
+}
+
+type extensionDecl struct {
+	extendee   string
+	sourceInfo *descriptor.SourceCodeInfo_Location
+	fields     []*desc.FieldDescriptor
+}
+
+type extensions map[*desc.FieldDescriptor]*extensionDecl
+
+func (p *Printer) computeExtensions(sourceInfo internal.SourceInfoMap, exts []*desc.FieldDescriptor, path []int32) extensions {
+	extsMap := map[string]map[*descriptor.SourceCodeInfo_Location]*extensionDecl{}
+	extSis := sourceInfo.GetAll(path)
+	for _, extd := range exts {
+		name := extd.GetOwner().GetFullyQualifiedName()
+		extSi := findExtSi(extd.GetSourceInfo(), extSis)
+		extsBySi := extsMap[name]
+		if extsBySi == nil {
+			extsBySi = map[*descriptor.SourceCodeInfo_Location]*extensionDecl{}
+			extsMap[name] = extsBySi
+		}
+		extDecl := extsBySi[extSi]
+		if extDecl == nil {
+			extDecl = &extensionDecl{
+				sourceInfo: extSi,
+				extendee:   name,
+			}
+			extsBySi[extSi] = extDecl
+		}
+		extDecl.fields = append(extDecl.fields, extd)
+	}
+
+	ret := extensions{}
+	for _, extsBySi := range extsMap {
+		for _, extDecl := range extsBySi {
+			for _, extd := range extDecl.fields {
+				ret[extd] = extDecl
+			}
+		}
+	}
+	return ret
 }
 
 func (p *Printer) sort(elements elementAddrs, sourceInfo internal.SourceInfoMap, path []int32) {
@@ -680,7 +742,13 @@
 	for i := range md.GetNestedEnumTypes() {
 		elements.addrs = append(elements.addrs, elementAddr{elementType: internal.Message_enumsTag, elementIndex: i})
 	}
-	for i := range md.GetNestedExtensions() {
+	exts := p.computeExtensions(sourceInfo, md.GetNestedExtensions(), append(path, internal.Message_extensionsTag))
+	for i, extd := range md.GetNestedExtensions() {
+		if extd.GetType() == descriptor.FieldDescriptorProto_TYPE_GROUP {
+			// we don't emit nested messages for groups since
+			// they get special treatment
+			skip[extd.GetMessageType()] = true
+		}
 		elements.addrs = append(elements.addrs, elementAddr{elementType: internal.Message_extensionsTag, elementIndex: i})
 	}
 
@@ -689,9 +757,9 @@
 	pkg := md.GetFile().GetPackage()
 	scope := md.GetFullyQualifiedName()
 
-	var ext *desc.FieldDescriptor
 	for i, el := range elements.addrs {
 		d := elements.at(el)
+
 		// skip[d] will panic if d is a slice (which it could be for []option),
 		// so just ignore it since we don't try to skip options
 		if reflect.TypeOf(d).Kind() != reflect.Slice && skip[d] {
@@ -699,116 +767,89 @@
 			continue
 		}
 
+		if i > 0 {
+			p.newLine(w)
+		}
+
 		childPath := append(path, el.elementType, int32(el.elementIndex))
-		if el.elementType == internal.Message_extensionsTag {
-			// extension
-			fld := d.(*desc.FieldDescriptor)
-			if ext == nil || ext.GetOwner() != fld.GetOwner() {
-				// need to open a new extend block
-				if ext != nil {
-					// close preceding extend block
-					p.indent(w, indent)
-					fmt.Fprintln(w, "}")
-				}
-				if i > 0 {
-					p.newLine(w)
-				}
 
-				ext = fld
-				p.indent(w, indent)
-				fmt.Fprint(w, "extend ")
-				extNameSi := sourceInfo.Get(append(childPath, internal.Field_extendeeTag))
-				p.printElementString(extNameSi, w, indent, p.qualifyName(pkg, scope, fld.GetOwner().GetFullyQualifiedName()))
-				fmt.Fprintln(w, "{")
+		switch d := d.(type) {
+		case []option:
+			p.printOptionsLong(d, w, sourceInfo, childPath, indent)
+		case *desc.FieldDescriptor:
+			if d.IsExtension() {
+				extDecl := exts[d]
+				p.printExtensions(extDecl, exts, elements, i, mf, w, sourceInfo, path, internal.Message_extensionsTag, pkg, scope, indent)
+				// we printed all extensions in the group, so we can skip the others
+				for _, fld := range extDecl.fields {
+					skip[fld] = true
+				}
 			} else {
-				p.newLine(w)
-			}
-			p.printField(fld, mf, w, sourceInfo, childPath, scope, indent+1)
-		} else {
-			if ext != nil {
-				// close preceding extend block
-				p.indent(w, indent)
-				fmt.Fprintln(w, "}")
-				ext = nil
-			}
-
-			if i > 0 {
-				p.newLine(w)
-			}
-
-			switch d := d.(type) {
-			case []option:
-				p.printOptionsLong(d, w, sourceInfo, childPath, indent)
-			case *desc.FieldDescriptor:
 				ood := d.GetOneOf()
 				if ood == nil {
 					p.printField(d, mf, w, sourceInfo, childPath, scope, indent)
-				} else if !skip[ood] {
+				} else {
 					// print the one-of, including all of its fields
 					p.printOneOf(ood, elements, i, mf, w, sourceInfo, path, indent, d.AsFieldDescriptorProto().GetOneofIndex())
-					skip[ood] = true
-				}
-			case *desc.MessageDescriptor:
-				p.printMessage(d, mf, w, sourceInfo, childPath, indent)
-			case *desc.EnumDescriptor:
-				p.printEnum(d, mf, w, sourceInfo, childPath, indent)
-			case *descriptor.DescriptorProto_ExtensionRange:
-				// collapse ranges into a single "extensions" block
-				ranges := []*descriptor.DescriptorProto_ExtensionRange{d}
-				addrs := []elementAddr{el}
-				for idx := i + 1; idx < len(elements.addrs); idx++ {
-					elnext := elements.addrs[idx]
-					if elnext.elementType != el.elementType {
-						break
+					for _, fld := range ood.GetChoices() {
+						skip[fld] = true
 					}
-					extr := elements.at(elnext).(*descriptor.DescriptorProto_ExtensionRange)
-					if !areEqual(d.Options, extr.Options, mf) {
-						break
-					}
-					ranges = append(ranges, extr)
-					addrs = append(addrs, elnext)
-					skip[extr] = true
 				}
-				p.printExtensionRanges(md, ranges, addrs, mf, w, sourceInfo, path, indent)
-			case reservedRange:
-				// collapse reserved ranges into a single "reserved" block
-				ranges := []reservedRange{d}
-				addrs := []elementAddr{el}
-				for idx := i + 1; idx < len(elements.addrs); idx++ {
-					elnext := elements.addrs[idx]
-					if elnext.elementType != el.elementType {
-						break
-					}
-					rr := elements.at(elnext).(reservedRange)
-					ranges = append(ranges, rr)
-					addrs = append(addrs, elnext)
-					skip[rr] = true
-				}
-				p.printReservedRanges(ranges, false, addrs, w, sourceInfo, path, indent)
-			case string: // reserved name
-				// collapse reserved names into a single "reserved" block
-				names := []string{d}
-				addrs := []elementAddr{el}
-				for idx := i + 1; idx < len(elements.addrs); idx++ {
-					elnext := elements.addrs[idx]
-					if elnext.elementType != el.elementType {
-						break
-					}
-					rn := elements.at(elnext).(string)
-					names = append(names, rn)
-					addrs = append(addrs, elnext)
-					skip[rn] = true
-				}
-				p.printReservedNames(names, addrs, w, sourceInfo, path, indent)
 			}
+		case *desc.MessageDescriptor:
+			p.printMessage(d, mf, w, sourceInfo, childPath, indent)
+		case *desc.EnumDescriptor:
+			p.printEnum(d, mf, w, sourceInfo, childPath, indent)
+		case *descriptor.DescriptorProto_ExtensionRange:
+			// collapse ranges into a single "extensions" block
+			ranges := []*descriptor.DescriptorProto_ExtensionRange{d}
+			addrs := []elementAddr{el}
+			for idx := i + 1; idx < len(elements.addrs); idx++ {
+				elnext := elements.addrs[idx]
+				if elnext.elementType != el.elementType {
+					break
+				}
+				extr := elements.at(elnext).(*descriptor.DescriptorProto_ExtensionRange)
+				if !areEqual(d.Options, extr.Options, mf) {
+					break
+				}
+				ranges = append(ranges, extr)
+				addrs = append(addrs, elnext)
+				skip[extr] = true
+			}
+			p.printExtensionRanges(md, ranges, addrs, mf, w, sourceInfo, path, indent)
+		case reservedRange:
+			// collapse reserved ranges into a single "reserved" block
+			ranges := []reservedRange{d}
+			addrs := []elementAddr{el}
+			for idx := i + 1; idx < len(elements.addrs); idx++ {
+				elnext := elements.addrs[idx]
+				if elnext.elementType != el.elementType {
+					break
+				}
+				rr := elements.at(elnext).(reservedRange)
+				ranges = append(ranges, rr)
+				addrs = append(addrs, elnext)
+				skip[rr] = true
+			}
+			p.printReservedRanges(ranges, false, addrs, w, sourceInfo, path, indent)
+		case string: // reserved name
+			// collapse reserved names into a single "reserved" block
+			names := []string{d}
+			addrs := []elementAddr{el}
+			for idx := i + 1; idx < len(elements.addrs); idx++ {
+				elnext := elements.addrs[idx]
+				if elnext.elementType != el.elementType {
+					break
+				}
+				rn := elements.at(elnext).(string)
+				names = append(names, rn)
+				addrs = append(addrs, elnext)
+				skip[rn] = true
+			}
+			p.printReservedNames(names, addrs, w, sourceInfo, path, indent)
 		}
 	}
-
-	if ext != nil {
-		// close trailing extend block
-		p.indent(w, indent)
-		fmt.Fprintln(w, "}")
-	}
 }
 
 func areEqual(a, b proto.Message, mf *dynamic.MessageFactory) bool {
@@ -840,16 +881,29 @@
 		// compute path to group message type
 		groupPath = make([]int32, len(path)-2)
 		copy(groupPath, path)
+
+		var candidates []*desc.MessageDescriptor
+		var parentTag int32
+		switch parent := fld.GetParent().(type) {
+		case *desc.MessageDescriptor:
+			// group in a message
+			candidates = parent.GetNestedMessageTypes()
+			parentTag = internal.Message_nestedMessagesTag
+		case *desc.FileDescriptor:
+			// group that is a top-level extension
+			candidates = parent.GetMessageTypes()
+			parentTag = internal.File_messagesTag
+		}
+
 		var groupMsgIndex int32
-		md := fld.GetParent().(*desc.MessageDescriptor)
-		for i, nmd := range md.GetNestedMessageTypes() {
+		for i, nmd := range candidates {
 			if nmd == fld.GetMessageType() {
 				// found it
 				groupMsgIndex = int32(i)
 				break
 			}
 		}
-		groupPath = append(groupPath, internal.Message_nestedMessagesTag, groupMsgIndex)
+		groupPath = append(groupPath, parentTag, groupMsgIndex)
 
 		// the group message is where the field's comments and position are stored
 		si = sourceInfo.Get(groupPath)
@@ -979,8 +1033,10 @@
 			}
 		}
 
+		// the fields are already sorted, but we have to re-sort in order to
+		// interleave the options (in the event that we are using file location
+		// order and the option locations are interleaved with the fields)
 		p.sort(elements, sourceInfo, oopath)
-
 		scope := ood.GetOwner().GetFullyQualifiedName()
 
 		for i, el := range elements.addrs {
@@ -1003,6 +1059,44 @@
 	})
 }
 
+func (p *Printer) printExtensions(exts *extensionDecl, allExts extensions, parentElements elementAddrs, startFieldIndex int, mf *dynamic.MessageFactory, w *writer, sourceInfo internal.SourceInfoMap, parentPath []int32, extTag int32, pkg, scope string, indent int) {
+	path := append(parentPath, extTag)
+	p.printLeadingComments(exts.sourceInfo, w, indent)
+	p.indent(w, indent)
+	fmt.Fprint(w, "extend ")
+	extNameSi := sourceInfo.Get(append(path, 0, internal.Field_extendeeTag))
+	p.printElementString(extNameSi, w, indent, p.qualifyName(pkg, scope, exts.extendee))
+	fmt.Fprintln(w, "{")
+
+	count := len(exts.fields)
+	first := true
+	for idx := startFieldIndex; count > 0 && idx < len(parentElements.addrs); idx++ {
+		el := parentElements.addrs[idx]
+		if el.elementType != extTag {
+			continue
+		}
+		fld := parentElements.at(el).(*desc.FieldDescriptor)
+		if allExts[fld] == exts {
+			if first {
+				first = false
+			} else {
+				p.newLine(w)
+			}
+			childPath := append(path, int32(el.elementIndex))
+			p.printField(fld, mf, w, sourceInfo, childPath, scope, indent+1)
+			count--
+		}
+	}
+
+	p.indent(w, indent)
+	fmt.Fprintln(w, "}")
+	p.printTrailingComments(exts.sourceInfo, w, indent)
+	if indent >= 0 && !w.newline {
+		// if we're not printing inline but element did not have trailing newline, add one now
+		fmt.Fprintln(w)
+	}
+}
+
 func (p *Printer) printExtensionRanges(parent *desc.MessageDescriptor, ranges []*descriptor.DescriptorProto_ExtensionRange, addrs []elementAddr, mf *dynamic.MessageFactory, w *writer, sourceInfo internal.SourceInfoMap, parentPath []int32, indent int) {
 	p.indent(w, indent)
 	fmt.Fprint(w, "extensions ")
@@ -1523,8 +1617,11 @@
 	},
 }
 
-func extendOptionLocations(sc internal.SourceInfoMap) {
-	for _, loc := range sc {
+func extendOptionLocations(sc internal.SourceInfoMap, locs []*descriptor.SourceCodeInfo_Location) {
+	// we iterate in the order that locations appear in descriptor
+	// for determinism (if we ranged over the map, order and thus
+	// potentially results are non-deterministic)
+	for _, loc := range locs {
 		allowed := edges[edgeKindFile]
 		for i := 0; i+1 < len(loc.Path); i += 2 {
 			nextKind, ok := allowed[loc.Path[i]]
@@ -1967,19 +2064,51 @@
 
 	if (si == nil) != (sj == nil) {
 		// generally, we put unknown elements after known ones;
-		// except package and option elements go first
+		// except package, imports, and option elements go first
 
 		// i will be unknown and j will be known
 		swapped := false
 		if si != nil {
 			si, sj = sj, si
-			// no need to swap ti and tj because we don't use tj anywhere below
-			ti = tj
+			ti, tj = tj, ti
 			swapped = true
 		}
 		switch a.dsc.(type) {
 		case *desc.FileDescriptor:
-			if ti == internal.File_packageTag || ti == internal.File_optionsTag {
+			// NB: These comparisons are *trying* to get things ordered so that
+			// 1) If the package element has no source info, it appears _first_.
+			// 2) If any import element has no source info, it appears _after_
+			//    the package element but _before_ any other element.
+			// 3) If any option element has no source info, it appears _after_
+			//    the package and import elements but _before_ any other element.
+			// If the package, imports, and options are all missing source info,
+			// this will sort them all to the top in expected order. But if they
+			// are mixed (some _do_ have source info, some do not), and elements
+			// with source info have spans that positions them _after_ other
+			// elements in the file, then this Less function will be unstable
+			// since the above dual objectives for imports and options ("before
+			// this but after that") may be in conflict with one another. This
+			// should not cause any problems, other than elements being possibly
+			// sorted in a confusing order.
+			//
+			// Well-formed descriptors should instead have consistent source
+			// info: either all elements have source info or none do. So this
+			// should not be an issue in practice.
+			if ti == internal.File_packageTag {
+				return !swapped
+			}
+			if ti == internal.File_dependencyTag {
+				if tj == internal.File_packageTag {
+					// imports will come *after* package
+					return swapped
+				}
+				return !swapped
+			}
+			if ti == internal.File_optionsTag {
+				if tj == internal.File_packageTag || tj == internal.File_dependencyTag {
+					// options will come *after* package and imports
+					return swapped
+				}
 				return !swapped
 			}
 		case *desc.MessageDescriptor:
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/binary.go b/vendor/github.com/jhump/protoreflect/dynamic/binary.go
index b1fbe7c..91fd672 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/binary.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/binary.go
@@ -4,15 +4,9 @@
 
 import (
 	"fmt"
-	"io"
-	"math"
-	"reflect"
-	"sort"
-
 	"github.com/golang/protobuf/proto"
-	"github.com/golang/protobuf/protoc-gen-go/descriptor"
-
-	"github.com/jhump/protoreflect/desc"
+	"github.com/jhump/protoreflect/codec"
+	"io"
 )
 
 // defaultDeterminism, if true, will mean that calls to Marshal will produce
@@ -24,11 +18,12 @@
 // Marshal serializes this message to bytes, returning an error if the operation
 // fails. The resulting bytes are in the standard protocol buffer binary format.
 func (m *Message) Marshal() ([]byte, error) {
-	var b codedBuffer
-	if err := m.marshal(&b, defaultDeterminism); err != nil {
+	var b codec.Buffer
+	b.SetDeterministic(defaultDeterminism)
+	if err := m.marshal(&b); err != nil {
 		return nil, err
 	}
-	return b.buf, nil
+	return b.Bytes(), nil
 }
 
 // MarshalAppend behaves exactly the same as Marshal, except instead of allocating a
@@ -37,11 +32,12 @@
 // it's not guaranteed as a new backing array will automatically be allocated if
 // more bytes need to be written than the provided buffer has capacity for.
 func (m *Message) MarshalAppend(b []byte) ([]byte, error) {
-	codedBuf := codedBuffer{buf: b}
-	if err := m.marshal(&codedBuf, defaultDeterminism); err != nil {
+	codedBuf := codec.NewBuffer(b)
+	codedBuf.SetDeterministic(defaultDeterminism)
+	if err := m.marshal(codedBuf); err != nil {
 		return nil, err
 	}
-	return codedBuf.buf, nil
+	return codedBuf.Bytes(), nil
 }
 
 // MarshalDeterministic serializes this message to bytes in a deterministic way,
@@ -51,21 +47,37 @@
 // iteration order (which will be random). But for cases where determinism is
 // more important than performance, use this method instead.
 func (m *Message) MarshalDeterministic() ([]byte, error) {
-	var b codedBuffer
-	if err := m.marshal(&b, true); err != nil {
+	var b codec.Buffer
+	b.SetDeterministic(true)
+	if err := m.marshal(&b); err != nil {
 		return nil, err
 	}
-	return b.buf, nil
+	return b.Bytes(), nil
 }
 
-func (m *Message) marshal(b *codedBuffer, deterministic bool) error {
-	if err := m.marshalKnownFields(b, deterministic); err != nil {
+// MarshalAppendDeterministic behaves exactly the same as MarshalDeterministic,
+// except instead of allocating a new byte slice to marshal into, it uses the
+// provided byte slice. The backing array for the returned byte slice *may* be
+// the same as the one that was passed in, but it's not guaranteed as a new
+// backing array will automatically be allocated if more bytes need to be written
+// than the provided buffer has capacity for.
+func (m *Message) MarshalAppendDeterministic(b []byte) ([]byte, error) {
+	codedBuf := codec.NewBuffer(b)
+	codedBuf.SetDeterministic(true)
+	if err := m.marshal(codedBuf); err != nil {
+		return nil, err
+	}
+	return codedBuf.Bytes(), nil
+}
+
+func (m *Message) marshal(b *codec.Buffer) error {
+	if err := m.marshalKnownFields(b); err != nil {
 		return err
 	}
 	return m.marshalUnknownFields(b)
 }
 
-func (m *Message) marshalKnownFields(b *codedBuffer, deterministic bool) error {
+func (m *Message) marshalKnownFields(b *codec.Buffer) error {
 	for _, tag := range m.knownFieldTags() {
 		itag := int32(tag)
 		val := m.values[itag]
@@ -73,317 +85,51 @@
 		if fd == nil {
 			panic(fmt.Sprintf("Couldn't find field for tag %d", itag))
 		}
-		if err := marshalField(itag, fd, val, b, deterministic); err != nil {
+		if err := b.EncodeFieldValue(fd, val); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (m *Message) marshalUnknownFields(b *codedBuffer) error {
+func (m *Message) marshalUnknownFields(b *codec.Buffer) error {
 	for _, tag := range m.unknownFieldTags() {
 		itag := int32(tag)
 		sl := m.unknownFields[itag]
 		for _, u := range sl {
-			if err := b.encodeTagAndWireType(itag, u.Encoding); err != nil {
+			if err := b.EncodeTagAndWireType(itag, u.Encoding); err != nil {
 				return err
 			}
 			switch u.Encoding {
 			case proto.WireBytes:
-				if err := b.encodeRawBytes(u.Contents); err != nil {
+				if err := b.EncodeRawBytes(u.Contents); err != nil {
 					return err
 				}
 			case proto.WireStartGroup:
-				b.buf = append(b.buf, u.Contents...)
-				if err := b.encodeTagAndWireType(itag, proto.WireEndGroup); err != nil {
+				_, _ = b.Write(u.Contents)
+				if err := b.EncodeTagAndWireType(itag, proto.WireEndGroup); err != nil {
 					return err
 				}
 			case proto.WireFixed32:
-				if err := b.encodeFixed32(u.Value); err != nil {
+				if err := b.EncodeFixed32(u.Value); err != nil {
 					return err
 				}
 			case proto.WireFixed64:
-				if err := b.encodeFixed64(u.Value); err != nil {
+				if err := b.EncodeFixed64(u.Value); err != nil {
 					return err
 				}
 			case proto.WireVarint:
-				if err := b.encodeVarint(u.Value); err != nil {
+				if err := b.EncodeVarint(u.Value); err != nil {
 					return err
 				}
 			default:
-				return proto.ErrInternalBadWireType
+				return codec.ErrBadWireType
 			}
 		}
 	}
 	return nil
 }
 
-func marshalField(tag int32, fd *desc.FieldDescriptor, val interface{}, b *codedBuffer, deterministic bool) error {
-	if fd.IsMap() {
-		mp := val.(map[interface{}]interface{})
-		entryType := fd.GetMessageType()
-		keyType := entryType.FindFieldByNumber(1)
-		valType := entryType.FindFieldByNumber(2)
-		var entryBuffer codedBuffer
-		if deterministic {
-			keys := make([]interface{}, 0, len(mp))
-			for k := range mp {
-				keys = append(keys, k)
-			}
-			sort.Sort(sortable(keys))
-			for _, k := range keys {
-				v := mp[k]
-				entryBuffer.reset()
-				if err := marshalFieldElement(1, keyType, k, &entryBuffer, deterministic); err != nil {
-					return err
-				}
-				if err := marshalFieldElement(2, valType, v, &entryBuffer, deterministic); err != nil {
-					return err
-				}
-				if err := b.encodeTagAndWireType(tag, proto.WireBytes); err != nil {
-					return err
-				}
-				if err := b.encodeRawBytes(entryBuffer.buf); err != nil {
-					return err
-				}
-			}
-		} else {
-			for k, v := range mp {
-				entryBuffer.reset()
-				if err := marshalFieldElement(1, keyType, k, &entryBuffer, deterministic); err != nil {
-					return err
-				}
-				if err := marshalFieldElement(2, valType, v, &entryBuffer, deterministic); err != nil {
-					return err
-				}
-				if err := b.encodeTagAndWireType(tag, proto.WireBytes); err != nil {
-					return err
-				}
-				if err := b.encodeRawBytes(entryBuffer.buf); err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	} else if fd.IsRepeated() {
-		sl := val.([]interface{})
-		wt, err := getWireType(fd.GetType())
-		if err != nil {
-			return err
-		}
-		if isPacked(fd) && len(sl) > 1 &&
-			(wt == proto.WireVarint || wt == proto.WireFixed32 || wt == proto.WireFixed64) {
-			// packed repeated field
-			var packedBuffer codedBuffer
-			for _, v := range sl {
-				if err := marshalFieldValue(fd, v, &packedBuffer, deterministic); err != nil {
-					return err
-				}
-			}
-			if err := b.encodeTagAndWireType(tag, proto.WireBytes); err != nil {
-				return err
-			}
-			return b.encodeRawBytes(packedBuffer.buf)
-		} else {
-			// non-packed repeated field
-			for _, v := range sl {
-				if err := marshalFieldElement(tag, fd, v, b, deterministic); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	} else {
-		return marshalFieldElement(tag, fd, val, b, deterministic)
-	}
-}
-
-func isPacked(fd *desc.FieldDescriptor) bool {
-	opts := fd.AsFieldDescriptorProto().GetOptions()
-	// if set, use that value
-	if opts != nil && opts.Packed != nil {
-		return opts.GetPacked()
-	}
-	// if unset: proto2 defaults to false, proto3 to true
-	return fd.GetFile().IsProto3()
-}
-
-// sortable is used to sort map keys. Values will be integers (int32, int64, uint32, and uint64),
-// bools, or strings.
-type sortable []interface{}
-
-func (s sortable) Len() int {
-	return len(s)
-}
-
-func (s sortable) Less(i, j int) bool {
-	vi := s[i]
-	vj := s[j]
-	switch reflect.TypeOf(vi).Kind() {
-	case reflect.Int32:
-		return vi.(int32) < vj.(int32)
-	case reflect.Int64:
-		return vi.(int64) < vj.(int64)
-	case reflect.Uint32:
-		return vi.(uint32) < vj.(uint32)
-	case reflect.Uint64:
-		return vi.(uint64) < vj.(uint64)
-	case reflect.String:
-		return vi.(string) < vj.(string)
-	case reflect.Bool:
-		return vi.(bool) && !vj.(bool)
-	default:
-		panic(fmt.Sprintf("cannot compare keys of type %v", reflect.TypeOf(vi)))
-	}
-}
-
-func (s sortable) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}
-
-func marshalFieldElement(tag int32, fd *desc.FieldDescriptor, val interface{}, b *codedBuffer, deterministic bool) error {
-	wt, err := getWireType(fd.GetType())
-	if err != nil {
-		return err
-	}
-	if err := b.encodeTagAndWireType(tag, wt); err != nil {
-		return err
-	}
-	if err := marshalFieldValue(fd, val, b, deterministic); err != nil {
-		return err
-	}
-	if wt == proto.WireStartGroup {
-		return b.encodeTagAndWireType(tag, proto.WireEndGroup)
-	}
-	return nil
-}
-
-func marshalFieldValue(fd *desc.FieldDescriptor, val interface{}, b *codedBuffer, deterministic bool) error {
-	switch fd.GetType() {
-	case descriptor.FieldDescriptorProto_TYPE_BOOL:
-		v := val.(bool)
-		if v {
-			return b.encodeVarint(1)
-		} else {
-			return b.encodeVarint(0)
-		}
-
-	case descriptor.FieldDescriptorProto_TYPE_ENUM,
-		descriptor.FieldDescriptorProto_TYPE_INT32:
-		v := val.(int32)
-		return b.encodeVarint(uint64(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-		v := val.(int32)
-		return b.encodeFixed32(uint64(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_SINT32:
-		v := val.(int32)
-		return b.encodeVarint(encodeZigZag32(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_UINT32:
-		v := val.(uint32)
-		return b.encodeVarint(uint64(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_FIXED32:
-		v := val.(uint32)
-		return b.encodeFixed32(uint64(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_INT64:
-		v := val.(int64)
-		return b.encodeVarint(uint64(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-		v := val.(int64)
-		return b.encodeFixed64(uint64(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_SINT64:
-		v := val.(int64)
-		return b.encodeVarint(encodeZigZag64(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_UINT64:
-		v := val.(uint64)
-		return b.encodeVarint(v)
-
-	case descriptor.FieldDescriptorProto_TYPE_FIXED64:
-		v := val.(uint64)
-		return b.encodeFixed64(v)
-
-	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-		v := val.(float64)
-		return b.encodeFixed64(math.Float64bits(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
-		v := val.(float32)
-		return b.encodeFixed32(uint64(math.Float32bits(v)))
-
-	case descriptor.FieldDescriptorProto_TYPE_BYTES:
-		v := val.([]byte)
-		return b.encodeRawBytes(v)
-
-	case descriptor.FieldDescriptorProto_TYPE_STRING:
-		v := val.(string)
-		return b.encodeRawBytes(([]byte)(v))
-
-	case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-		m := val.(proto.Message)
-		if bytes, err := proto.Marshal(m); err != nil {
-			return err
-		} else {
-			return b.encodeRawBytes(bytes)
-		}
-
-	case descriptor.FieldDescriptorProto_TYPE_GROUP:
-		// just append the nested message to this buffer
-		dm, ok := val.(*Message)
-		if ok {
-			return dm.marshal(b, deterministic)
-		} else {
-			m := val.(proto.Message)
-			return b.encodeMessage(m)
-		}
-		// whosoever writeth start-group tag (e.g. caller) is responsible for writing end-group tag
-
-	default:
-		return fmt.Errorf("unrecognized field type: %v", fd.GetType())
-	}
-}
-
-func getWireType(t descriptor.FieldDescriptorProto_Type) (int8, error) {
-	switch t {
-	case descriptor.FieldDescriptorProto_TYPE_ENUM,
-		descriptor.FieldDescriptorProto_TYPE_BOOL,
-		descriptor.FieldDescriptorProto_TYPE_INT32,
-		descriptor.FieldDescriptorProto_TYPE_SINT32,
-		descriptor.FieldDescriptorProto_TYPE_UINT32,
-		descriptor.FieldDescriptorProto_TYPE_INT64,
-		descriptor.FieldDescriptorProto_TYPE_SINT64,
-		descriptor.FieldDescriptorProto_TYPE_UINT64:
-		return proto.WireVarint, nil
-
-	case descriptor.FieldDescriptorProto_TYPE_FIXED32,
-		descriptor.FieldDescriptorProto_TYPE_SFIXED32,
-		descriptor.FieldDescriptorProto_TYPE_FLOAT:
-		return proto.WireFixed32, nil
-
-	case descriptor.FieldDescriptorProto_TYPE_FIXED64,
-		descriptor.FieldDescriptorProto_TYPE_SFIXED64,
-		descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-		return proto.WireFixed64, nil
-
-	case descriptor.FieldDescriptorProto_TYPE_BYTES,
-		descriptor.FieldDescriptorProto_TYPE_STRING,
-		descriptor.FieldDescriptorProto_TYPE_MESSAGE:
-		return proto.WireBytes, nil
-
-	case descriptor.FieldDescriptorProto_TYPE_GROUP:
-		return proto.WireStartGroup, nil
-
-	default:
-		return 0, proto.ErrInternalBadWireType
-	}
-}
-
 // Unmarshal de-serializes the message that is present in the given bytes into
 // this message. It first resets the current message. It returns an error if the
 // given bytes do not contain a valid encoding of this message type.
@@ -400,34 +146,36 @@
 // instead merging the data in the given bytes into the existing data in this
 // message.
 func (m *Message) UnmarshalMerge(b []byte) error {
-	return m.unmarshal(newCodedBuffer(b), false)
+	return m.unmarshal(codec.NewBuffer(b), false)
 }
 
-func (m *Message) unmarshal(buf *codedBuffer, isGroup bool) error {
-	for !buf.eof() {
-		tagNumber, wireType, err := buf.decodeTagAndWireType()
+func (m *Message) unmarshal(buf *codec.Buffer, isGroup bool) error {
+	for !buf.EOF() {
+		fd, val, err := buf.DecodeFieldValue(m.FindFieldDescriptor, m.mf)
 		if err != nil {
+			if err == codec.ErrWireTypeEndGroup {
+				if isGroup {
+					// finished parsing group
+					return nil
+				}
+				return codec.ErrBadWireType
+			}
 			return err
 		}
-		if wireType == proto.WireEndGroup {
-			if isGroup {
-				// finished parsing group
-				return nil
-			} else {
-				return proto.ErrInternalBadWireType
-			}
-		}
-		fd := m.FindFieldDescriptor(tagNumber)
+
 		if fd == nil {
-			err := m.unmarshalUnknownField(tagNumber, wireType, buf)
-			if err != nil {
-				return err
+			if m.unknownFields == nil {
+				m.unknownFields = map[int32][]UnknownField{}
 			}
-		} else {
-			err := m.unmarshalKnownField(fd, wireType, buf)
-			if err != nil {
-				return err
+			uv := val.(codec.UnknownField)
+			u := UnknownField{
+				Encoding: uv.Encoding,
+				Value:    uv.Value,
+				Contents: uv.Contents,
 			}
+			m.unknownFields[uv.Tag] = append(m.unknownFields[uv.Tag], u)
+		} else if err := mergeField(m, fd, val); err != nil {
+			return err
 		}
 	}
 	if isGroup {
@@ -435,280 +183,3 @@
 	}
 	return nil
 }
-
-func unmarshalSimpleField(fd *desc.FieldDescriptor, v uint64) (interface{}, error) {
-	switch fd.GetType() {
-	case descriptor.FieldDescriptorProto_TYPE_BOOL:
-		return v != 0, nil
-	case descriptor.FieldDescriptorProto_TYPE_UINT32,
-		descriptor.FieldDescriptorProto_TYPE_FIXED32:
-		if v > math.MaxUint32 {
-			return nil, NumericOverflowError
-		}
-		return uint32(v), nil
-
-	case descriptor.FieldDescriptorProto_TYPE_INT32,
-		descriptor.FieldDescriptorProto_TYPE_ENUM:
-		s := int64(v)
-		if s > math.MaxInt32 || s < math.MinInt32 {
-			return nil, NumericOverflowError
-		}
-		return int32(s), nil
-
-	case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
-		if v > math.MaxUint32 {
-			return nil, NumericOverflowError
-		}
-		return int32(v), nil
-
-	case descriptor.FieldDescriptorProto_TYPE_SINT32:
-		if v > math.MaxUint32 {
-			return nil, NumericOverflowError
-		}
-		return decodeZigZag32(v), nil
-
-	case descriptor.FieldDescriptorProto_TYPE_UINT64,
-		descriptor.FieldDescriptorProto_TYPE_FIXED64:
-		return v, nil
-
-	case descriptor.FieldDescriptorProto_TYPE_INT64,
-		descriptor.FieldDescriptorProto_TYPE_SFIXED64:
-		return int64(v), nil
-
-	case descriptor.FieldDescriptorProto_TYPE_SINT64:
-		return decodeZigZag64(v), nil
-
-	case descriptor.FieldDescriptorProto_TYPE_FLOAT:
-		if v > math.MaxUint32 {
-			return nil, NumericOverflowError
-		}
-		return math.Float32frombits(uint32(v)), nil
-
-	case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
-		return math.Float64frombits(v), nil
-
-	default:
-		// bytes, string, message, and group cannot be represented as a simple numeric value
-		return nil, fmt.Errorf("bad input; field %s requires length-delimited wire type", fd.GetFullyQualifiedName())
-	}
-}
-
-func unmarshalLengthDelimitedField(fd *desc.FieldDescriptor, bytes []byte, mf *MessageFactory) (interface{}, error) {
-	switch {
-	case fd.GetType() == descriptor.FieldDescriptorProto_TYPE_BYTES:
-		return bytes, nil
-
-	case fd.GetType() == descriptor.FieldDescriptorProto_TYPE_STRING:
-		return string(bytes), nil
-
-	case fd.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE ||
-		fd.GetType() == descriptor.FieldDescriptorProto_TYPE_GROUP:
-		msg := mf.NewMessage(fd.GetMessageType())
-		err := proto.Unmarshal(bytes, msg)
-		if err != nil {
-			return nil, err
-		} else {
-			return msg, nil
-		}
-
-	default:
-		// even if the field is not repeated or not packed, we still parse it as such for
-		// backwards compatibility (e.g. message we are de-serializing could have been both
-		// repeated and packed at the time of serialization)
-		packedBuf := newCodedBuffer(bytes)
-		var slice []interface{}
-		var val interface{}
-		for !packedBuf.eof() {
-			var v uint64
-			var err error
-			if varintTypes[fd.GetType()] {
-				v, err = packedBuf.decodeVarint()
-			} else if fixed32Types[fd.GetType()] {
-				v, err = packedBuf.decodeFixed32()
-			} else if fixed64Types[fd.GetType()] {
-				v, err = packedBuf.decodeFixed64()
-			} else {
-				return nil, fmt.Errorf("bad input; cannot parse length-delimited wire type for field %s", fd.GetFullyQualifiedName())
-			}
-			if err != nil {
-				return nil, err
-			}
-			val, err = unmarshalSimpleField(fd, v)
-			if err != nil {
-				return nil, err
-			}
-			if fd.IsRepeated() {
-				slice = append(slice, val)
-			}
-		}
-		if fd.IsRepeated() {
-			return slice, nil
-		} else {
-			// if not a repeated field, last value wins
-			return val, nil
-		}
-	}
-}
-
-func (m *Message) unmarshalKnownField(fd *desc.FieldDescriptor, encoding int8, b *codedBuffer) error {
-	var val interface{}
-	var err error
-	switch encoding {
-	case proto.WireFixed32:
-		var num uint64
-		num, err = b.decodeFixed32()
-		if err == nil {
-			val, err = unmarshalSimpleField(fd, num)
-		}
-	case proto.WireFixed64:
-		var num uint64
-		num, err = b.decodeFixed64()
-		if err == nil {
-			val, err = unmarshalSimpleField(fd, num)
-		}
-	case proto.WireVarint:
-		var num uint64
-		num, err = b.decodeVarint()
-		if err == nil {
-			val, err = unmarshalSimpleField(fd, num)
-		}
-
-	case proto.WireBytes:
-		if fd.GetType() == descriptor.FieldDescriptorProto_TYPE_BYTES {
-			val, err = b.decodeRawBytes(true) // defensive copy
-		} else if fd.GetType() == descriptor.FieldDescriptorProto_TYPE_STRING {
-			var raw []byte
-			raw, err = b.decodeRawBytes(true) // defensive copy
-			if err == nil {
-				val = string(raw)
-			}
-		} else {
-			var raw []byte
-			raw, err = b.decodeRawBytes(false)
-			if err == nil {
-				val, err = unmarshalLengthDelimitedField(fd, raw, m.mf)
-			}
-		}
-
-	case proto.WireStartGroup:
-		if fd.GetMessageType() == nil {
-			return fmt.Errorf("cannot parse field %s from group-encoded wire type", fd.GetFullyQualifiedName())
-		}
-		msg := m.mf.NewMessage(fd.GetMessageType())
-		if dm, ok := msg.(*Message); ok {
-			err = dm.unmarshal(b, true)
-			if err == nil {
-				val = dm
-			}
-		} else {
-			var groupEnd, dataEnd int
-			groupEnd, dataEnd, err = skipGroup(b)
-			if err == nil {
-				err = proto.Unmarshal(b.buf[b.index:dataEnd], msg)
-				if err == nil {
-					val = msg
-				}
-				b.index = groupEnd
-			}
-		}
-
-	default:
-		return proto.ErrInternalBadWireType
-	}
-	if err != nil {
-		return err
-	}
-
-	return mergeField(m, fd, val)
-}
-
-func (m *Message) unmarshalUnknownField(tagNumber int32, encoding int8, b *codedBuffer) error {
-	u := UnknownField{Encoding: encoding}
-	var err error
-	switch encoding {
-	case proto.WireFixed32:
-		u.Value, err = b.decodeFixed32()
-	case proto.WireFixed64:
-		u.Value, err = b.decodeFixed64()
-	case proto.WireVarint:
-		u.Value, err = b.decodeVarint()
-	case proto.WireBytes:
-		u.Contents, err = b.decodeRawBytes(true)
-	case proto.WireStartGroup:
-		var groupEnd, dataEnd int
-		groupEnd, dataEnd, err = skipGroup(b)
-		if err == nil {
-			u.Contents = make([]byte, dataEnd-b.index)
-			copy(u.Contents, b.buf[b.index:])
-			b.index = groupEnd
-		}
-	default:
-		err = proto.ErrInternalBadWireType
-	}
-	if err != nil {
-		return err
-	}
-	if m.unknownFields == nil {
-		m.unknownFields = map[int32][]UnknownField{}
-	}
-	m.unknownFields[tagNumber] = append(m.unknownFields[tagNumber], u)
-	return nil
-}
-
-func skipGroup(b *codedBuffer) (int, int, error) {
-	bs := b.buf
-	start := b.index
-	defer func() {
-		b.index = start
-	}()
-	for {
-		fieldStart := b.index
-		// read a field tag
-		_, wireType, err := b.decodeTagAndWireType()
-		if err != nil {
-			return 0, 0, err
-		}
-		// skip past the field's data
-		switch wireType {
-		case proto.WireFixed32:
-			if !b.skip(4) {
-				return 0, 0, io.ErrUnexpectedEOF
-			}
-		case proto.WireFixed64:
-			if !b.skip(8) {
-				return 0, 0, io.ErrUnexpectedEOF
-			}
-		case proto.WireVarint:
-			// skip varint by finding last byte (has high bit unset)
-			i := b.index
-			for {
-				if i >= len(bs) {
-					return 0, 0, io.ErrUnexpectedEOF
-				}
-				if bs[i]&0x80 == 0 {
-					break
-				}
-				i++
-			}
-			b.index = i + 1
-		case proto.WireBytes:
-			l, err := b.decodeVarint()
-			if err != nil {
-				return 0, 0, err
-			}
-			if !b.skip(int(l)) {
-				return 0, 0, io.ErrUnexpectedEOF
-			}
-		case proto.WireStartGroup:
-			endIndex, _, err := skipGroup(b)
-			if err != nil {
-				return 0, 0, err
-			}
-			b.index = endIndex
-		case proto.WireEndGroup:
-			return b.index, fieldStart, nil
-		default:
-			return 0, 0, proto.ErrInternalBadWireType
-		}
-	}
-}
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/codec.go b/vendor/github.com/jhump/protoreflect/dynamic/codec.go
deleted file mode 100644
index 9d70ab7..0000000
--- a/vendor/github.com/jhump/protoreflect/dynamic/codec.go
+++ /dev/null
@@ -1,350 +0,0 @@
-package dynamic
-
-// A reader/writer type that assists with encoding and decoding protobuf's binary representation.
-// This code is largely a fork of proto.Buffer, which cannot be used because it has no exported
-// field or method that provides access to its underlying reader index.
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"math"
-
-	"github.com/golang/protobuf/proto"
-)
-
-// ErrOverflow is returned when an integer is too large to be represented.
-var ErrOverflow = errors.New("proto: integer overflow")
-
-type codedBuffer struct {
-	buf   []byte
-	index int
-}
-
-func newCodedBuffer(buf []byte) *codedBuffer {
-	return &codedBuffer{buf: buf}
-}
-
-func (cb *codedBuffer) reset() {
-	cb.buf = []byte(nil)
-	cb.index = 0
-}
-
-func (cb *codedBuffer) eof() bool {
-	return cb.index >= len(cb.buf)
-}
-
-func (cb *codedBuffer) skip(count int) bool {
-	newIndex := cb.index + count
-	if newIndex > len(cb.buf) {
-		return false
-	}
-	cb.index = newIndex
-	return true
-}
-
-func (cb *codedBuffer) decodeVarintSlow() (x uint64, err error) {
-	i := cb.index
-	l := len(cb.buf)
-
-	for shift := uint(0); shift < 64; shift += 7 {
-		if i >= l {
-			err = io.ErrUnexpectedEOF
-			return
-		}
-		b := cb.buf[i]
-		i++
-		x |= (uint64(b) & 0x7F) << shift
-		if b < 0x80 {
-			cb.index = i
-			return
-		}
-	}
-
-	// The number is too large to represent in a 64-bit value.
-	err = ErrOverflow
-	return
-}
-
-// DecodeVarint reads a varint-encoded integer from the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (cb *codedBuffer) decodeVarint() (uint64, error) {
-	i := cb.index
-	buf := cb.buf
-
-	if i >= len(buf) {
-		return 0, io.ErrUnexpectedEOF
-	} else if buf[i] < 0x80 {
-		cb.index++
-		return uint64(buf[i]), nil
-	} else if len(buf)-i < 10 {
-		return cb.decodeVarintSlow()
-	}
-
-	var b uint64
-	// we already checked the first byte
-	x := uint64(buf[i]) - 0x80
-	i++
-
-	b = uint64(buf[i])
-	i++
-	x += b << 7
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 7
-
-	b = uint64(buf[i])
-	i++
-	x += b << 14
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 14
-
-	b = uint64(buf[i])
-	i++
-	x += b << 21
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 21
-
-	b = uint64(buf[i])
-	i++
-	x += b << 28
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 28
-
-	b = uint64(buf[i])
-	i++
-	x += b << 35
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 35
-
-	b = uint64(buf[i])
-	i++
-	x += b << 42
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 42
-
-	b = uint64(buf[i])
-	i++
-	x += b << 49
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 49
-
-	b = uint64(buf[i])
-	i++
-	x += b << 56
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 56
-
-	b = uint64(buf[i])
-	i++
-	x += b << 63
-	if b&0x80 == 0 {
-		goto done
-	}
-	// x -= 0x80 << 63 // Always zero.
-
-	return 0, ErrOverflow
-
-done:
-	cb.index = i
-	return x, nil
-}
-
-func (cb *codedBuffer) decodeTagAndWireType() (tag int32, wireType int8, err error) {
-	var v uint64
-	v, err = cb.decodeVarint()
-	if err != nil {
-		return
-	}
-	// low 7 bits is wire type
-	wireType = int8(v & 7)
-	// rest is int32 tag number
-	v = v >> 3
-	if v > math.MaxInt32 {
-		err = fmt.Errorf("tag number out of range: %d", v)
-		return
-	}
-	tag = int32(v)
-	return
-}
-
-// DecodeFixed64 reads a 64-bit integer from the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (cb *codedBuffer) decodeFixed64() (x uint64, err error) {
-	// x, err already 0
-	i := cb.index + 8
-	if i < 0 || i > len(cb.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	cb.index = i
-
-	x = uint64(cb.buf[i-8])
-	x |= uint64(cb.buf[i-7]) << 8
-	x |= uint64(cb.buf[i-6]) << 16
-	x |= uint64(cb.buf[i-5]) << 24
-	x |= uint64(cb.buf[i-4]) << 32
-	x |= uint64(cb.buf[i-3]) << 40
-	x |= uint64(cb.buf[i-2]) << 48
-	x |= uint64(cb.buf[i-1]) << 56
-	return
-}
-
-// DecodeFixed32 reads a 32-bit integer from the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (cb *codedBuffer) decodeFixed32() (x uint64, err error) {
-	// x, err already 0
-	i := cb.index + 4
-	if i < 0 || i > len(cb.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	cb.index = i
-
-	x = uint64(cb.buf[i-4])
-	x |= uint64(cb.buf[i-3]) << 8
-	x |= uint64(cb.buf[i-2]) << 16
-	x |= uint64(cb.buf[i-1]) << 24
-	return
-}
-
-func decodeZigZag32(v uint64) int32 {
-	return int32((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31))
-}
-
-func decodeZigZag64(v uint64) int64 {
-	return int64((v >> 1) ^ uint64((int64(v&1)<<63)>>63))
-}
-
-// These are not ValueDecoders: they produce an array of bytes or a string.
-// bytes, embedded messages
-
-// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (cb *codedBuffer) decodeRawBytes(alloc bool) (buf []byte, err error) {
-	n, err := cb.decodeVarint()
-	if err != nil {
-		return nil, err
-	}
-
-	nb := int(n)
-	if nb < 0 {
-		return nil, fmt.Errorf("proto: bad byte length %d", nb)
-	}
-	end := cb.index + nb
-	if end < cb.index || end > len(cb.buf) {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	if !alloc {
-		buf = cb.buf[cb.index:end]
-		cb.index += nb
-		return
-	}
-
-	buf = make([]byte, nb)
-	copy(buf, cb.buf[cb.index:])
-	cb.index += nb
-	return
-}
-
-// EncodeVarint writes a varint-encoded integer to the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (cb *codedBuffer) encodeVarint(x uint64) error {
-	for x >= 1<<7 {
-		cb.buf = append(cb.buf, uint8(x&0x7f|0x80))
-		x >>= 7
-	}
-	cb.buf = append(cb.buf, uint8(x))
-	return nil
-}
-
-func (cb *codedBuffer) encodeTagAndWireType(tag int32, wireType int8) error {
-	v := uint64((int64(tag) << 3) | int64(wireType))
-	return cb.encodeVarint(v)
-}
-
-// TODO: decodeTagAndWireType
-
-// EncodeFixed64 writes a 64-bit integer to the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (cb *codedBuffer) encodeFixed64(x uint64) error {
-	cb.buf = append(cb.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24),
-		uint8(x>>32),
-		uint8(x>>40),
-		uint8(x>>48),
-		uint8(x>>56))
-	return nil
-}
-
-// EncodeFixed32 writes a 32-bit integer to the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (cb *codedBuffer) encodeFixed32(x uint64) error {
-	cb.buf = append(cb.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24))
-	return nil
-}
-
-func encodeZigZag64(v int64) uint64 {
-	return (uint64(v) << 1) ^ uint64(v>>63)
-}
-
-func encodeZigZag32(v int32) uint64 {
-	return uint64((uint32(v) << 1) ^ uint32((v >> 31)))
-}
-
-// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (cb *codedBuffer) encodeRawBytes(b []byte) error {
-	cb.encodeVarint(uint64(len(b)))
-	cb.buf = append(cb.buf, b...)
-	return nil
-}
-
-func (cb *codedBuffer) encodeMessage(pm proto.Message) error {
-	bytes, err := proto.Marshal(pm)
-	if err != nil {
-		return err
-	}
-	if len(bytes) == 0 {
-		return nil
-	}
-
-	if err := cb.encodeVarint(uint64(len(bytes))); err != nil {
-		return err
-	}
-	cb.buf = append(cb.buf, bytes...)
-	return nil
-}
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go b/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go
index ac7e52f..3f19d6b 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go
@@ -12,6 +12,7 @@
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/protoc-gen-go/descriptor"
 
+	"github.com/jhump/protoreflect/codec"
 	"github.com/jhump/protoreflect/desc"
 )
 
@@ -68,29 +69,6 @@
 var typeOfDynamicMessage = reflect.TypeOf((*Message)(nil))
 var typeOfBytes = reflect.TypeOf(([]byte)(nil))
 
-var varintTypes = map[descriptor.FieldDescriptorProto_Type]bool{}
-var fixed32Types = map[descriptor.FieldDescriptorProto_Type]bool{}
-var fixed64Types = map[descriptor.FieldDescriptorProto_Type]bool{}
-
-func init() {
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_BOOL] = true
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_INT32] = true
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_INT64] = true
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_UINT32] = true
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_UINT64] = true
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_SINT32] = true
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_SINT64] = true
-	varintTypes[descriptor.FieldDescriptorProto_TYPE_ENUM] = true
-
-	fixed32Types[descriptor.FieldDescriptorProto_TYPE_FIXED32] = true
-	fixed32Types[descriptor.FieldDescriptorProto_TYPE_SFIXED32] = true
-	fixed32Types[descriptor.FieldDescriptorProto_TYPE_FLOAT] = true
-
-	fixed64Types[descriptor.FieldDescriptorProto_TYPE_FIXED64] = true
-	fixed64Types[descriptor.FieldDescriptorProto_TYPE_SFIXED64] = true
-	fixed64Types[descriptor.FieldDescriptorProto_TYPE_DOUBLE] = true
-}
-
 // Message is a dynamic protobuf message. Instead of a generated struct,
 // like most protobuf messages, this is a map of field number to values and
 // a message descriptor, which is used to validate the field values and
@@ -1221,7 +1199,6 @@
 		if mp, err = m.parseUnknownField(fd); err != nil {
 			return err
 		} else if mp == nil {
-			mp = map[interface{}]interface{}{}
 			m.internalSetField(fd, map[interface{}]interface{}{ki: vi})
 			return nil
 		}
@@ -1777,9 +1754,9 @@
 	for _, unk := range unks {
 		var val interface{}
 		if unk.Encoding == proto.WireBytes || unk.Encoding == proto.WireStartGroup {
-			val, err = unmarshalLengthDelimitedField(fd, unk.Contents, m.mf)
+			val, err = codec.DecodeLengthDelimitedField(fd, unk.Contents, m.mf)
 		} else {
-			val, err = unmarshalSimpleField(fd, unk.Value)
+			val, err = codec.DecodeScalarField(fd, unk.Value)
 		}
 		if err != nil {
 			return nil, err
@@ -2292,14 +2269,15 @@
 	// if we have fields that the given message doesn't know about, add to its unknown fields
 	if len(unknownTags) > 0 {
 		ub := u.Interface().([]byte)
-		var b codedBuffer
+		var b codec.Buffer
+		b.SetDeterministic(defaultDeterminism)
 		for tag := range unknownTags {
 			fd := m.FindFieldDescriptor(tag)
-			if err := marshalField(tag, fd, m.values[tag], &b, false); err != nil {
+			if err := b.EncodeFieldValue(fd, m.values[tag]); err != nil {
 				return err
 			}
 		}
-		ub = append(ub, b.buf...)
+		ub = append(ub, b.Bytes()...)
 		u.Set(reflect.ValueOf(ub))
 	}
 
@@ -2307,9 +2285,9 @@
 	// (this will append to its unknown fields if not known; if somehow the given message recognizes
 	// a field even though the dynamic message did not, it will get correctly unmarshalled)
 	if unknownTags != nil && len(m.unknownFields) > 0 {
-		var b codedBuffer
-		m.marshalUnknownFields(&b)
-		proto.UnmarshalMerge(b.buf, pm)
+		var b codec.Buffer
+		_ = m.marshalUnknownFields(&b)
+		_ = proto.UnmarshalMerge(b.Bytes(), pm)
 	}
 
 	return nil
@@ -2535,7 +2513,7 @@
 	u := src.FieldByName("XXX_unrecognized")
 	if u.IsValid() && u.Type() == typeOfBytes {
 		// ignore any error returned: pulling in unknown fields is best-effort
-		m.UnmarshalMerge(u.Interface().([]byte))
+		_ = m.UnmarshalMerge(u.Interface().([]byte))
 	}
 
 	// lastly, also extract any unknown extensions the message may have (unknown extensions
@@ -2543,7 +2521,7 @@
 	// more than just the step above...)
 	if len(unknownExtensions) > 0 {
 		// pulling in unknown fields is best-effort, so we just ignore errors
-		m.UnmarshalMerge(unknownExtensions)
+		_ = m.UnmarshalMerge(unknownExtensions)
 	}
 	return nil
 }
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/extension.go b/vendor/github.com/jhump/protoreflect/dynamic/extension.go
index a0ff6af..1d38161 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/extension.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/extension.go
@@ -5,6 +5,7 @@
 
 	"github.com/golang/protobuf/proto"
 
+	"github.com/jhump/protoreflect/codec"
 	"github.com/jhump/protoreflect/desc"
 )
 
@@ -35,10 +36,11 @@
 		return err
 	}
 
-	var b codedBuffer
-	if err := marshalField(extd.GetNumber(), extd, val, &b, defaultDeterminism); err != nil {
+	var b codec.Buffer
+	b.SetDeterministic(defaultDeterminism)
+	if err := b.EncodeFieldValue(extd, val); err != nil {
 		return err
 	}
-	proto.SetRawExtension(msg, extd.GetNumber(), b.buf)
+	proto.SetRawExtension(msg, extd.GetNumber(), b.Bytes())
 	return nil
 }
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/json.go b/vendor/github.com/jhump/protoreflect/dynamic/json.go
index f79b4ac..7dfae09 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/json.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/json.go
@@ -308,6 +308,39 @@
 	}
 }
 
+// sortable is used to sort map keys. Values will be integers (int32, int64, uint32, and uint64),
+// bools, or strings.
+type sortable []interface{}
+
+func (s sortable) Len() int {
+	return len(s)
+}
+
+func (s sortable) Less(i, j int) bool {
+	vi := s[i]
+	vj := s[j]
+	switch reflect.TypeOf(vi).Kind() {
+	case reflect.Int32:
+		return vi.(int32) < vj.(int32)
+	case reflect.Int64:
+		return vi.(int64) < vj.(int64)
+	case reflect.Uint32:
+		return vi.(uint32) < vj.(uint32)
+	case reflect.Uint64:
+		return vi.(uint64) < vj.(uint64)
+	case reflect.String:
+		return vi.(string) < vj.(string)
+	case reflect.Bool:
+		return !vi.(bool) && vj.(bool)
+	default:
+		panic(fmt.Sprintf("cannot compare keys of type %v", reflect.TypeOf(vi)))
+	}
+}
+
+func (s sortable) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
 func isNil(v interface{}) bool {
 	if v == nil {
 		return true
@@ -345,7 +378,9 @@
 func marshalKnownFieldValueJSON(b *indentBuffer, fd *desc.FieldDescriptor, v interface{}, opts *jsonpb.Marshaler) error {
 	rv := reflect.ValueOf(v)
 	switch rv.Kind() {
-	case reflect.Int32, reflect.Int64:
+	case reflect.Int64:
+		return writeJsonString(b, strconv.FormatInt(rv.Int(), 10))
+	case reflect.Int32:
 		ed := fd.GetEnumType()
 		if !opts.EnumsAsInts && ed != nil {
 			n := int32(rv.Int())
@@ -360,7 +395,9 @@
 			_, err := b.WriteString(strconv.FormatInt(rv.Int(), 10))
 			return err
 		}
-	case reflect.Uint32, reflect.Uint64:
+	case reflect.Uint64:
+		return writeJsonString(b, strconv.FormatUint(rv.Uint(), 10))
+	case reflect.Uint32:
 		_, err := b.WriteString(strconv.FormatUint(rv.Uint(), 10))
 		return err
 	case reflect.Float32, reflect.Float64:
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/text.go b/vendor/github.com/jhump/protoreflect/dynamic/text.go
index 2d0fa04..72636f2 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/text.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/text.go
@@ -17,6 +17,7 @@
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/protoc-gen-go/descriptor"
 
+	"github.com/jhump/protoreflect/codec"
 	"github.com/jhump/protoreflect/desc"
 )
 
@@ -124,7 +125,7 @@
 				if err != nil {
 					return err
 				}
-				in := newCodedBuffer(uf.Contents)
+				in := codec.NewBuffer(uf.Contents)
 				err = marshalUnknownGroupText(b, in, true)
 				if err != nil {
 					return err
@@ -360,17 +361,17 @@
 	return b.WriteByte('"')
 }
 
-func marshalUnknownGroupText(b *indentBuffer, in *codedBuffer, topLevel bool) error {
+func marshalUnknownGroupText(b *indentBuffer, in *codec.Buffer, topLevel bool) error {
 	first := true
 	for {
-		if in.eof() {
+		if in.EOF() {
 			if topLevel {
 				return nil
 			}
 			// this is a nested message: we are expecting an end-group tag, not EOF!
 			return io.ErrUnexpectedEOF
 		}
-		tag, wireType, err := in.decodeTagAndWireType()
+		tag, wireType, err := in.DecodeTagAndWireType()
 		if err != nil {
 			return err
 		}
@@ -413,7 +414,7 @@
 				return err
 			}
 			if wireType == proto.WireBytes {
-				contents, err := in.decodeRawBytes(false)
+				contents, err := in.DecodeRawBytes(false)
 				if err != nil {
 					return err
 				}
@@ -425,11 +426,11 @@
 				var v uint64
 				switch wireType {
 				case proto.WireVarint:
-					v, err = in.decodeVarint()
+					v, err = in.DecodeVarint()
 				case proto.WireFixed32:
-					v, err = in.decodeFixed32()
+					v, err = in.DecodeFixed32()
 				case proto.WireFixed64:
-					v, err = in.decodeFixed64()
+					v, err = in.DecodeFixed64()
 				default:
 					return proto.ErrInternalBadWireType
 				}