internal/encoding/tag/tag.go - protobuf - Git at Google

 // 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 tag marshals and unmarshals the legacy struct tags as generated
 // by historical versions of protoc-gen-go.
 package tag

 import (
 	"fmt"
 	"math"
 	"reflect"
 	"strconv"
 	"strings"

 	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
 	ptext "github.com/golang/protobuf/v2/internal/encoding/text"
 	scalar "github.com/golang/protobuf/v2/internal/scalar"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )

 var byteType = reflect.TypeOf(byte(0))

 // Unmarshal decodes the tag into a prototype.Field.
 //
 // The goType is needed to determine the original protoreflect.Kind since the
 // tag does not record sufficient information to determine that.
 // The type is the underlying field type (e.g., a repeated field may be
 // represented by []T, but the Go type passed in is just T).
 // This does not populate the EnumType or MessageType (except for weak message).
 //
 // This function is a best effort attempt; parsing errors are ignored.
 func Unmarshal(tag string, goType reflect.Type) ptype.Field {
 	f := ptype.Field{Options: new(descriptorV1.FieldOptions)}
 	for len(tag) > 0 {
 		i := strings.IndexByte(tag, ',')
 		if i < 0 {
 			i = len(tag)
 		}
 		switch s := tag[:i]; {
 		case strings.HasPrefix(s, "name="):
 			f.Name = pref.Name(s[len("name="):])
 		case strings.Trim(s, "0123456789") == "":
 			n, _ := strconv.ParseUint(s, 10, 32)
 			f.Number = pref.FieldNumber(n)
 		case s == "opt":
 			f.Cardinality = pref.Optional
 		case s == "req":
 			f.Cardinality = pref.Required
 		case s == "rep":
 			f.Cardinality = pref.Repeated
 		case s == "varint":
 			switch goType.Kind() {
 			case reflect.Bool:
 				f.Kind = pref.BoolKind
 			case reflect.Int32:
 				f.Kind = pref.Int32Kind
 			case reflect.Int64:
 				f.Kind = pref.Int64Kind
 			case reflect.Uint32:
 				f.Kind = pref.Uint32Kind
 			case reflect.Uint64:
 				f.Kind = pref.Uint64Kind
 			}
 		case s == "zigzag32":
 			if goType.Kind() == reflect.Int32 {
 				f.Kind = pref.Sint32Kind
 			}
 		case s == "zigzag64":
 			if goType.Kind() == reflect.Int64 {
 				f.Kind = pref.Sint64Kind
 			}
 		case s == "fixed32":
 			switch goType.Kind() {
 			case reflect.Int32:
 				f.Kind = pref.Sfixed32Kind
 			case reflect.Uint32:
 				f.Kind = pref.Fixed32Kind
 			case reflect.Float32:
 				f.Kind = pref.FloatKind
 			}
 		case s == "fixed64":
 			switch goType.Kind() {
 			case reflect.Int64:
 				f.Kind = pref.Sfixed64Kind
 			case reflect.Uint64:
 				f.Kind = pref.Fixed64Kind
 			case reflect.Float64:
 				f.Kind = pref.DoubleKind
 			}
 		case s == "bytes":
 			switch {
 			case goType.Kind() == reflect.String:
 				f.Kind = pref.StringKind
 			case goType.Kind() == reflect.Slice && goType.Elem() == byteType:
 				f.Kind = pref.BytesKind
 			default:
 				f.Kind = pref.MessageKind
 			}
 		case s == "group":
 			f.Kind = pref.GroupKind
 		case strings.HasPrefix(s, "enum="):
 			f.Kind = pref.EnumKind
 		case strings.HasPrefix(s, "json="):
 			f.JSONName = s[len("json="):]
 		case s == "packed":
 			f.Options.Packed = scalar.Bool(true)
 		case strings.HasPrefix(s, "weak="):
 			f.Options.Weak = scalar.Bool(true)
 			f.MessageType = ptype.PlaceholderMessage(pref.FullName(s[len("weak="):]))
 		case strings.HasPrefix(s, "def="):
 			// The default tag is special in that everything afterwards is the
 			// default regardless of the presence of commas.
 			s, i = tag[len("def="):], len(tag)

 			// Defaults are parsed last, so Kind is populated.
 			switch f.Kind {
 			case pref.BoolKind:
 				switch s {
 				case "1":
 					f.Default = pref.ValueOf(true)
 				case "0":
 					f.Default = pref.ValueOf(false)
 				}
 			case pref.EnumKind:
 				n, _ := strconv.ParseInt(s, 10, 32)
 				f.Default = pref.ValueOf(pref.EnumNumber(n))
 			case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
 				n, _ := strconv.ParseInt(s, 10, 32)
 				f.Default = pref.ValueOf(int32(n))
 			case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
 				n, _ := strconv.ParseInt(s, 10, 64)
 				f.Default = pref.ValueOf(int64(n))
 			case pref.Uint32Kind, pref.Fixed32Kind:
 				n, _ := strconv.ParseUint(s, 10, 32)
 				f.Default = pref.ValueOf(uint32(n))
 			case pref.Uint64Kind, pref.Fixed64Kind:
 				n, _ := strconv.ParseUint(s, 10, 64)
 				f.Default = pref.ValueOf(uint64(n))
 			case pref.FloatKind, pref.DoubleKind:
 				n, _ := strconv.ParseFloat(s, 64)
 				switch s {
 				case "nan":
 					n = math.NaN()
 				case "inf":
 					n = math.Inf(+1)
 				case "-inf":
 					n = math.Inf(-1)
 				}
 				if f.Kind == pref.FloatKind {
 					f.Default = pref.ValueOf(float32(n))
 				} else {
 					f.Default = pref.ValueOf(float64(n))
 				}
 			case pref.StringKind:
 				f.Default = pref.ValueOf(string(s))
 			case pref.BytesKind:
 				// The default value is in escaped form (C-style).
 				// TODO: Export unmarshalString in the text package to avoid this hack.
 				v, err := ptext.Unmarshal([]byte(`["` + s + `"]:0`))
 				if err == nil && len(v.Message()) == 1 {
 					s := v.Message()[0][0].String()
 					f.Default = pref.ValueOf([]byte(s))
 				}
 			}
 		}
 		tag = strings.TrimPrefix(tag[i:], ",")
 	}

 	// The generator uses the group message name instead of the field name.
 	// We obtain the real field name by lowercasing the group name.
 	if f.Kind == pref.GroupKind {
 		f.Name = pref.Name(strings.ToLower(string(f.Name)))
 	}
 	return f
 }

 // Marshal encodes the protoreflect.FieldDescriptor as a tag.
 //
 // The enumName must be provided if the kind is an enum.
 // Historically, the formulation of the enum "name" was the proto package
 // dot-concatenated with the generated Go identifier for the enum type.
 // Depending on the context on how Marshal is called, there are different ways
 // through which that information is determined. As such it is the caller's
 // responsibility to provide a function to obtain that information.
 func Marshal(fd pref.FieldDescriptor, enumName string) string {
 	var tag []string
 	switch fd.Kind() {
 	case pref.BoolKind, pref.EnumKind, pref.Int32Kind, pref.Uint32Kind, pref.Int64Kind, pref.Uint64Kind:
 		tag = append(tag, "varint")
 	case pref.Sint32Kind:
 		tag = append(tag, "zigzag32")
 	case pref.Sint64Kind:
 		tag = append(tag, "zigzag64")
 	case pref.Sfixed32Kind, pref.Fixed32Kind, pref.FloatKind:
 		tag = append(tag, "fixed32")
 	case pref.Sfixed64Kind, pref.Fixed64Kind, pref.DoubleKind:
 		tag = append(tag, "fixed64")
 	case pref.StringKind, pref.BytesKind, pref.MessageKind:
 		tag = append(tag, "bytes")
 	case pref.GroupKind:
 		tag = append(tag, "group")
 	}
 	tag = append(tag, strconv.Itoa(int(fd.Number())))
 	switch fd.Cardinality() {
 	case pref.Optional:
 		tag = append(tag, "opt")
 	case pref.Required:
 		tag = append(tag, "req")
 	case pref.Repeated:
 		tag = append(tag, "rep")
 	}
 	if fd.IsPacked() {
 		tag = append(tag, "packed")
 	}
 	// TODO: Weak fields?
 	name := string(fd.Name())
 	if fd.Kind() == pref.GroupKind {
 		// The name of the FieldDescriptor for a group field is
 		// lowercased. To find the original capitalization, we
 		// look in the field's MessageType.
 		name = string(fd.MessageType().Name())
 	}
 	tag = append(tag, "name="+name)
 	if jsonName := fd.JSONName(); jsonName != "" && jsonName != name {
 		tag = append(tag, "json="+jsonName)
 	}
 	// The previous implementation does not tag extension fields as proto3,
 	// even when the field is defined in a proto3 file. Match that behavior
 	// for consistency.
 	if fd.Syntax() == pref.Proto3 && fd.ExtendedType() == nil {
 		tag = append(tag, "proto3")
 	}
 	if fd.Kind() == pref.EnumKind && enumName != "" {
 		tag = append(tag, "enum="+enumName)
 	}
 	if fd.OneofType() != nil {
 		tag = append(tag, "oneof")
 	}
 	// This must appear last in the tag, since commas in strings aren't escaped.
 	if fd.HasDefault() {
 		var def string
 		switch fd.Kind() {
 		case pref.BoolKind:
 			if fd.Default().Bool() {
 				def = "1"
 			} else {
 				def = "0"
 			}
 		case pref.BytesKind:
 			// Preserve protoc-gen-go's historical output of escaped bytes.
 			// This behavior is buggy, but fixing it makes it impossible to
 			// distinguish between the escaped and unescaped forms.
 			//
 			// To match the exact output of protoc, this is identical to the
 			// CEscape function in strutil.cc of the protoc source code.
 			var b []byte
 			for _, c := range fd.Default().Bytes() {
 				switch c {
 				case '\n':
 					b = append(b, `\n`...)
 				case '\r':
 					b = append(b, `\r`...)
 				case '\t':
 					b = append(b, `\t`...)
 				case '"':
 					b = append(b, `\"`...)
 				case '\'':
 					b = append(b, `\'`...)
 				case '\\':
 					b = append(b, `\\`...)
 				default:
 					if c >= 0x20 && c <= 0x7e { // printable ASCII
 						b = append(b, c)
 					} else {
 						b = append(b, fmt.Sprintf(`\%03o`, c)...)
 					}
 				}
 			}
 			def = string(b)
 		case pref.FloatKind, pref.DoubleKind:
 			f := fd.Default().Float()
 			switch {
 			case math.IsInf(f, -1):
 				def = "-inf"
 			case math.IsInf(f, 1):
 				def = "inf"
 			case math.IsNaN(f):
 				def = "nan"
 			default:
 				def = fmt.Sprint(fd.Default().Interface())
 			}
 		default:
 			def = fmt.Sprint(fd.Default().Interface())
 		}
 		tag = append(tag, "def="+def)
 	}
 	return strings.Join(tag, ",")
 }
	// 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 tag marshals and unmarshals the legacy struct tags as generated
	// by historical versions of protoc-gen-go.
	package tag

	import (
	"fmt"
	"math"
	"reflect"
	"strconv"
	"strings"

	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
	ptext "github.com/golang/protobuf/v2/internal/encoding/text"
	scalar "github.com/golang/protobuf/v2/internal/scalar"
	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
	ptype "github.com/golang/protobuf/v2/reflect/prototype"
	)

	var byteType = reflect.TypeOf(byte(0))

	// Unmarshal decodes the tag into a prototype.Field.
	//
	// The goType is needed to determine the original protoreflect.Kind since the
	// tag does not record sufficient information to determine that.
	// The type is the underlying field type (e.g., a repeated field may be
	// represented by []T, but the Go type passed in is just T).
	// This does not populate the EnumType or MessageType (except for weak message).
	//
	// This function is a best effort attempt; parsing errors are ignored.
	func Unmarshal(tag string, goType reflect.Type) ptype.Field {
	f := ptype.Field{Options: new(descriptorV1.FieldOptions)}
	for len(tag) > 0 {
	i := strings.IndexByte(tag, ',')
	if i < 0 {
	i = len(tag)
	}
	switch s := tag[:i]; {
	case strings.HasPrefix(s, "name="):
	f.Name = pref.Name(s[len("name="):])
	case strings.Trim(s, "0123456789") == "":
	n, _ := strconv.ParseUint(s, 10, 32)
	f.Number = pref.FieldNumber(n)
	case s == "opt":
	f.Cardinality = pref.Optional
	case s == "req":
	f.Cardinality = pref.Required
	case s == "rep":
	f.Cardinality = pref.Repeated
	case s == "varint":
	switch goType.Kind() {
	case reflect.Bool:
	f.Kind = pref.BoolKind
	case reflect.Int32:
	f.Kind = pref.Int32Kind
	case reflect.Int64:
	f.Kind = pref.Int64Kind
	case reflect.Uint32:
	f.Kind = pref.Uint32Kind
	case reflect.Uint64:
	f.Kind = pref.Uint64Kind
	}
	case s == "zigzag32":
	if goType.Kind() == reflect.Int32 {
	f.Kind = pref.Sint32Kind
	}
	case s == "zigzag64":
	if goType.Kind() == reflect.Int64 {
	f.Kind = pref.Sint64Kind
	}
	case s == "fixed32":
	switch goType.Kind() {
	case reflect.Int32:
	f.Kind = pref.Sfixed32Kind
	case reflect.Uint32:
	f.Kind = pref.Fixed32Kind
	case reflect.Float32:
	f.Kind = pref.FloatKind
	}
	case s == "fixed64":
	switch goType.Kind() {
	case reflect.Int64:
	f.Kind = pref.Sfixed64Kind
	case reflect.Uint64:
	f.Kind = pref.Fixed64Kind
	case reflect.Float64:
	f.Kind = pref.DoubleKind
	}
	case s == "bytes":
	switch {
	case goType.Kind() == reflect.String:
	f.Kind = pref.StringKind
	case goType.Kind() == reflect.Slice && goType.Elem() == byteType:
	f.Kind = pref.BytesKind
	default:
	f.Kind = pref.MessageKind
	}
	case s == "group":
	f.Kind = pref.GroupKind
	case strings.HasPrefix(s, "enum="):
	f.Kind = pref.EnumKind
	case strings.HasPrefix(s, "json="):
	f.JSONName = s[len("json="):]
	case s == "packed":
	f.Options.Packed = scalar.Bool(true)
	case strings.HasPrefix(s, "weak="):
	f.Options.Weak = scalar.Bool(true)
	f.MessageType = ptype.PlaceholderMessage(pref.FullName(s[len("weak="):]))
	case strings.HasPrefix(s, "def="):
	// The default tag is special in that everything afterwards is the
	// default regardless of the presence of commas.
	s, i = tag[len("def="):], len(tag)

	// Defaults are parsed last, so Kind is populated.
	switch f.Kind {
	case pref.BoolKind:
	switch s {
	case "1":
	f.Default = pref.ValueOf(true)
	case "0":
	f.Default = pref.ValueOf(false)
	}
	case pref.EnumKind:
	n, _ := strconv.ParseInt(s, 10, 32)
	f.Default = pref.ValueOf(pref.EnumNumber(n))
	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
	n, _ := strconv.ParseInt(s, 10, 32)
	f.Default = pref.ValueOf(int32(n))
	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
	n, _ := strconv.ParseInt(s, 10, 64)
	f.Default = pref.ValueOf(int64(n))
	case pref.Uint32Kind, pref.Fixed32Kind:
	n, _ := strconv.ParseUint(s, 10, 32)
	f.Default = pref.ValueOf(uint32(n))
	case pref.Uint64Kind, pref.Fixed64Kind:
	n, _ := strconv.ParseUint(s, 10, 64)
	f.Default = pref.ValueOf(uint64(n))
	case pref.FloatKind, pref.DoubleKind:
	n, _ := strconv.ParseFloat(s, 64)
	switch s {
	case "nan":
	n = math.NaN()
	case "inf":
	n = math.Inf(+1)
	case "-inf":
	n = math.Inf(-1)
	}
	if f.Kind == pref.FloatKind {
	f.Default = pref.ValueOf(float32(n))
	} else {
	f.Default = pref.ValueOf(float64(n))
	}
	case pref.StringKind:
	f.Default = pref.ValueOf(string(s))
	case pref.BytesKind:
	// The default value is in escaped form (C-style).
	// TODO: Export unmarshalString in the text package to avoid this hack.
	v, err := ptext.Unmarshal([]byte(`["` + s + `"]:0`))
	if err == nil && len(v.Message()) == 1 {
	s := v.Message()[0][0].String()
	f.Default = pref.ValueOf([]byte(s))
	}
	}
	}
	tag = strings.TrimPrefix(tag[i:], ",")
	}

	// The generator uses the group message name instead of the field name.
	// We obtain the real field name by lowercasing the group name.
	if f.Kind == pref.GroupKind {
	f.Name = pref.Name(strings.ToLower(string(f.Name)))
	}
	return f
	}

	// Marshal encodes the protoreflect.FieldDescriptor as a tag.
	//
	// The enumName must be provided if the kind is an enum.
	// Historically, the formulation of the enum "name" was the proto package
	// dot-concatenated with the generated Go identifier for the enum type.
	// Depending on the context on how Marshal is called, there are different ways
	// through which that information is determined. As such it is the caller's
	// responsibility to provide a function to obtain that information.
	func Marshal(fd pref.FieldDescriptor, enumName string) string {
	var tag []string
	switch fd.Kind() {
	case pref.BoolKind, pref.EnumKind, pref.Int32Kind, pref.Uint32Kind, pref.Int64Kind, pref.Uint64Kind:
	tag = append(tag, "varint")
	case pref.Sint32Kind:
	tag = append(tag, "zigzag32")
	case pref.Sint64Kind:
	tag = append(tag, "zigzag64")
	case pref.Sfixed32Kind, pref.Fixed32Kind, pref.FloatKind:
	tag = append(tag, "fixed32")
	case pref.Sfixed64Kind, pref.Fixed64Kind, pref.DoubleKind:
	tag = append(tag, "fixed64")
	case pref.StringKind, pref.BytesKind, pref.MessageKind:
	tag = append(tag, "bytes")
	case pref.GroupKind:
	tag = append(tag, "group")
	}
	tag = append(tag, strconv.Itoa(int(fd.Number())))
	switch fd.Cardinality() {
	case pref.Optional:
	tag = append(tag, "opt")
	case pref.Required:
	tag = append(tag, "req")
	case pref.Repeated:
	tag = append(tag, "rep")
	}
	if fd.IsPacked() {
	tag = append(tag, "packed")
	}
	// TODO: Weak fields?
	name := string(fd.Name())
	if fd.Kind() == pref.GroupKind {
	// The name of the FieldDescriptor for a group field is
	// lowercased. To find the original capitalization, we
	// look in the field's MessageType.
	name = string(fd.MessageType().Name())
	}
	tag = append(tag, "name="+name)
	if jsonName := fd.JSONName(); jsonName != "" && jsonName != name {
	tag = append(tag, "json="+jsonName)
	}
	// The previous implementation does not tag extension fields as proto3,
	// even when the field is defined in a proto3 file. Match that behavior
	// for consistency.
	if fd.Syntax() == pref.Proto3 && fd.ExtendedType() == nil {
	tag = append(tag, "proto3")
	}
	if fd.Kind() == pref.EnumKind && enumName != "" {
	tag = append(tag, "enum="+enumName)
	}
	if fd.OneofType() != nil {
	tag = append(tag, "oneof")
	}
	// This must appear last in the tag, since commas in strings aren't escaped.
	if fd.HasDefault() {
	var def string
	switch fd.Kind() {
	case pref.BoolKind:
	if fd.Default().Bool() {
	def = "1"
	} else {
	def = "0"
	}
	case pref.BytesKind:
	// Preserve protoc-gen-go's historical output of escaped bytes.
	// This behavior is buggy, but fixing it makes it impossible to
	// distinguish between the escaped and unescaped forms.
	//
	// To match the exact output of protoc, this is identical to the
	// CEscape function in strutil.cc of the protoc source code.
	var b []byte
	for _, c := range fd.Default().Bytes() {
	switch c {
	case '\n':
	b = append(b, `\n`...)
	case '\r':
	b = append(b, `\r`...)
	case '\t':
	b = append(b, `\t`...)
	case '"':
	b = append(b, `\"`...)
	case '\'':
	b = append(b, `\'`...)
	case '\\':
	b = append(b, `\\`...)
	default:
	if c >= 0x20 && c <= 0x7e { // printable ASCII
	b = append(b, c)
	} else {
	b = append(b, fmt.Sprintf(`\%03o`, c)...)
	}
	}
	}
	def = string(b)
	case pref.FloatKind, pref.DoubleKind:
	f := fd.Default().Float()
	switch {
	case math.IsInf(f, -1):
	def = "-inf"
	case math.IsInf(f, 1):
	def = "inf"
	case math.IsNaN(f):
	def = "nan"
	default:
	def = fmt.Sprint(fd.Default().Interface())
	}
	default:
	def = fmt.Sprint(fd.Default().Interface())
	}
	tag = append(tag, "def="+def)
	}
	return strings.Join(tag, ",")
	}