planetscale 0.2.0 → 0.3.3

data/vendor/google.golang.org/protobuf/internal/impl/convert_map.go

@@ -1,121 +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.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type mapConverter struct {
-	goType           reflect.Type // map[K]V
-	keyConv, valConv Converter
-}
-
-func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
-	if t.Kind() != reflect.Map {
-		panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-	}
-	return &mapConverter{
-		goType:  t,
-		keyConv: newSingularConverter(t.Key(), fd.MapKey()),
-		valConv: newSingularConverter(t.Elem(), fd.MapValue()),
-	}
-}
-
-func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
-}
-
-func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
-	return v.Map().(*mapReflect).v
-}
-
-func (c *mapConverter) IsValidPB(v pref.Value) bool {
-	mapv, ok := v.Interface().(*mapReflect)
-	if !ok {
-		return false
-	}
-	return mapv.v.Type() == c.goType
-}
-
-func (c *mapConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *mapConverter) New() pref.Value {
-	return c.PBValueOf(reflect.MakeMap(c.goType))
-}
-
-func (c *mapConverter) Zero() pref.Value {
-	return c.PBValueOf(reflect.Zero(c.goType))
-}
-
-type mapReflect struct {
-	v       reflect.Value // map[K]V
-	keyConv Converter
-	valConv Converter
-}
-
-func (ms *mapReflect) Len() int {
-	return ms.v.Len()
-}
-func (ms *mapReflect) Has(k pref.MapKey) bool {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	rv := ms.v.MapIndex(rk)
-	return rv.IsValid()
-}
-func (ms *mapReflect) Get(k pref.MapKey) pref.Value {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	rv := ms.v.MapIndex(rk)
-	if !rv.IsValid() {
-		return pref.Value{}
-	}
-	return ms.valConv.PBValueOf(rv)
-}
-func (ms *mapReflect) Set(k pref.MapKey, v pref.Value) {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	rv := ms.valConv.GoValueOf(v)
-	ms.v.SetMapIndex(rk, rv)
-}
-func (ms *mapReflect) Clear(k pref.MapKey) {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	ms.v.SetMapIndex(rk, reflect.Value{})
-}
-func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value {
-	if _, ok := ms.valConv.(*messageConverter); !ok {
-		panic("invalid Mutable on map with non-message value type")
-	}
-	v := ms.Get(k)
-	if !v.IsValid() {
-		v = ms.NewValue()
-		ms.Set(k, v)
-	}
-	return v
-}
-func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
-	iter := mapRange(ms.v)
-	for iter.Next() {
-		k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
-		v := ms.valConv.PBValueOf(iter.Value())
-		if !f(k, v) {
-			return
-		}
-	}
-}
-func (ms *mapReflect) NewValue() pref.Value {
-	return ms.valConv.New()
-}
-func (ms *mapReflect) IsValid() bool {
-	return !ms.v.IsNil()
-}
-func (ms *mapReflect) protoUnwrap() interface{} {
-	return ms.v.Interface()
-}

data/vendor/google.golang.org/protobuf/internal/impl/decode.go

