planetscale 0.3.1 → 0.3.3

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

@@ -1,176 +0,0 @@
-// Copyright 2020 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"
-
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type mergeOptions struct{}
-
-func (o mergeOptions) Merge(dst, src proto.Message) {
-	proto.Merge(dst, src)
-}
-
-// merge is protoreflect.Methods.Merge.
-func (mi *MessageInfo) merge(in piface.MergeInput) piface.MergeOutput {
-	dp, ok := mi.getPointer(in.Destination)
-	if !ok {
-		return piface.MergeOutput{}
-	}
-	sp, ok := mi.getPointer(in.Source)
-	if !ok {
-		return piface.MergeOutput{}
-	}
-	mi.mergePointer(dp, sp, mergeOptions{})
-	return piface.MergeOutput{Flags: piface.MergeComplete}
-}
-
-func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
-	mi.init()
-	if dst.IsNil() {
-		panic(fmt.Sprintf("invalid value: merging into nil message"))
-	}
-	if src.IsNil() {
-		return
-	}
-	for _, f := range mi.orderedCoderFields {
-		if f.funcs.merge == nil {
-			continue
-		}
-		sfptr := src.Apply(f.offset)
-		if f.isPointer && sfptr.Elem().IsNil() {
-			continue
-		}
-		f.funcs.merge(dst.Apply(f.offset), sfptr, f, opts)
-	}
-	if mi.extensionOffset.IsValid() {
-		sext := src.Apply(mi.extensionOffset).Extensions()
-		dext := dst.Apply(mi.extensionOffset).Extensions()
-		if *dext == nil {
-			*dext = make(map[int32]ExtensionField)
-		}
-		for num, sx := range *sext {
-			xt := sx.Type()
-			xi := getExtensionFieldInfo(xt)
-			if xi.funcs.merge == nil {
-				continue
-			}
-			dx := (*dext)[num]
-			var dv pref.Value
-			if dx.Type() == sx.Type() {
-				dv = dx.Value()
-			}
-			if !dv.IsValid() && xi.unmarshalNeedsValue {
-				dv = xt.New()
-			}
-			dv = xi.funcs.merge(dv, sx.Value(), opts)
-			dx.Set(sx.Type(), dv)
-			(*dext)[num] = dx
-		}
-	}
-	if mi.unknownOffset.IsValid() {
-		su := mi.getUnknownBytes(src)
-		if su != nil && len(*su) > 0 {
-			du := mi.mutableUnknownBytes(dst)
-			*du = append(*du, *su...)
-		}
-	}
-}
-
-func mergeScalarValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	return src
-}
-
-func mergeBytesValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	return pref.ValueOfBytes(append(emptyBuf[:], src.Bytes()...))
-}
-
-func mergeListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	dstl := dst.List()
-	srcl := src.List()
-	for i, llen := 0, srcl.Len(); i < llen; i++ {
-		dstl.Append(srcl.Get(i))
-	}
-	return dst
-}
-
-func mergeBytesListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	dstl := dst.List()
-	srcl := src.List()
-	for i, llen := 0, srcl.Len(); i < llen; i++ {
-		sb := srcl.Get(i).Bytes()
-		db := append(emptyBuf[:], sb...)
-		dstl.Append(pref.ValueOfBytes(db))
-	}
-	return dst
-}
-
-func mergeMessageListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	dstl := dst.List()
-	srcl := src.List()
-	for i, llen := 0, srcl.Len(); i < llen; i++ {
-		sm := srcl.Get(i).Message()
-		dm := proto.Clone(sm.Interface()).ProtoReflect()
-		dstl.Append(pref.ValueOfMessage(dm))
-	}
-	return dst
-}
-
-func mergeMessageValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	opts.Merge(dst.Message().Interface(), src.Message().Interface())
-	return dst
-}
-
-func mergeMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-	if f.mi != nil {
-		if dst.Elem().IsNil() {
-			dst.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
-		}
-		f.mi.mergePointer(dst.Elem(), src.Elem(), opts)
-	} else {
-		dm := dst.AsValueOf(f.ft).Elem()
-		sm := src.AsValueOf(f.ft).Elem()
-		if dm.IsNil() {
-			dm.Set(reflect.New(f.ft.Elem()))
-		}
-		opts.Merge(asMessage(dm), asMessage(sm))
-	}
-}
-
-func mergeMessageSlice(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-	for _, sp := range src.PointerSlice() {
-		dm := reflect.New(f.ft.Elem().Elem())
-		if f.mi != nil {
-			f.mi.mergePointer(pointerOfValue(dm), sp, opts)
-		} else {
-			opts.Merge(asMessage(dm), asMessage(sp.AsValueOf(f.ft.Elem().Elem())))
-		}
-		dst.AppendPointerSlice(pointerOfValue(dm))
-	}
-}
-
-func mergeBytes(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Bytes() = append(emptyBuf[:], *src.Bytes()...)
-}
-
-func mergeBytesNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Bytes()
-	if len(v) > 0 {
-		*dst.Bytes() = append(emptyBuf[:], v...)
-	}
-}
-
-func mergeBytesSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.BytesSlice()
-	for _, v := range *src.BytesSlice() {
-		*ds = append(*ds, append(emptyBuf[:], v...))
-	}
-}

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

