planetscale 0.3.1 → 0.3.3

data/vendor/google.golang.org/protobuf/proto/encode.go

@@ -1,319 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/order"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-// MarshalOptions configures the marshaler.
-//
-// Example usage:
-//   b, err := MarshalOptions{Deterministic: true}.Marshal(m)
-type MarshalOptions struct {
-	pragma.NoUnkeyedLiterals
-
-	// AllowPartial allows messages that have missing required fields to marshal
-	// without returning an error. If AllowPartial is false (the default),
-	// Marshal will return an error if there are any missing required fields.
-	AllowPartial bool
-
-	// Deterministic controls whether the same message will always be
-	// serialized to the same bytes within the same binary.
-	//
-	// Setting this option guarantees that repeated serialization of
-	// the same message will return the same bytes, and that different
-	// processes of the same binary (which may be executing on different
-	// machines) will serialize equal messages to the same bytes.
-	// It has no effect on the resulting size of the encoded message compared
-	// to a non-deterministic marshal.
-	//
-	// Note that the deterministic serialization is NOT canonical across
-	// languages. It is not guaranteed to remain stable over time. It is
-	// unstable across different builds with schema changes due to unknown
-	// fields. Users who need canonical serialization (e.g., persistent
-	// storage in a canonical form, fingerprinting, etc.) must define
-	// their own canonicalization specification and implement their own
-	// serializer rather than relying on this API.
-	//
-	// If deterministic serialization is requested, map entries will be
-	// sorted by keys in lexographical order. This is an implementation
-	// detail and subject to change.
-	Deterministic bool
-
-	// UseCachedSize indicates that the result of a previous Size call
-	// may be reused.
-	//
-	// Setting this option asserts that:
-	//
-	// 1. Size has previously been called on this message with identical
-	// options (except for UseCachedSize itself).
-	//
-	// 2. The message and all its submessages have not changed in any
-	// way since the Size call.
-	//
-	// If either of these invariants is violated,
-	// the results are undefined and may include panics or corrupted output.
-	//
-	// Implementations MAY take this option into account to provide
-	// better performance, but there is no guarantee that they will do so.
-	// There is absolutely no guarantee that Size followed by Marshal with
-	// UseCachedSize set will perform equivalently to Marshal alone.
-	UseCachedSize bool
-}
-
-// Marshal returns the wire-format encoding of m.
-func Marshal(m Message) ([]byte, error) {
-	// Treat nil message interface as an empty message; nothing to output.
-	if m == nil {
-		return nil, nil
-	}
-
-	out, err := MarshalOptions{}.marshal(nil, m.ProtoReflect())
-	if len(out.Buf) == 0 && err == nil {
-		out.Buf = emptyBytesForMessage(m)
-	}
-	return out.Buf, err
-}
-
-// Marshal returns the wire-format encoding of m.
-func (o MarshalOptions) Marshal(m Message) ([]byte, error) {
-	// Treat nil message interface as an empty message; nothing to output.
-	if m == nil {
-		return nil, nil
-	}
-
-	out, err := o.marshal(nil, m.ProtoReflect())
-	if len(out.Buf) == 0 && err == nil {
-		out.Buf = emptyBytesForMessage(m)
-	}
-	return out.Buf, err
-}
-
-// emptyBytesForMessage returns a nil buffer if and only if m is invalid,
-// otherwise it returns a non-nil empty buffer.
-//
-// This is to assist the edge-case where user-code does the following:
-//	m1.OptionalBytes, _ = proto.Marshal(m2)
-// where they expect the proto2 "optional_bytes" field to be populated
-// if any only if m2 is a valid message.
-func emptyBytesForMessage(m Message) []byte {
-	if m == nil || !m.ProtoReflect().IsValid() {
-		return nil
-	}
-	return emptyBuf[:]
-}
-
-// MarshalAppend appends the wire-format encoding of m to b,
-// returning the result.
-func (o MarshalOptions) MarshalAppend(b []byte, m Message) ([]byte, error) {
-	// Treat nil message interface as an empty message; nothing to append.
-	if m == nil {
-		return b, nil
-	}
-
-	out, err := o.marshal(b, m.ProtoReflect())
-	return out.Buf, err
-}
-
-// MarshalState returns the wire-format encoding of a message.
-//
-// This method permits fine-grained control over the marshaler.
-// Most users should use Marshal instead.
-func (o MarshalOptions) MarshalState(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-	return o.marshal(in.Buf, in.Message)
-}
-
-// marshal is a centralized function that all marshal operations go through.
-// For profiling purposes, avoid changing the name of this function or
-// introducing other code paths for marshal that do not go through this.
-func (o MarshalOptions) marshal(b []byte, m protoreflect.Message) (out protoiface.MarshalOutput, err error) {
-	allowPartial := o.AllowPartial
-	o.AllowPartial = true
-	if methods := protoMethods(m); methods != nil && methods.Marshal != nil &&
-		!(o.Deterministic && methods.Flags&protoiface.SupportMarshalDeterministic == 0) {
-		in := protoiface.MarshalInput{
-			Message: m,
-			Buf:     b,
-		}
-		if o.Deterministic {
-			in.Flags |= protoiface.MarshalDeterministic
-		}
-		if o.UseCachedSize {
-			in.Flags |= protoiface.MarshalUseCachedSize
-		}
-		if methods.Size != nil {
-			sout := methods.Size(protoiface.SizeInput{
-				Message: m,
-				Flags:   in.Flags,
-			})
-			if cap(b) < len(b)+sout.Size {
-				in.Buf = make([]byte, len(b), growcap(cap(b), len(b)+sout.Size))
-				copy(in.Buf, b)
-			}
-			in.Flags |= protoiface.MarshalUseCachedSize
-		}
-		out, err = methods.Marshal(in)
-	} else {
-		out.Buf, err = o.marshalMessageSlow(b, m)
-	}
-	if err != nil {
-		return out, err
-	}
-	if allowPartial {
-		return out, nil
-	}
-	return out, checkInitialized(m)
-}
-
-func (o MarshalOptions) marshalMessage(b []byte, m protoreflect.Message) ([]byte, error) {
-	out, err := o.marshal(b, m)
-	return out.Buf, err
-}
-
-// growcap scales up the capacity of a slice.
-//
-// Given a slice with a current capacity of oldcap and a desired
-// capacity of wantcap, growcap returns a new capacity >= wantcap.
-//
-// The algorithm is mostly identical to the one used by append as of Go 1.14.
-func growcap(oldcap, wantcap int) (newcap int) {
-	if wantcap > oldcap*2 {
-		newcap = wantcap
-	} else if oldcap < 1024 {
-		// The Go 1.14 runtime takes this case when len(s) < 1024,
-		// not when cap(s) < 1024. The difference doesn't seem
-		// significant here.
-		newcap = oldcap * 2
-	} else {
-		newcap = oldcap
-		for 0 < newcap && newcap < wantcap {
-			newcap += newcap / 4
-		}
-		if newcap <= 0 {
-			newcap = wantcap
-		}
-	}
-	return newcap
-}
-
-func (o MarshalOptions) marshalMessageSlow(b []byte, m protoreflect.Message) ([]byte, error) {
-	if messageset.IsMessageSet(m.Descriptor()) {
-		return o.marshalMessageSet(b, m)
-	}
-	fieldOrder := order.AnyFieldOrder
-	if o.Deterministic {
-		// TODO: This should use a more natural ordering like NumberFieldOrder,
-		// but doing so breaks golden tests that make invalid assumption about
-		// output stability of this implementation.
-		fieldOrder = order.LegacyFieldOrder
-	}
-	var err error
-	order.RangeFields(m, fieldOrder, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		b, err = o.marshalField(b, fd, v)
-		return err == nil
-	})
-	if err != nil {
-		return b, err
-	}
-	b = append(b, m.GetUnknown()...)
-	return b, nil
-}
-
-func (o MarshalOptions) marshalField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value) ([]byte, error) {
-	switch {
-	case fd.IsList():
-		return o.marshalList(b, fd, value.List())
-	case fd.IsMap():
-		return o.marshalMap(b, fd, value.Map())
-	default:
-		b = protowire.AppendTag(b, fd.Number(), wireTypes[fd.Kind()])
-		return o.marshalSingular(b, fd, value)
-	}
-}
-
-func (o MarshalOptions) marshalList(b []byte, fd protoreflect.FieldDescriptor, list protoreflect.List) ([]byte, error) {
-	if fd.IsPacked() && list.Len() > 0 {
-		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
-		b, pos := appendSpeculativeLength(b)
-		for i, llen := 0, list.Len(); i < llen; i++ {
-			var err error
-			b, err = o.marshalSingular(b, fd, list.Get(i))
-			if err != nil {
-				return b, err
-			}
-		}
-		b = finishSpeculativeLength(b, pos)
-		return b, nil
-	}
-
-	kind := fd.Kind()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		var err error
-		b = protowire.AppendTag(b, fd.Number(), wireTypes[kind])
-		b, err = o.marshalSingular(b, fd, list.Get(i))
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-func (o MarshalOptions) marshalMap(b []byte, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) ([]byte, error) {
-	keyf := fd.MapKey()
-	valf := fd.MapValue()
-	keyOrder := order.AnyKeyOrder
-	if o.Deterministic {
-		keyOrder = order.GenericKeyOrder
-	}
-	var err error
-	order.RangeEntries(mapv, keyOrder, func(key protoreflect.MapKey, value protoreflect.Value) bool {
-		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
-		var pos int
-		b, pos = appendSpeculativeLength(b)
-
-		b, err = o.marshalField(b, keyf, key.Value())
-		if err != nil {
-			return false
-		}
-		b, err = o.marshalField(b, valf, value)
-		if err != nil {
-			return false
-		}
-		b = finishSpeculativeLength(b, pos)
-		return true
-	})
-	return b, err
-}
-
-// When encoding length-prefixed fields, we speculatively set aside some number of bytes
-// for the length, encode the data, and then encode the length (shifting the data if necessary
-// to make room).
-const speculativeLength = 1
-
-func appendSpeculativeLength(b []byte) ([]byte, int) {
-	pos := len(b)
-	b = append(b, "\x00\x00\x00\x00"[:speculativeLength]...)
-	return b, pos
-}
-
-func finishSpeculativeLength(b []byte, pos int) []byte {
-	mlen := len(b) - pos - speculativeLength
-	msiz := protowire.SizeVarint(uint64(mlen))
-	if msiz != speculativeLength {
-		for i := 0; i < msiz-speculativeLength; i++ {
-			b = append(b, 0)
-		}
-		copy(b[pos+msiz:], b[pos+speculativeLength:])
-		b = b[:pos+msiz+mlen]
-	}
-	protowire.AppendVarint(b[:pos], uint64(mlen))
-	return b
-}

data/vendor/google.golang.org/protobuf/proto/encode_gen.go

@@ -1,97 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package proto
-
-import (
-	"math"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-var wireTypes = map[protoreflect.Kind]protowire.Type{
-	protoreflect.BoolKind:     protowire.VarintType,
-	protoreflect.EnumKind:     protowire.VarintType,
-	protoreflect.Int32Kind:    protowire.VarintType,
-	protoreflect.Sint32Kind:   protowire.VarintType,
-	protoreflect.Uint32Kind:   protowire.VarintType,
-	protoreflect.Int64Kind:    protowire.VarintType,
-	protoreflect.Sint64Kind:   protowire.VarintType,
-	protoreflect.Uint64Kind:   protowire.VarintType,
-	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
-	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
-	protoreflect.FloatKind:    protowire.Fixed32Type,
-	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
-	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
-	protoreflect.DoubleKind:   protowire.Fixed64Type,
-	protoreflect.StringKind:   protowire.BytesType,
-	protoreflect.BytesKind:    protowire.BytesType,
-	protoreflect.MessageKind:  protowire.BytesType,
-	protoreflect.GroupKind:    protowire.StartGroupType,
-}
-
-func (o MarshalOptions) marshalSingular(b []byte, fd protoreflect.FieldDescriptor, v protoreflect.Value) ([]byte, error) {
-	switch fd.Kind() {
-	case protoreflect.BoolKind:
-		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
-	case protoreflect.EnumKind:
-		b = protowire.AppendVarint(b, uint64(v.Enum()))
-	case protoreflect.Int32Kind:
-		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
-	case protoreflect.Sint32Kind:
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
-	case protoreflect.Uint32Kind:
-		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
-	case protoreflect.Int64Kind:
-		b = protowire.AppendVarint(b, uint64(v.Int()))
-	case protoreflect.Sint64Kind:
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
-	case protoreflect.Uint64Kind:
-		b = protowire.AppendVarint(b, v.Uint())
-	case protoreflect.Sfixed32Kind:
-		b = protowire.AppendFixed32(b, uint32(v.Int()))
-	case protoreflect.Fixed32Kind:
-		b = protowire.AppendFixed32(b, uint32(v.Uint()))
-	case protoreflect.FloatKind:
-		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
-	case protoreflect.Sfixed64Kind:
-		b = protowire.AppendFixed64(b, uint64(v.Int()))
-	case protoreflect.Fixed64Kind:
-		b = protowire.AppendFixed64(b, v.Uint())
-	case protoreflect.DoubleKind:
-		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
-	case protoreflect.StringKind:
-		if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
-			return b, errors.InvalidUTF8(string(fd.FullName()))
-		}
-		b = protowire.AppendString(b, v.String())
-	case protoreflect.BytesKind:
-		b = protowire.AppendBytes(b, v.Bytes())
-	case protoreflect.MessageKind:
-		var pos int
-		var err error
-		b, pos = appendSpeculativeLength(b)
-		b, err = o.marshalMessage(b, v.Message())
-		if err != nil {
-			return b, err
-		}
-		b = finishSpeculativeLength(b, pos)
-	case protoreflect.GroupKind:
-		var err error
-		b, err = o.marshalMessage(b, v.Message())
-		if err != nil {
-			return b, err
-		}
-		b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
-	default:
-		return b, errors.New("invalid kind %v", fd.Kind())
-	}
-	return b, nil
-}

data/vendor/google.golang.org/protobuf/proto/equal.go

@@ -1,167 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"bytes"
-	"math"
-	"reflect"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Equal reports whether two messages are equal.
-// If two messages marshal to the same bytes under deterministic serialization,
-// then Equal is guaranteed to report true.
-//
-// Two messages are equal if they belong to the same message descriptor,
-// have the same set of populated known and extension field values,
-// and the same set of unknown fields values. If either of the top-level
-// messages are invalid, then Equal reports true only if both are invalid.
-//
-// Scalar values are compared with the equivalent of the == operator in Go,
-// except bytes values which are compared using bytes.Equal and
-// floating point values which specially treat NaNs as equal.
-// Message values are compared by recursively calling Equal.
-// Lists are equal if each element value is also equal.
-// Maps are equal if they have the same set of keys, where the pair of values
-// for each key is also equal.
-func Equal(x, y Message) bool {
-	if x == nil || y == nil {
-		return x == nil && y == nil
-	}
-	mx := x.ProtoReflect()
-	my := y.ProtoReflect()
-	if mx.IsValid() != my.IsValid() {
-		return false
-	}
-	return equalMessage(mx, my)
-}
-
-// equalMessage compares two messages.
-func equalMessage(mx, my pref.Message) bool {
-	if mx.Descriptor() != my.Descriptor() {
-		return false
-	}
-
-	nx := 0
-	equal := true
-	mx.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
-		nx++
-		vy := my.Get(fd)
-		equal = my.Has(fd) && equalField(fd, vx, vy)
-		return equal
-	})
-	if !equal {
-		return false
-	}
-	ny := 0
-	my.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
-		ny++
-		return true
-	})
-	if nx != ny {
-		return false
-	}
-
-	return equalUnknown(mx.GetUnknown(), my.GetUnknown())
-}
-
-// equalField compares two fields.
-func equalField(fd pref.FieldDescriptor, x, y pref.Value) bool {
-	switch {
-	case fd.IsList():
-		return equalList(fd, x.List(), y.List())
-	case fd.IsMap():
-		return equalMap(fd, x.Map(), y.Map())
-	default:
-		return equalValue(fd, x, y)
-	}
-}
-
-// equalMap compares two maps.
-func equalMap(fd pref.FieldDescriptor, x, y pref.Map) bool {
-	if x.Len() != y.Len() {
-		return false
-	}
-	equal := true
-	x.Range(func(k pref.MapKey, vx pref.Value) bool {
-		vy := y.Get(k)
-		equal = y.Has(k) && equalValue(fd.MapValue(), vx, vy)
-		return equal
-	})
-	return equal
-}
-
-// equalList compares two lists.
-func equalList(fd pref.FieldDescriptor, x, y pref.List) bool {
-	if x.Len() != y.Len() {
-		return false
-	}
-	for i := x.Len() - 1; i >= 0; i-- {
-		if !equalValue(fd, x.Get(i), y.Get(i)) {
-			return false
-		}
-	}
-	return true
-}
-
-// equalValue compares two singular values.
-func equalValue(fd pref.FieldDescriptor, x, y pref.Value) bool {
-	switch fd.Kind() {
-	case pref.BoolKind:
-		return x.Bool() == y.Bool()
-	case pref.EnumKind:
-		return x.Enum() == y.Enum()
-	case pref.Int32Kind, pref.Sint32Kind,
-		pref.Int64Kind, pref.Sint64Kind,
-		pref.Sfixed32Kind, pref.Sfixed64Kind:
-		return x.Int() == y.Int()
-	case pref.Uint32Kind, pref.Uint64Kind,
-		pref.Fixed32Kind, pref.Fixed64Kind:
-		return x.Uint() == y.Uint()
-	case pref.FloatKind, pref.DoubleKind:
-		fx := x.Float()
-		fy := y.Float()
-		if math.IsNaN(fx) || math.IsNaN(fy) {
-			return math.IsNaN(fx) && math.IsNaN(fy)
-		}
-		return fx == fy
-	case pref.StringKind:
-		return x.String() == y.String()
-	case pref.BytesKind:
-		return bytes.Equal(x.Bytes(), y.Bytes())
-	case pref.MessageKind, pref.GroupKind:
-		return equalMessage(x.Message(), y.Message())
-	default:
-		return x.Interface() == y.Interface()
-	}
-}
-
-// equalUnknown compares unknown fields by direct comparison on the raw bytes
-// of each individual field number.
-func equalUnknown(x, y pref.RawFields) bool {
-	if len(x) != len(y) {
-		return false
-	}
-	if bytes.Equal([]byte(x), []byte(y)) {
-		return true
-	}
-
-	mx := make(map[pref.FieldNumber]pref.RawFields)
-	my := make(map[pref.FieldNumber]pref.RawFields)
-	for len(x) > 0 {
-		fnum, _, n := protowire.ConsumeField(x)
-		mx[fnum] = append(mx[fnum], x[:n]...)
-		x = x[n:]
-	}
-	for len(y) > 0 {
-		fnum, _, n := protowire.ConsumeField(y)
-		my[fnum] = append(my[fnum], y[:n]...)
-		y = y[n:]
-	}
-	return reflect.DeepEqual(mx, my)
-}

