Source file src/google.golang.org/protobuf/encoding/protojson/decode.go

Documentation: google.golang.org/protobuf/encoding/protojson

     1  // Copyright 2019 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package protojson
     6  
     7  import (
     8  	"encoding/base64"
     9  	"fmt"
    10  	"math"
    11  	"strconv"
    12  	"strings"
    13  
    14  	"google.golang.org/protobuf/encoding/protowire"
    15  	"google.golang.org/protobuf/internal/encoding/json"
    16  	"google.golang.org/protobuf/internal/encoding/messageset"
    17  	"google.golang.org/protobuf/internal/errors"
    18  	"google.golang.org/protobuf/internal/flags"
    19  	"google.golang.org/protobuf/internal/genid"
    20  	"google.golang.org/protobuf/internal/pragma"
    21  	"google.golang.org/protobuf/internal/set"
    22  	"google.golang.org/protobuf/proto"
    23  	"google.golang.org/protobuf/reflect/protoreflect"
    24  	"google.golang.org/protobuf/reflect/protoregistry"
    25  )
    26  
    27  // Unmarshal reads the given []byte into the given [proto.Message].
    28  // The provided message must be mutable (e.g., a non-nil pointer to a message).
    29  func Unmarshal(b []byte, m proto.Message) error {
    30  	return UnmarshalOptions{}.Unmarshal(b, m)
    31  }
    32  
    33  // UnmarshalOptions is a configurable JSON format parser.
    34  type UnmarshalOptions struct {
    35  	pragma.NoUnkeyedLiterals
    36  
    37  	// If AllowPartial is set, input for messages that will result in missing
    38  	// required fields will not return an error.
    39  	AllowPartial bool
    40  
    41  	// If DiscardUnknown is set, unknown fields and enum name values are ignored.
    42  	DiscardUnknown bool
    43  
    44  	// Resolver is used for looking up types when unmarshaling
    45  	// google.protobuf.Any messages or extension fields.
    46  	// If nil, this defaults to using protoregistry.GlobalTypes.
    47  	Resolver interface {
    48  		protoregistry.MessageTypeResolver
    49  		protoregistry.ExtensionTypeResolver
    50  	}
    51  
    52  	// RecursionLimit limits how deeply messages may be nested.
    53  	// If zero, a default limit is applied.
    54  	RecursionLimit int
    55  }
    56  
    57  // Unmarshal reads the given []byte and populates the given [proto.Message]
    58  // using options in the UnmarshalOptions object.
    59  // It will clear the message first before setting the fields.
    60  // If it returns an error, the given message may be partially set.
    61  // The provided message must be mutable (e.g., a non-nil pointer to a message).
    62  func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
    63  	return o.unmarshal(b, m)
    64  }
    65  
    66  // unmarshal is a centralized function that all unmarshal operations go through.
    67  // For profiling purposes, avoid changing the name of this function or
    68  // introducing other code paths for unmarshal that do not go through this.
    69  func (o UnmarshalOptions) unmarshal(b []byte, m proto.Message) error {
    70  	proto.Reset(m)
    71  
    72  	if o.Resolver == nil {
    73  		o.Resolver = protoregistry.GlobalTypes
    74  	}
    75  	if o.RecursionLimit == 0 {
    76  		o.RecursionLimit = protowire.DefaultRecursionLimit
    77  	}
    78  
    79  	dec := decoder{json.NewDecoder(b), o}
    80  	if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
    81  		return err
    82  	}
    83  
    84  	// Check for EOF.
    85  	tok, err := dec.Read()
    86  	if err != nil {
    87  		return err
    88  	}
    89  	if tok.Kind() != json.EOF {
    90  		return dec.unexpectedTokenError(tok)
    91  	}
    92  
    93  	if o.AllowPartial {
    94  		return nil
    95  	}
    96  	return proto.CheckInitialized(m)
    97  }
    98  
    99  type decoder struct {
   100  	*json.Decoder
   101  	opts UnmarshalOptions
   102  }
   103  
   104  // newError returns an error object with position info.
   105  func (d decoder) newError(pos int, f string, x ...interface{}) error {
   106  	line, column := d.Position(pos)
   107  	head := fmt.Sprintf("(line %d:%d): ", line, column)
   108  	return errors.New(head+f, x...)
   109  }
   110  
   111  // unexpectedTokenError returns a syntax error for the given unexpected token.
   112  func (d decoder) unexpectedTokenError(tok json.Token) error {
   113  	return d.syntaxError(tok.Pos(), "unexpected token %s", tok.RawString())
   114  }
   115  
   116  // syntaxError returns a syntax error for given position.
   117  func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
   118  	line, column := d.Position(pos)
   119  	head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
   120  	return errors.New(head+f, x...)
   121  }
   122  
   123  // unmarshalMessage unmarshals a message into the given protoreflect.Message.
   124  func (d decoder) unmarshalMessage(m protoreflect.Message, skipTypeURL bool) error {
   125  	d.opts.RecursionLimit--
   126  	if d.opts.RecursionLimit < 0 {
   127  		return errors.New("exceeded max recursion depth")
   128  	}
   129  	if unmarshal := wellKnownTypeUnmarshaler(m.Descriptor().FullName()); unmarshal != nil {
   130  		return unmarshal(d, m)
   131  	}
   132  
   133  	tok, err := d.Read()
   134  	if err != nil {
   135  		return err
   136  	}
   137  	if tok.Kind() != json.ObjectOpen {
   138  		return d.unexpectedTokenError(tok)
   139  	}
   140  
   141  	messageDesc := m.Descriptor()
   142  	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
   143  		return errors.New("no support for proto1 MessageSets")
   144  	}
   145  
   146  	var seenNums set.Ints
   147  	var seenOneofs set.Ints
   148  	fieldDescs := messageDesc.Fields()
   149  	for {
   150  		// Read field name.
   151  		tok, err := d.Read()
   152  		if err != nil {
   153  			return err
   154  		}
   155  		switch tok.Kind() {
   156  		default:
   157  			return d.unexpectedTokenError(tok)
   158  		case json.ObjectClose:
   159  			return nil
   160  		case json.Name:
   161  			// Continue below.
   162  		}
   163  
   164  		name := tok.Name()
   165  		// Unmarshaling a non-custom embedded message in Any will contain the
   166  		// JSON field "@type" which should be skipped because it is not a field
   167  		// of the embedded message, but simply an artifact of the Any format.
   168  		if skipTypeURL && name == "@type" {
   169  			d.Read()
   170  			continue
   171  		}
   172  
   173  		// Get the FieldDescriptor.
   174  		var fd protoreflect.FieldDescriptor
   175  		if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") {
   176  			// Only extension names are in [name] format.
   177  			extName := protoreflect.FullName(name[1 : len(name)-1])
   178  			extType, err := d.opts.Resolver.FindExtensionByName(extName)
   179  			if err != nil && err != protoregistry.NotFound {
   180  				return d.newError(tok.Pos(), "unable to resolve %s: %v", tok.RawString(), err)
   181  			}
   182  			if extType != nil {
   183  				fd = extType.TypeDescriptor()
   184  				if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
   185  					return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
   186  				}
   187  			}
   188  		} else {
   189  			// The name can either be the JSON name or the proto field name.
   190  			fd = fieldDescs.ByJSONName(name)
   191  			if fd == nil {
   192  				fd = fieldDescs.ByTextName(name)
   193  			}
   194  		}
   195  		if flags.ProtoLegacy {
   196  			if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
   197  				fd = nil // reset since the weak reference is not linked in
   198  			}
   199  		}
   200  
   201  		if fd == nil {
   202  			// Field is unknown.
   203  			if d.opts.DiscardUnknown {
   204  				if err := d.skipJSONValue(); err != nil {
   205  					return err
   206  				}
   207  				continue
   208  			}
   209  			return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
   210  		}
   211  
   212  		// Do not allow duplicate fields.
   213  		num := uint64(fd.Number())
   214  		if seenNums.Has(num) {
   215  			return d.newError(tok.Pos(), "duplicate field %v", tok.RawString())
   216  		}
   217  		seenNums.Set(num)
   218  
   219  		// No need to set values for JSON null unless the field type is
   220  		// google.protobuf.Value or google.protobuf.NullValue.
   221  		if tok, _ := d.Peek(); tok.Kind() == json.Null && !isKnownValue(fd) && !isNullValue(fd) {
   222  			d.Read()
   223  			continue
   224  		}
   225  
   226  		switch {
   227  		case fd.IsList():
   228  			list := m.Mutable(fd).List()
   229  			if err := d.unmarshalList(list, fd); err != nil {
   230  				return err
   231  			}
   232  		case fd.IsMap():
   233  			mmap := m.Mutable(fd).Map()
   234  			if err := d.unmarshalMap(mmap, fd); err != nil {
   235  				return err
   236  			}
   237  		default:
   238  			// If field is a oneof, check if it has already been set.
   239  			if od := fd.ContainingOneof(); od != nil {
   240  				idx := uint64(od.Index())
   241  				if seenOneofs.Has(idx) {
   242  					return d.newError(tok.Pos(), "error parsing %s, oneof %v is already set", tok.RawString(), od.FullName())
   243  				}
   244  				seenOneofs.Set(idx)
   245  			}
   246  
   247  			// Required or optional fields.
   248  			if err := d.unmarshalSingular(m, fd); err != nil {
   249  				return err
   250  			}
   251  		}
   252  	}
   253  }
   254  
   255  func isKnownValue(fd protoreflect.FieldDescriptor) bool {
   256  	md := fd.Message()
   257  	return md != nil && md.FullName() == genid.Value_message_fullname
   258  }
   259  
   260  func isNullValue(fd protoreflect.FieldDescriptor) bool {
   261  	ed := fd.Enum()
   262  	return ed != nil && ed.FullName() == genid.NullValue_enum_fullname
   263  }
   264  
   265  // unmarshalSingular unmarshals to the non-repeated field specified
   266  // by the given FieldDescriptor.
   267  func (d decoder) unmarshalSingular(m protoreflect.Message, fd protoreflect.FieldDescriptor) error {
   268  	var val protoreflect.Value
   269  	var err error
   270  	switch fd.Kind() {
   271  	case protoreflect.MessageKind, protoreflect.GroupKind:
   272  		val = m.NewField(fd)
   273  		err = d.unmarshalMessage(val.Message(), false)
   274  	default:
   275  		val, err = d.unmarshalScalar(fd)
   276  	}
   277  
   278  	if err != nil {
   279  		return err
   280  	}
   281  	if val.IsValid() {
   282  		m.Set(fd, val)
   283  	}
   284  	return nil
   285  }
   286  
   287  // unmarshalScalar unmarshals to a scalar/enum protoreflect.Value specified by
   288  // the given FieldDescriptor.
   289  func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
   290  	const b32 int = 32
   291  	const b64 int = 64
   292  
   293  	tok, err := d.Read()
   294  	if err != nil {
   295  		return protoreflect.Value{}, err
   296  	}
   297  
   298  	kind := fd.Kind()
   299  	switch kind {
   300  	case protoreflect.BoolKind:
   301  		if tok.Kind() == json.Bool {
   302  			return protoreflect.ValueOfBool(tok.Bool()), nil
   303  		}
   304  
   305  	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
   306  		if v, ok := unmarshalInt(tok, b32); ok {
   307  			return v, nil
   308  		}
   309  
   310  	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
   311  		if v, ok := unmarshalInt(tok, b64); ok {
   312  			return v, nil
   313  		}
   314  
   315  	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
   316  		if v, ok := unmarshalUint(tok, b32); ok {
   317  			return v, nil
   318  		}
   319  
   320  	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
   321  		if v, ok := unmarshalUint(tok, b64); ok {
   322  			return v, nil
   323  		}
   324  
   325  	case protoreflect.FloatKind:
   326  		if v, ok := unmarshalFloat(tok, b32); ok {
   327  			return v, nil
   328  		}
   329  
   330  	case protoreflect.DoubleKind:
   331  		if v, ok := unmarshalFloat(tok, b64); ok {
   332  			return v, nil
   333  		}
   334  
   335  	case protoreflect.StringKind:
   336  		if tok.Kind() == json.String {
   337  			return protoreflect.ValueOfString(tok.ParsedString()), nil
   338  		}
   339  
   340  	case protoreflect.BytesKind:
   341  		if v, ok := unmarshalBytes(tok); ok {
   342  			return v, nil
   343  		}
   344  
   345  	case protoreflect.EnumKind:
   346  		if v, ok := unmarshalEnum(tok, fd, d.opts.DiscardUnknown); ok {
   347  			return v, nil
   348  		}
   349  
   350  	default:
   351  		panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
   352  	}
   353  
   354  	return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
   355  }
   356  
   357  func unmarshalInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
   358  	switch tok.Kind() {
   359  	case json.Number:
   360  		return getInt(tok, bitSize)
   361  
   362  	case json.String:
   363  		// Decode number from string.
   364  		s := strings.TrimSpace(tok.ParsedString())
   365  		if len(s) != len(tok.ParsedString()) {
   366  			return protoreflect.Value{}, false
   367  		}
   368  		dec := json.NewDecoder([]byte(s))
   369  		tok, err := dec.Read()
   370  		if err != nil {
   371  			return protoreflect.Value{}, false
   372  		}
   373  		return getInt(tok, bitSize)
   374  	}
   375  	return protoreflect.Value{}, false
   376  }
   377  
   378  func getInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
   379  	n, ok := tok.Int(bitSize)
   380  	if !ok {
   381  		return protoreflect.Value{}, false
   382  	}
   383  	if bitSize == 32 {
   384  		return protoreflect.ValueOfInt32(int32(n)), true
   385  	}
   386  	return protoreflect.ValueOfInt64(n), true
   387  }
   388  
   389  func unmarshalUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
   390  	switch tok.Kind() {
   391  	case json.Number:
   392  		return getUint(tok, bitSize)
   393  
   394  	case json.String:
   395  		// Decode number from string.
   396  		s := strings.TrimSpace(tok.ParsedString())
   397  		if len(s) != len(tok.ParsedString()) {
   398  			return protoreflect.Value{}, false
   399  		}
   400  		dec := json.NewDecoder([]byte(s))
   401  		tok, err := dec.Read()
   402  		if err != nil {
   403  			return protoreflect.Value{}, false
   404  		}
   405  		return getUint(tok, bitSize)
   406  	}
   407  	return protoreflect.Value{}, false
   408  }
   409  
   410  func getUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
   411  	n, ok := tok.Uint(bitSize)
   412  	if !ok {
   413  		return protoreflect.Value{}, false
   414  	}
   415  	if bitSize == 32 {
   416  		return protoreflect.ValueOfUint32(uint32(n)), true
   417  	}
   418  	return protoreflect.ValueOfUint64(n), true
   419  }
   420  
   421  func unmarshalFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
   422  	switch tok.Kind() {
   423  	case json.Number:
   424  		return getFloat(tok, bitSize)
   425  
   426  	case json.String:
   427  		s := tok.ParsedString()
   428  		switch s {
   429  		case "NaN":
   430  			if bitSize == 32 {
   431  				return protoreflect.ValueOfFloat32(float32(math.NaN())), true
   432  			}
   433  			return protoreflect.ValueOfFloat64(math.NaN()), true
   434  		case "Infinity":
   435  			if bitSize == 32 {
   436  				return protoreflect.ValueOfFloat32(float32(math.Inf(+1))), true
   437  			}
   438  			return protoreflect.ValueOfFloat64(math.Inf(+1)), true
   439  		case "-Infinity":
   440  			if bitSize == 32 {
   441  				return protoreflect.ValueOfFloat32(float32(math.Inf(-1))), true
   442  			}
   443  			return protoreflect.ValueOfFloat64(math.Inf(-1)), true
   444  		}
   445  
   446  		// Decode number from string.
   447  		if len(s) != len(strings.TrimSpace(s)) {
   448  			return protoreflect.Value{}, false
   449  		}
   450  		dec := json.NewDecoder([]byte(s))
   451  		tok, err := dec.Read()
   452  		if err != nil {
   453  			return protoreflect.Value{}, false
   454  		}
   455  		return getFloat(tok, bitSize)
   456  	}
   457  	return protoreflect.Value{}, false
   458  }
   459  
   460  func getFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
   461  	n, ok := tok.Float(bitSize)
   462  	if !ok {
   463  		return protoreflect.Value{}, false
   464  	}
   465  	if bitSize == 32 {
   466  		return protoreflect.ValueOfFloat32(float32(n)), true
   467  	}
   468  	return protoreflect.ValueOfFloat64(n), true
   469  }
   470  
   471  func unmarshalBytes(tok json.Token) (protoreflect.Value, bool) {
   472  	if tok.Kind() != json.String {
   473  		return protoreflect.Value{}, false
   474  	}
   475  
   476  	s := tok.ParsedString()
   477  	enc := base64.StdEncoding
   478  	if strings.ContainsAny(s, "-_") {
   479  		enc = base64.URLEncoding
   480  	}
   481  	if len(s)%4 != 0 {
   482  		enc = enc.WithPadding(base64.NoPadding)
   483  	}
   484  	b, err := enc.DecodeString(s)
   485  	if err != nil {
   486  		return protoreflect.Value{}, false
   487  	}
   488  	return protoreflect.ValueOfBytes(b), true
   489  }
   490  
   491  func unmarshalEnum(tok json.Token, fd protoreflect.FieldDescriptor, discardUnknown bool) (protoreflect.Value, bool) {
   492  	switch tok.Kind() {
   493  	case json.String:
   494  		// Lookup EnumNumber based on name.
   495  		s := tok.ParsedString()
   496  		if enumVal := fd.Enum().Values().ByName(protoreflect.Name(s)); enumVal != nil {
   497  			return protoreflect.ValueOfEnum(enumVal.Number()), true
   498  		}
   499  		if discardUnknown {
   500  			return protoreflect.Value{}, true
   501  		}
   502  
   503  	case json.Number:
   504  		if n, ok := tok.Int(32); ok {
   505  			return protoreflect.ValueOfEnum(protoreflect.EnumNumber(n)), true
   506  		}
   507  
   508  	case json.Null:
   509  		// This is only valid for google.protobuf.NullValue.
   510  		if isNullValue(fd) {
   511  			return protoreflect.ValueOfEnum(0), true
   512  		}
   513  	}
   514  
   515  	return protoreflect.Value{}, false
   516  }
   517  
   518  func (d decoder) unmarshalList(list protoreflect.List, fd protoreflect.FieldDescriptor) error {
   519  	tok, err := d.Read()
   520  	if err != nil {
   521  		return err
   522  	}
   523  	if tok.Kind() != json.ArrayOpen {
   524  		return d.unexpectedTokenError(tok)
   525  	}
   526  
   527  	switch fd.Kind() {
   528  	case protoreflect.MessageKind, protoreflect.GroupKind:
   529  		for {
   530  			tok, err := d.Peek()
   531  			if err != nil {
   532  				return err
   533  			}
   534  
   535  			if tok.Kind() == json.ArrayClose {
   536  				d.Read()
   537  				return nil
   538  			}
   539  
   540  			val := list.NewElement()
   541  			if err := d.unmarshalMessage(val.Message(), false); err != nil {
   542  				return err
   543  			}
   544  			list.Append(val)
   545  		}
   546  	default:
   547  		for {
   548  			tok, err := d.Peek()
   549  			if err != nil {
   550  				return err
   551  			}
   552  
   553  			if tok.Kind() == json.ArrayClose {
   554  				d.Read()
   555  				return nil
   556  			}
   557  
   558  			val, err := d.unmarshalScalar(fd)
   559  			if err != nil {
   560  				return err
   561  			}
   562  			if val.IsValid() {
   563  				list.Append(val)
   564  			}
   565  		}
   566  	}
   567  
   568  	return nil
   569  }
   570  
   571  func (d decoder) unmarshalMap(mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
   572  	tok, err := d.Read()
   573  	if err != nil {
   574  		return err
   575  	}
   576  	if tok.Kind() != json.ObjectOpen {
   577  		return d.unexpectedTokenError(tok)
   578  	}
   579  
   580  	// Determine ahead whether map entry is a scalar type or a message type in
   581  	// order to call the appropriate unmarshalMapValue func inside the for loop
   582  	// below.
   583  	var unmarshalMapValue func() (protoreflect.Value, error)
   584  	switch fd.MapValue().Kind() {
   585  	case protoreflect.MessageKind, protoreflect.GroupKind:
   586  		unmarshalMapValue = func() (protoreflect.Value, error) {
   587  			val := mmap.NewValue()
   588  			if err := d.unmarshalMessage(val.Message(), false); err != nil {
   589  				return protoreflect.Value{}, err
   590  			}
   591  			return val, nil
   592  		}
   593  	default:
   594  		unmarshalMapValue = func() (protoreflect.Value, error) {
   595  			return d.unmarshalScalar(fd.MapValue())
   596  		}
   597  	}
   598  
   599  Loop:
   600  	for {
   601  		// Read field name.
   602  		tok, err := d.Read()
   603  		if err != nil {
   604  			return err
   605  		}
   606  		switch tok.Kind() {
   607  		default:
   608  			return d.unexpectedTokenError(tok)
   609  		case json.ObjectClose:
   610  			break Loop
   611  		case json.Name:
   612  			// Continue.
   613  		}
   614  
   615  		// Unmarshal field name.
   616  		pkey, err := d.unmarshalMapKey(tok, fd.MapKey())
   617  		if err != nil {
   618  			return err
   619  		}
   620  
   621  		// Check for duplicate field name.
   622  		if mmap.Has(pkey) {
   623  			return d.newError(tok.Pos(), "duplicate map key %v", tok.RawString())
   624  		}
   625  
   626  		// Read and unmarshal field value.
   627  		pval, err := unmarshalMapValue()
   628  		if err != nil {
   629  			return err
   630  		}
   631  		if pval.IsValid() {
   632  			mmap.Set(pkey, pval)
   633  		}
   634  	}
   635  
   636  	return nil
   637  }
   638  
   639  // unmarshalMapKey converts given token of Name kind into a protoreflect.MapKey.
   640  // A map key type is any integral or string type.
   641  func (d decoder) unmarshalMapKey(tok json.Token, fd protoreflect.FieldDescriptor) (protoreflect.MapKey, error) {
   642  	const b32 = 32
   643  	const b64 = 64
   644  	const base10 = 10
   645  
   646  	name := tok.Name()
   647  	kind := fd.Kind()
   648  	switch kind {
   649  	case protoreflect.StringKind:
   650  		return protoreflect.ValueOfString(name).MapKey(), nil
   651  
   652  	case protoreflect.BoolKind:
   653  		switch name {
   654  		case "true":
   655  			return protoreflect.ValueOfBool(true).MapKey(), nil
   656  		case "false":
   657  			return protoreflect.ValueOfBool(false).MapKey(), nil
   658  		}
   659  
   660  	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
   661  		if n, err := strconv.ParseInt(name, base10, b32); err == nil {
   662  			return protoreflect.ValueOfInt32(int32(n)).MapKey(), nil
   663  		}
   664  
   665  	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
   666  		if n, err := strconv.ParseInt(name, base10, b64); err == nil {
   667  			return protoreflect.ValueOfInt64(int64(n)).MapKey(), nil
   668  		}
   669  
   670  	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
   671  		if n, err := strconv.ParseUint(name, base10, b32); err == nil {
   672  			return protoreflect.ValueOfUint32(uint32(n)).MapKey(), nil
   673  		}
   674  
   675  	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
   676  		if n, err := strconv.ParseUint(name, base10, b64); err == nil {
   677  			return protoreflect.ValueOfUint64(uint64(n)).MapKey(), nil
   678  		}
   679  
   680  	default:
   681  		panic(fmt.Sprintf("invalid kind for map key: %v", kind))
   682  	}
   683  
   684  	return protoreflect.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString())
   685  }
   686  

View as plain text