@@ -1,209 +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 impl
-
-import ()
-
-func mergeBool(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Bool() = *src.Bool()
-}
-
-func mergeBoolNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Bool()
-	if v != false {
-		*dst.Bool() = v
-	}
-}
-
-func mergeBoolPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.BoolPtr()
-	if p != nil {
-		v := *p
-		*dst.BoolPtr() = &v
-	}
-}
-
-func mergeBoolSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.BoolSlice()
-	ss := src.BoolSlice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeInt32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Int32() = *src.Int32()
-}
-
-func mergeInt32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Int32()
-	if v != 0 {
-		*dst.Int32() = v
-	}
-}
-
-func mergeInt32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Int32Ptr()
-	if p != nil {
-		v := *p
-		*dst.Int32Ptr() = &v
-	}
-}
-
-func mergeInt32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Int32Slice()
-	ss := src.Int32Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeUint32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Uint32() = *src.Uint32()
-}
-
-func mergeUint32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Uint32()
-	if v != 0 {
-		*dst.Uint32() = v
-	}
-}
-
-func mergeUint32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Uint32Ptr()
-	if p != nil {
-		v := *p
-		*dst.Uint32Ptr() = &v
-	}
-}
-
-func mergeUint32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Uint32Slice()
-	ss := src.Uint32Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeInt64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Int64() = *src.Int64()
-}
-
-func mergeInt64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Int64()
-	if v != 0 {
-		*dst.Int64() = v
-	}
-}
-
-func mergeInt64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Int64Ptr()
-	if p != nil {
-		v := *p
-		*dst.Int64Ptr() = &v
-	}
-}
-
-func mergeInt64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Int64Slice()
-	ss := src.Int64Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeUint64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Uint64() = *src.Uint64()
-}
-
-func mergeUint64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Uint64()
-	if v != 0 {
-		*dst.Uint64() = v
-	}
-}
-
-func mergeUint64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Uint64Ptr()
-	if p != nil {
-		v := *p
-		*dst.Uint64Ptr() = &v
-	}
-}
-
-func mergeUint64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Uint64Slice()
-	ss := src.Uint64Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeFloat32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Float32() = *src.Float32()
-}
-
-func mergeFloat32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Float32()
-	if v != 0 {
-		*dst.Float32() = v
-	}
-}
-
-func mergeFloat32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Float32Ptr()
-	if p != nil {
-		v := *p
-		*dst.Float32Ptr() = &v
-	}
-}
-
-func mergeFloat32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Float32Slice()
-	ss := src.Float32Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeFloat64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Float64() = *src.Float64()
-}
-
-func mergeFloat64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Float64()
-	if v != 0 {
-		*dst.Float64() = v
-	}
-}
-
-func mergeFloat64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Float64Ptr()
-	if p != nil {
-		v := *p
-		*dst.Float64Ptr() = &v
-	}
-}
-
-func mergeFloat64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Float64Slice()
-	ss := src.Float64Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeString(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.String() = *src.String()
-}
-
-func mergeStringNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.String()
-	if v != "" {
-		*dst.String() = v
-	}
-}
-
-func mergeStringPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.StringPtr()
-	if p != nil {
-		v := *p
-		*dst.StringPtr() = &v
-	}
-}
-
-func mergeStringSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.StringSlice()
-	ss := src.StringSlice()
-	*ds = append(*ds, *ss...)
-}

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