@@ -1,276 +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 impl
-
-import (
-	"math/bits"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-	"google.golang.org/protobuf/runtime/protoiface"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-var errDecode = errors.New("cannot parse invalid wire-format data")
-
-type unmarshalOptions struct {
-	flags    protoiface.UnmarshalInputFlags
-	resolver interface {
-		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
-		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
-	}
-}
-
-func (o unmarshalOptions) Options() proto.UnmarshalOptions {
-	return proto.UnmarshalOptions{
-		Merge:          true,
-		AllowPartial:   true,
-		DiscardUnknown: o.DiscardUnknown(),
-		Resolver:       o.resolver,
-	}
-}
-
-func (o unmarshalOptions) DiscardUnknown() bool { return o.flags&piface.UnmarshalDiscardUnknown != 0 }
-
-func (o unmarshalOptions) IsDefault() bool {
-	return o.flags == 0 && o.resolver == preg.GlobalTypes
-}
-
-var lazyUnmarshalOptions = unmarshalOptions{
-	resolver: preg.GlobalTypes,
-}
-
-type unmarshalOutput struct {
-	n           int // number of bytes consumed
-	initialized bool
-}
-
-// unmarshal is protoreflect.Methods.Unmarshal.
-func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
-	var p pointer
-	if ms, ok := in.Message.(*messageState); ok {
-		p = ms.pointer()
-	} else {
-		p = in.Message.(*messageReflectWrapper).pointer()
-	}
-	out, err := mi.unmarshalPointer(in.Buf, p, 0, unmarshalOptions{
-		flags:    in.Flags,
-		resolver: in.Resolver,
-	})
-	var flags piface.UnmarshalOutputFlags
-	if out.initialized {
-		flags |= piface.UnmarshalInitialized
-	}
-	return piface.UnmarshalOutput{
-		Flags: flags,
-	}, err
-}
-
-// errUnknown is returned during unmarshaling to indicate a parse error that
-// should result in a field being placed in the unknown fields section (for example,
-// when the wire type doesn't match) as opposed to the entire unmarshal operation
-// failing (for example, when a field extends past the available input).
-//
-// This is a sentinel error which should never be visible to the user.
-var errUnknown = errors.New("unknown")
-
-func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	mi.init()
-	if flags.ProtoLegacy && mi.isMessageSet {
-		return unmarshalMessageSet(mi, b, p, opts)
-	}
-	initialized := true
-	var requiredMask uint64
-	var exts *map[int32]ExtensionField
-	start := len(b)
-	for len(b) > 0 {
-		// Parse the tag (field number and wire type).
-		var tag uint64
-		if b[0] < 0x80 {
-			tag = uint64(b[0])
-			b = b[1:]
-		} else if len(b) >= 2 && b[1] < 128 {
-			tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
-			b = b[2:]
-		} else {
-			var n int
-			tag, n = protowire.ConsumeVarint(b)
-			if n < 0 {
-				return out, errDecode
-			}
-			b = b[n:]
-		}
-		var num protowire.Number
-		if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
-			return out, errDecode
-		} else {
-			num = protowire.Number(n)
-		}
-		wtyp := protowire.Type(tag & 7)
-
-		if wtyp == protowire.EndGroupType {
-			if num != groupTag {
-				return out, errDecode
-			}
-			groupTag = 0
-			break
-		}
-
-		var f *coderFieldInfo
-		if int(num) < len(mi.denseCoderFields) {
-			f = mi.denseCoderFields[num]
-		} else {
-			f = mi.coderFields[num]
-		}
-		var n int
-		err := errUnknown
-		switch {
-		case f != nil:
-			if f.funcs.unmarshal == nil {
-				break
-			}
-			var o unmarshalOutput
-			o, err = f.funcs.unmarshal(b, p.Apply(f.offset), wtyp, f, opts)
-			n = o.n
-			if err != nil {
-				break
-			}
-			requiredMask |= f.validation.requiredBit
-			if f.funcs.isInit != nil && !o.initialized {
-				initialized = false
-			}
-		default:
-			// Possible extension.
-			if exts == nil && mi.extensionOffset.IsValid() {
-				exts = p.Apply(mi.extensionOffset).Extensions()
-				if *exts == nil {
-					*exts = make(map[int32]ExtensionField)
-				}
-			}
-			if exts == nil {
-				break
-			}
-			var o unmarshalOutput
-			o, err = mi.unmarshalExtension(b, num, wtyp, *exts, opts)
-			if err != nil {
-				break
-			}
-			n = o.n
-			if !o.initialized {
-				initialized = false
-			}
-		}
-		if err != nil {
-			if err != errUnknown {
-				return out, err
-			}
-			n = protowire.ConsumeFieldValue(num, wtyp, b)
-			if n < 0 {
-				return out, errDecode
-			}
-			if !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
-				u := mi.mutableUnknownBytes(p)
-				*u = protowire.AppendTag(*u, num, wtyp)
-				*u = append(*u, b[:n]...)
-			}
-		}
-		b = b[n:]
-	}
-	if groupTag != 0 {
-		return out, errDecode
-	}
-	if mi.numRequiredFields > 0 && bits.OnesCount64(requiredMask) != int(mi.numRequiredFields) {
-		initialized = false
-	}
-	if initialized {
-		out.initialized = true
-	}
-	out.n = start - len(b)
-	return out, nil
-}
-
-func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp protowire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	x := exts[int32(num)]
-	xt := x.Type()
-	if xt == nil {
-		var err error
-		xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
-		if err != nil {
-			if err == preg.NotFound {
-				return out, errUnknown
-			}
-			return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)
-		}
-	}
-	xi := getExtensionFieldInfo(xt)
-	if xi.funcs.unmarshal == nil {
-		return out, errUnknown
-	}
-	if flags.LazyUnmarshalExtensions {
-		if opts.IsDefault() && x.canLazy(xt) {
-			out, valid := skipExtension(b, xi, num, wtyp, opts)
-			switch valid {
-			case ValidationValid:
-				if out.initialized {
-					x.appendLazyBytes(xt, xi, num, wtyp, b[:out.n])
-					exts[int32(num)] = x
-					return out, nil
-				}
-			case ValidationInvalid:
-				return out, errDecode
-			case ValidationUnknown:
-			}
-		}
-	}
-	ival := x.Value()
-	if !ival.IsValid() && xi.unmarshalNeedsValue {
-		// Create a new message, list, or map value to fill in.
-		// For enums, create a prototype value to let the unmarshal func know the
-		// concrete type.
-		ival = xt.New()
-	}
-	v, out, err := xi.funcs.unmarshal(b, ival, num, wtyp, opts)
-	if err != nil {
-		return out, err
-	}
-	if xi.funcs.isInit == nil {
-		out.initialized = true
-	}
-	x.Set(xt, v)
-	exts[int32(num)] = x
-	return out, nil
-}
-
-func skipExtension(b []byte, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
-	if xi.validation.mi == nil {
-		return out, ValidationUnknown
-	}
-	xi.validation.mi.init()
-	switch xi.validation.typ {
-	case validationTypeMessage:
-		if wtyp != protowire.BytesType {
-			return out, ValidationUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, ValidationUnknown
-		}
-		out, st := xi.validation.mi.validate(v, 0, opts)
-		out.n = n
-		return out, st
-	case validationTypeGroup:
-		if wtyp != protowire.StartGroupType {
-			return out, ValidationUnknown
-		}
-		out, st := xi.validation.mi.validate(b, num, opts)
-		return out, st
-	default:
-		return out, ValidationUnknown
-	}
-}