data/vendor/google.golang.org/protobuf/proto/extension.go

@@ -1,92 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// HasExtension reports whether an extension field is populated.
-// It returns false if m is invalid or if xt does not extend m.
-func HasExtension(m Message, xt protoreflect.ExtensionType) bool {
-	// Treat nil message interface as an empty message; no populated fields.
-	if m == nil {
-		return false
-	}
-
-	// As a special-case, we reports invalid or mismatching descriptors
-	// as always not being populated (since they aren't).
-	if xt == nil || m.ProtoReflect().Descriptor() != xt.TypeDescriptor().ContainingMessage() {
-		return false
-	}
-
-	return m.ProtoReflect().Has(xt.TypeDescriptor())
-}
-
-// ClearExtension clears an extension field such that subsequent
-// HasExtension calls return false.
-// It panics if m is invalid or if xt does not extend m.
-func ClearExtension(m Message, xt protoreflect.ExtensionType) {
-	m.ProtoReflect().Clear(xt.TypeDescriptor())
-}
-
-// GetExtension retrieves the value for an extension field.
-// If the field is unpopulated, it returns the default value for
-// scalars and an immutable, empty value for lists or messages.
-// It panics if xt does not extend m.
-func GetExtension(m Message, xt protoreflect.ExtensionType) interface{} {
-	// Treat nil message interface as an empty message; return the default.
-	if m == nil {
-		return xt.InterfaceOf(xt.Zero())
-	}
-
-	return xt.InterfaceOf(m.ProtoReflect().Get(xt.TypeDescriptor()))
-}
-
-// SetExtension stores the value of an extension field.
-// It panics if m is invalid, xt does not extend m, or if type of v
-// is invalid for the specified extension field.
-func SetExtension(m Message, xt protoreflect.ExtensionType, v interface{}) {
-	xd := xt.TypeDescriptor()
-	pv := xt.ValueOf(v)
-
-	// Specially treat an invalid list, map, or message as clear.
-	isValid := true
-	switch {
-	case xd.IsList():
-		isValid = pv.List().IsValid()
-	case xd.IsMap():
-		isValid = pv.Map().IsValid()
-	case xd.Message() != nil:
-		isValid = pv.Message().IsValid()
-	}
-	if !isValid {
-		m.ProtoReflect().Clear(xd)
-		return
-	}
-
-	m.ProtoReflect().Set(xd, pv)
-}
-
-// RangeExtensions iterates over every populated extension field in m in an
-// undefined order, calling f for each extension type and value encountered.
-// It returns immediately if f returns false.
-// While iterating, mutating operations may only be performed
-// on the current extension field.
-func RangeExtensions(m Message, f func(protoreflect.ExtensionType, interface{}) bool) {
-	// Treat nil message interface as an empty message; nothing to range over.
-	if m == nil {
-		return
-	}
-
-	m.ProtoReflect().Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		if fd.IsExtension() {
-			xt := fd.(protoreflect.ExtensionTypeDescriptor).Type()
-			vi := xt.InterfaceOf(v)
-			return f(xt, vi)
-		}
-		return true
-	})
-}