@@ -1,276 +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"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-
-	"google.golang.org/protobuf/internal/genid"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// MessageInfo provides protobuf related functionality for a given Go type
-// that represents a message. A given instance of MessageInfo is tied to
-// exactly one Go type, which must be a pointer to a struct type.
-//
-// The exported fields must be populated before any methods are called
-// and cannot be mutated after set.
-type MessageInfo struct {
-	// GoReflectType is the underlying message Go type and must be populated.
-	GoReflectType reflect.Type // pointer to struct
-
-	// Desc is the underlying message descriptor type and must be populated.
-	Desc pref.MessageDescriptor
-
-	// Exporter must be provided in a purego environment in order to provide
-	// access to unexported fields.
-	Exporter exporter
-
-	// OneofWrappers is list of pointers to oneof wrapper struct types.
-	OneofWrappers []interface{}
-
-	initMu   sync.Mutex // protects all unexported fields
-	initDone uint32
-
-	reflectMessageInfo // for reflection implementation
-	coderMessageInfo   // for fast-path method implementations
-}
-
-// exporter is a function that returns a reference to the ith field of v,
-// where v is a pointer to a struct. It returns nil if it does not support
-// exporting the requested field (e.g., already exported).
-type exporter func(v interface{}, i int) interface{}
-
-// getMessageInfo returns the MessageInfo for any message type that
-// is generated by our implementation of protoc-gen-go (for v2 and on).
-// If it is unable to obtain a MessageInfo, it returns nil.
-func getMessageInfo(mt reflect.Type) *MessageInfo {
-	m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage)
-	if !ok {
-		return nil
-	}
-	mr, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *MessageInfo })
-	if !ok {
-		return nil
-	}
-	return mr.ProtoMessageInfo()
-}
-
-func (mi *MessageInfo) init() {
-	// This function is called in the hot path. Inline the sync.Once logic,
-	// since allocating a closure for Once.Do is expensive.
-	// Keep init small to ensure that it can be inlined.
-	if atomic.LoadUint32(&mi.initDone) == 0 {
-		mi.initOnce()
-	}
-}
-
-func (mi *MessageInfo) initOnce() {
-	mi.initMu.Lock()
-	defer mi.initMu.Unlock()
-	if mi.initDone == 1 {
-		return
-	}
-
-	t := mi.GoReflectType
-	if t.Kind() != reflect.Ptr && t.Elem().Kind() != reflect.Struct {
-		panic(fmt.Sprintf("got %v, want *struct kind", t))
-	}
-	t = t.Elem()
-
-	si := mi.makeStructInfo(t)
-	mi.makeReflectFuncs(t, si)
-	mi.makeCoderMethods(t, si)
-
-	atomic.StoreUint32(&mi.initDone, 1)
-}
-
-// getPointer returns the pointer for a message, which should be of
-// the type of the MessageInfo. If the message is of a different type,
-// it returns ok==false.
-func (mi *MessageInfo) getPointer(m pref.Message) (p pointer, ok bool) {
-	switch m := m.(type) {
-	case *messageState:
-		return m.pointer(), m.messageInfo() == mi
-	case *messageReflectWrapper:
-		return m.pointer(), m.messageInfo() == mi
-	}
-	return pointer{}, false
-}
-
-type (
-	SizeCache       = int32
-	WeakFields      = map[int32]protoreflect.ProtoMessage
-	UnknownFields   = unknownFieldsA // TODO: switch to unknownFieldsB
-	unknownFieldsA  = []byte
-	unknownFieldsB  = *[]byte
-	ExtensionFields = map[int32]ExtensionField
-)
-
-var (
-	sizecacheType       = reflect.TypeOf(SizeCache(0))
-	weakFieldsType      = reflect.TypeOf(WeakFields(nil))
-	unknownFieldsAType  = reflect.TypeOf(unknownFieldsA(nil))
-	unknownFieldsBType  = reflect.TypeOf(unknownFieldsB(nil))
-	extensionFieldsType = reflect.TypeOf(ExtensionFields(nil))
-)
-
-type structInfo struct {
-	sizecacheOffset offset
-	sizecacheType   reflect.Type
-	weakOffset      offset
-	weakType        reflect.Type
-	unknownOffset   offset
-	unknownType     reflect.Type
-	extensionOffset offset
-	extensionType   reflect.Type
-
-	fieldsByNumber        map[pref.FieldNumber]reflect.StructField
-	oneofsByName          map[pref.Name]reflect.StructField
-	oneofWrappersByType   map[reflect.Type]pref.FieldNumber
-	oneofWrappersByNumber map[pref.FieldNumber]reflect.Type
-}
-
-func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
-	si := structInfo{
-		sizecacheOffset: invalidOffset,
-		weakOffset:      invalidOffset,
-		unknownOffset:   invalidOffset,
-		extensionOffset: invalidOffset,
-
-		fieldsByNumber:        map[pref.FieldNumber]reflect.StructField{},
-		oneofsByName:          map[pref.Name]reflect.StructField{},
-		oneofWrappersByType:   map[reflect.Type]pref.FieldNumber{},
-		oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{},
-	}
-
-fieldLoop:
-	for i := 0; i < t.NumField(); i++ {
-		switch f := t.Field(i); f.Name {
-		case genid.SizeCache_goname, genid.SizeCacheA_goname:
-			if f.Type == sizecacheType {
-				si.sizecacheOffset = offsetOf(f, mi.Exporter)
-				si.sizecacheType = f.Type
-			}
-		case genid.WeakFields_goname, genid.WeakFieldsA_goname:
-			if f.Type == weakFieldsType {
-				si.weakOffset = offsetOf(f, mi.Exporter)
-				si.weakType = f.Type
-			}
-		case genid.UnknownFields_goname, genid.UnknownFieldsA_goname:
-			if f.Type == unknownFieldsAType || f.Type == unknownFieldsBType {
-				si.unknownOffset = offsetOf(f, mi.Exporter)
-				si.unknownType = f.Type
-			}
-		case genid.ExtensionFields_goname, genid.ExtensionFieldsA_goname, genid.ExtensionFieldsB_goname:
-			if f.Type == extensionFieldsType {
-				si.extensionOffset = offsetOf(f, mi.Exporter)
-				si.extensionType = f.Type
-			}
-		default:
-			for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
-				if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
-					n, _ := strconv.ParseUint(s, 10, 64)
-					si.fieldsByNumber[pref.FieldNumber(n)] = f
-					continue fieldLoop
-				}
-			}
-			if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 {
-				si.oneofsByName[pref.Name(s)] = f
-				continue fieldLoop
-			}
-		}
-	}
-
-	// Derive a mapping of oneof wrappers to fields.
-	oneofWrappers := mi.OneofWrappers
-	for _, method := range []string{"XXX_OneofFuncs", "XXX_OneofWrappers"} {
-		if fn, ok := reflect.PtrTo(t).MethodByName(method); ok {
-			for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
-				if vs, ok := v.Interface().([]interface{}); ok {
-					oneofWrappers = vs
-				}
-			}
-		}
-	}
-	for _, v := range oneofWrappers {
-		tf := reflect.TypeOf(v).Elem()
-		f := tf.Field(0)
-		for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
-			if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
-				n, _ := strconv.ParseUint(s, 10, 64)
-				si.oneofWrappersByType[tf] = pref.FieldNumber(n)
-				si.oneofWrappersByNumber[pref.FieldNumber(n)] = tf
-				break
-			}
-		}
-	}
-
-	return si
-}
-
-func (mi *MessageInfo) New() protoreflect.Message {
-	return mi.MessageOf(reflect.New(mi.GoReflectType.Elem()).Interface())
-}
-func (mi *MessageInfo) Zero() protoreflect.Message {
-	return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
-}
-func (mi *MessageInfo) Descriptor() protoreflect.MessageDescriptor {
-	return mi.Desc
-}
-func (mi *MessageInfo) Enum(i int) protoreflect.EnumType {
-	mi.init()
-	fd := mi.Desc.Fields().Get(i)
-	return Export{}.EnumTypeOf(mi.fieldTypes[fd.Number()])
-}
-func (mi *MessageInfo) Message(i int) protoreflect.MessageType {
-	mi.init()
-	fd := mi.Desc.Fields().Get(i)
-	switch {
-	case fd.IsWeak():
-		mt, _ := preg.GlobalTypes.FindMessageByName(fd.Message().FullName())
-		return mt
-	case fd.IsMap():
-		return mapEntryType{fd.Message(), mi.fieldTypes[fd.Number()]}
-	default:
-		return Export{}.MessageTypeOf(mi.fieldTypes[fd.Number()])
-	}
-}
-
-type mapEntryType struct {
-	desc    protoreflect.MessageDescriptor
-	valType interface{} // zero value of enum or message type
-}
-
-func (mt mapEntryType) New() protoreflect.Message {
-	return nil
-}
-func (mt mapEntryType) Zero() protoreflect.Message {
-	return nil
-}
-func (mt mapEntryType) Descriptor() protoreflect.MessageDescriptor {
-	return mt.desc
-}
-func (mt mapEntryType) Enum(i int) protoreflect.EnumType {
-	fd := mt.desc.Fields().Get(i)
-	if fd.Enum() == nil {
-		return nil
-	}
-	return Export{}.EnumTypeOf(mt.valType)
-}
-func (mt mapEntryType) Message(i int) protoreflect.MessageType {
-	fd := mt.desc.Fields().Get(i)
-	if fd.Message() == nil {
-		return nil
-	}
-	return Export{}.MessageTypeOf(mt.valType)
-}