data/vendor/google.golang.org/protobuf/internal/impl/encode.go

@@ -1,201 +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 impl
-
-import (
-	"math"
-	"sort"
-	"sync/atomic"
-
-	"google.golang.org/protobuf/internal/flags"
-	proto "google.golang.org/protobuf/proto"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type marshalOptions struct {
-	flags piface.MarshalInputFlags
-}
-
-func (o marshalOptions) Options() proto.MarshalOptions {
-	return proto.MarshalOptions{
-		AllowPartial:  true,
-		Deterministic: o.Deterministic(),
-		UseCachedSize: o.UseCachedSize(),
-	}
-}
-
-func (o marshalOptions) Deterministic() bool { return o.flags&piface.MarshalDeterministic != 0 }
-func (o marshalOptions) UseCachedSize() bool { return o.flags&piface.MarshalUseCachedSize != 0 }
-
-// size is protoreflect.Methods.Size.
-func (mi *MessageInfo) size(in piface.SizeInput) piface.SizeOutput {
-	var p pointer
-	if ms, ok := in.Message.(*messageState); ok {
-		p = ms.pointer()
-	} else {
-		p = in.Message.(*messageReflectWrapper).pointer()
-	}
-	size := mi.sizePointer(p, marshalOptions{
-		flags: in.Flags,
-	})
-	return piface.SizeOutput{Size: size}
-}
-
-func (mi *MessageInfo) sizePointer(p pointer, opts marshalOptions) (size int) {
-	mi.init()
-	if p.IsNil() {
-		return 0
-	}
-	if opts.UseCachedSize() && mi.sizecacheOffset.IsValid() {
-		if size := atomic.LoadInt32(p.Apply(mi.sizecacheOffset).Int32()); size >= 0 {
-			return int(size)
-		}
-	}
-	return mi.sizePointerSlow(p, opts)
-}
-
-func (mi *MessageInfo) sizePointerSlow(p pointer, opts marshalOptions) (size int) {
-	if flags.ProtoLegacy && mi.isMessageSet {
-		size = sizeMessageSet(mi, p, opts)
-		if mi.sizecacheOffset.IsValid() {
-			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
-		}
-		return size
-	}
-	if mi.extensionOffset.IsValid() {
-		e := p.Apply(mi.extensionOffset).Extensions()
-		size += mi.sizeExtensions(e, opts)
-	}
-	for _, f := range mi.orderedCoderFields {
-		if f.funcs.size == nil {
-			continue
-		}
-		fptr := p.Apply(f.offset)
-		if f.isPointer && fptr.Elem().IsNil() {
-			continue
-		}
-		size += f.funcs.size(fptr, f, opts)
-	}
-	if mi.unknownOffset.IsValid() {
-		if u := mi.getUnknownBytes(p); u != nil {
-			size += len(*u)
-		}
-	}
-	if mi.sizecacheOffset.IsValid() {
-		if size > math.MaxInt32 {
-			// The size is too large for the int32 sizecache field.
-			// We will need to recompute the size when encoding;
-			// unfortunately expensive, but better than invalid output.
-			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), -1)
-		} else {
-			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
-		}
-	}
-	return size
-}
-
-// marshal is protoreflect.Methods.Marshal.
-func (mi *MessageInfo) marshal(in piface.MarshalInput) (out piface.MarshalOutput, err error) {
-	var p pointer
-	if ms, ok := in.Message.(*messageState); ok {
-		p = ms.pointer()
-	} else {
-		p = in.Message.(*messageReflectWrapper).pointer()
-	}
-	b, err := mi.marshalAppendPointer(in.Buf, p, marshalOptions{
-		flags: in.Flags,
-	})
-	return piface.MarshalOutput{Buf: b}, err
-}
-
-func (mi *MessageInfo) marshalAppendPointer(b []byte, p pointer, opts marshalOptions) ([]byte, error) {
-	mi.init()
-	if p.IsNil() {
-		return b, nil
-	}
-	if flags.ProtoLegacy && mi.isMessageSet {
-		return marshalMessageSet(mi, b, p, opts)
-	}
-	var err error
-	// The old marshaler encodes extensions at beginning.
-	if mi.extensionOffset.IsValid() {
-		e := p.Apply(mi.extensionOffset).Extensions()
-		// TODO: Special handling for MessageSet?
-		b, err = mi.appendExtensions(b, e, opts)
-		if err != nil {
-			return b, err
-		}
-	}
-	for _, f := range mi.orderedCoderFields {
-		if f.funcs.marshal == nil {
-			continue
-		}
-		fptr := p.Apply(f.offset)
-		if f.isPointer && fptr.Elem().IsNil() {
-			continue
-		}
-		b, err = f.funcs.marshal(b, fptr, f, opts)
-		if err != nil {
-			return b, err
-		}
-	}
-	if mi.unknownOffset.IsValid() && !mi.isMessageSet {
-		if u := mi.getUnknownBytes(p); u != nil {
-			b = append(b, (*u)...)
-		}
-	}
-	return b, nil
-}
-
-func (mi *MessageInfo) sizeExtensions(ext *map[int32]ExtensionField, opts marshalOptions) (n int) {
-	if ext == nil {
-		return 0
-	}
-	for _, x := range *ext {
-		xi := getExtensionFieldInfo(x.Type())
-		if xi.funcs.size == nil {
-			continue
-		}
-		n += xi.funcs.size(x.Value(), xi.tagsize, opts)
-	}
-	return n
-}
-
-func (mi *MessageInfo) appendExtensions(b []byte, ext *map[int32]ExtensionField, opts marshalOptions) ([]byte, error) {
-	if ext == nil {
-		return b, nil
-	}
-
-	switch len(*ext) {
-	case 0:
-		return b, nil
-	case 1:
-		// Fast-path for one extension: Don't bother sorting the keys.
-		var err error
-		for _, x := range *ext {
-			xi := getExtensionFieldInfo(x.Type())
-			b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
-		}
-		return b, err
-	default:
-		// Sort the keys to provide a deterministic encoding.
-		// Not sure this is required, but the old code does it.
-		keys := make([]int, 0, len(*ext))
-		for k := range *ext {
-			keys = append(keys, int(k))
-		}
-		sort.Ints(keys)
-		var err error
-		for _, k := range keys {
-			x := (*ext)[int32(k)]
-			xi := getExtensionFieldInfo(x.Type())
-			b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
-			if err != nil {
-				return b, err
-			}
-		}
-		return b, nil
-	}
-}

data/vendor/google.golang.org/protobuf/internal/impl/enum.go

@@ -1,21 +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 impl
-
-import (
-	"reflect"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type EnumInfo struct {
-	GoReflectType reflect.Type // int32 kind
-	Desc          pref.EnumDescriptor
-}
-
-func (t *EnumInfo) New(n pref.EnumNumber) pref.Enum {
-	return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum)
-}
-func (t *EnumInfo) Descriptor() pref.EnumDescriptor { return t.Desc }