amit.ghosh | 258d14c | 2020-10-02 15:13:38 +0200 | [diff] [blame^] | 1 | // Copyright 2018 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 descfmt provides functionality to format descriptors. |
| 6 | package descfmt |
| 7 | |
| 8 | import ( |
| 9 | "fmt" |
| 10 | "io" |
| 11 | "reflect" |
| 12 | "strconv" |
| 13 | "strings" |
| 14 | |
| 15 | "google.golang.org/protobuf/internal/detrand" |
| 16 | "google.golang.org/protobuf/internal/pragma" |
| 17 | pref "google.golang.org/protobuf/reflect/protoreflect" |
| 18 | ) |
| 19 | |
| 20 | type list interface { |
| 21 | Len() int |
| 22 | pragma.DoNotImplement |
| 23 | } |
| 24 | |
| 25 | func FormatList(s fmt.State, r rune, vs list) { |
| 26 | io.WriteString(s, formatListOpt(vs, true, r == 'v' && (s.Flag('+') || s.Flag('#')))) |
| 27 | } |
| 28 | func formatListOpt(vs list, isRoot, allowMulti bool) string { |
| 29 | start, end := "[", "]" |
| 30 | if isRoot { |
| 31 | var name string |
| 32 | switch vs.(type) { |
| 33 | case pref.Names: |
| 34 | name = "Names" |
| 35 | case pref.FieldNumbers: |
| 36 | name = "FieldNumbers" |
| 37 | case pref.FieldRanges: |
| 38 | name = "FieldRanges" |
| 39 | case pref.EnumRanges: |
| 40 | name = "EnumRanges" |
| 41 | case pref.FileImports: |
| 42 | name = "FileImports" |
| 43 | case pref.Descriptor: |
| 44 | name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s" |
| 45 | } |
| 46 | start, end = name+"{", "}" |
| 47 | } |
| 48 | |
| 49 | var ss []string |
| 50 | switch vs := vs.(type) { |
| 51 | case pref.Names: |
| 52 | for i := 0; i < vs.Len(); i++ { |
| 53 | ss = append(ss, fmt.Sprint(vs.Get(i))) |
| 54 | } |
| 55 | return start + joinStrings(ss, false) + end |
| 56 | case pref.FieldNumbers: |
| 57 | for i := 0; i < vs.Len(); i++ { |
| 58 | ss = append(ss, fmt.Sprint(vs.Get(i))) |
| 59 | } |
| 60 | return start + joinStrings(ss, false) + end |
| 61 | case pref.FieldRanges: |
| 62 | for i := 0; i < vs.Len(); i++ { |
| 63 | r := vs.Get(i) |
| 64 | if r[0]+1 == r[1] { |
| 65 | ss = append(ss, fmt.Sprintf("%d", r[0])) |
| 66 | } else { |
| 67 | ss = append(ss, fmt.Sprintf("%d:%d", r[0], r[1])) // enum ranges are end exclusive |
| 68 | } |
| 69 | } |
| 70 | return start + joinStrings(ss, false) + end |
| 71 | case pref.EnumRanges: |
| 72 | for i := 0; i < vs.Len(); i++ { |
| 73 | r := vs.Get(i) |
| 74 | if r[0] == r[1] { |
| 75 | ss = append(ss, fmt.Sprintf("%d", r[0])) |
| 76 | } else { |
| 77 | ss = append(ss, fmt.Sprintf("%d:%d", r[0], int64(r[1])+1)) // enum ranges are end inclusive |
| 78 | } |
| 79 | } |
| 80 | return start + joinStrings(ss, false) + end |
| 81 | case pref.FileImports: |
| 82 | for i := 0; i < vs.Len(); i++ { |
| 83 | var rs records |
| 84 | rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak") |
| 85 | ss = append(ss, "{"+rs.Join()+"}") |
| 86 | } |
| 87 | return start + joinStrings(ss, allowMulti) + end |
| 88 | default: |
| 89 | _, isEnumValue := vs.(pref.EnumValueDescriptors) |
| 90 | for i := 0; i < vs.Len(); i++ { |
| 91 | m := reflect.ValueOf(vs).MethodByName("Get") |
| 92 | v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface() |
| 93 | ss = append(ss, formatDescOpt(v.(pref.Descriptor), false, allowMulti && !isEnumValue)) |
| 94 | } |
| 95 | return start + joinStrings(ss, allowMulti && isEnumValue) + end |
| 96 | } |
| 97 | } |
| 98 | |
| 99 | // descriptorAccessors is a list of accessors to print for each descriptor. |
| 100 | // |
| 101 | // Do not print all accessors since some contain redundant information, |
| 102 | // while others are pointers that we do not want to follow since the descriptor |
| 103 | // is actually a cyclic graph. |
| 104 | // |
| 105 | // Using a list allows us to print the accessors in a sensible order. |
| 106 | var descriptorAccessors = map[reflect.Type][]string{ |
| 107 | reflect.TypeOf((*pref.FileDescriptor)(nil)).Elem(): {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"}, |
| 108 | reflect.TypeOf((*pref.MessageDescriptor)(nil)).Elem(): {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"}, |
| 109 | reflect.TypeOf((*pref.FieldDescriptor)(nil)).Elem(): {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"}, |
| 110 | reflect.TypeOf((*pref.OneofDescriptor)(nil)).Elem(): {"Fields"}, // not directly used; must keep in sync with formatDescOpt |
| 111 | reflect.TypeOf((*pref.EnumDescriptor)(nil)).Elem(): {"Values", "ReservedNames", "ReservedRanges"}, |
| 112 | reflect.TypeOf((*pref.EnumValueDescriptor)(nil)).Elem(): {"Number"}, |
| 113 | reflect.TypeOf((*pref.ServiceDescriptor)(nil)).Elem(): {"Methods"}, |
| 114 | reflect.TypeOf((*pref.MethodDescriptor)(nil)).Elem(): {"Input", "Output", "IsStreamingClient", "IsStreamingServer"}, |
| 115 | } |
| 116 | |
| 117 | func FormatDesc(s fmt.State, r rune, t pref.Descriptor) { |
| 118 | io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#')))) |
| 119 | } |
| 120 | func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string { |
| 121 | rv := reflect.ValueOf(t) |
| 122 | rt := rv.MethodByName("ProtoType").Type().In(0) |
| 123 | |
| 124 | start, end := "{", "}" |
| 125 | if isRoot { |
| 126 | start = rt.Name() + "{" |
| 127 | } |
| 128 | |
| 129 | _, isFile := t.(pref.FileDescriptor) |
| 130 | rs := records{allowMulti: allowMulti} |
| 131 | if t.IsPlaceholder() { |
| 132 | if isFile { |
| 133 | rs.Append(rv, "Path", "Package", "IsPlaceholder") |
| 134 | } else { |
| 135 | rs.Append(rv, "FullName", "IsPlaceholder") |
| 136 | } |
| 137 | } else { |
| 138 | switch { |
| 139 | case isFile: |
| 140 | rs.Append(rv, "Syntax") |
| 141 | case isRoot: |
| 142 | rs.Append(rv, "Syntax", "FullName") |
| 143 | default: |
| 144 | rs.Append(rv, "Name") |
| 145 | } |
| 146 | switch t := t.(type) { |
| 147 | case pref.FieldDescriptor: |
| 148 | for _, s := range descriptorAccessors[rt] { |
| 149 | switch s { |
| 150 | case "MapKey": |
| 151 | if k := t.MapKey(); k != nil { |
| 152 | rs.recs = append(rs.recs, [2]string{"MapKey", k.Kind().String()}) |
| 153 | } |
| 154 | case "MapValue": |
| 155 | if v := t.MapValue(); v != nil { |
| 156 | switch v.Kind() { |
| 157 | case pref.EnumKind: |
| 158 | rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Enum().FullName())}) |
| 159 | case pref.MessageKind, pref.GroupKind: |
| 160 | rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Message().FullName())}) |
| 161 | default: |
| 162 | rs.recs = append(rs.recs, [2]string{"MapValue", v.Kind().String()}) |
| 163 | } |
| 164 | } |
| 165 | case "ContainingOneof": |
| 166 | if od := t.ContainingOneof(); od != nil { |
| 167 | rs.recs = append(rs.recs, [2]string{"Oneof", string(od.Name())}) |
| 168 | } |
| 169 | case "ContainingMessage": |
| 170 | if t.IsExtension() { |
| 171 | rs.recs = append(rs.recs, [2]string{"Extendee", string(t.ContainingMessage().FullName())}) |
| 172 | } |
| 173 | case "Message": |
| 174 | if !t.IsMap() { |
| 175 | rs.Append(rv, s) |
| 176 | } |
| 177 | default: |
| 178 | rs.Append(rv, s) |
| 179 | } |
| 180 | } |
| 181 | case pref.OneofDescriptor: |
| 182 | var ss []string |
| 183 | fs := t.Fields() |
| 184 | for i := 0; i < fs.Len(); i++ { |
| 185 | ss = append(ss, string(fs.Get(i).Name())) |
| 186 | } |
| 187 | if len(ss) > 0 { |
| 188 | rs.recs = append(rs.recs, [2]string{"Fields", "[" + joinStrings(ss, false) + "]"}) |
| 189 | } |
| 190 | default: |
| 191 | rs.Append(rv, descriptorAccessors[rt]...) |
| 192 | } |
| 193 | if rv.MethodByName("GoType").IsValid() { |
| 194 | rs.Append(rv, "GoType") |
| 195 | } |
| 196 | } |
| 197 | return start + rs.Join() + end |
| 198 | } |
| 199 | |
| 200 | type records struct { |
| 201 | recs [][2]string |
| 202 | allowMulti bool |
| 203 | } |
| 204 | |
| 205 | func (rs *records) Append(v reflect.Value, accessors ...string) { |
| 206 | for _, a := range accessors { |
| 207 | var rv reflect.Value |
| 208 | if m := v.MethodByName(a); m.IsValid() { |
| 209 | rv = m.Call(nil)[0] |
| 210 | } |
| 211 | if v.Kind() == reflect.Struct && !rv.IsValid() { |
| 212 | rv = v.FieldByName(a) |
| 213 | } |
| 214 | if !rv.IsValid() { |
| 215 | panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a)) |
| 216 | } |
| 217 | if _, ok := rv.Interface().(pref.Value); ok { |
| 218 | rv = rv.MethodByName("Interface").Call(nil)[0] |
| 219 | if !rv.IsNil() { |
| 220 | rv = rv.Elem() |
| 221 | } |
| 222 | } |
| 223 | |
| 224 | // Ignore zero values. |
| 225 | var isZero bool |
| 226 | switch rv.Kind() { |
| 227 | case reflect.Interface, reflect.Slice: |
| 228 | isZero = rv.IsNil() |
| 229 | case reflect.Bool: |
| 230 | isZero = rv.Bool() == false |
| 231 | case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
| 232 | isZero = rv.Int() == 0 |
| 233 | case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: |
| 234 | isZero = rv.Uint() == 0 |
| 235 | case reflect.String: |
| 236 | isZero = rv.String() == "" |
| 237 | } |
| 238 | if n, ok := rv.Interface().(list); ok { |
| 239 | isZero = n.Len() == 0 |
| 240 | } |
| 241 | if isZero { |
| 242 | continue |
| 243 | } |
| 244 | |
| 245 | // Format the value. |
| 246 | var s string |
| 247 | v := rv.Interface() |
| 248 | switch v := v.(type) { |
| 249 | case list: |
| 250 | s = formatListOpt(v, false, rs.allowMulti) |
| 251 | case pref.FieldDescriptor, pref.OneofDescriptor, pref.EnumValueDescriptor, pref.MethodDescriptor: |
| 252 | s = string(v.(pref.Descriptor).Name()) |
| 253 | case pref.Descriptor: |
| 254 | s = string(v.FullName()) |
| 255 | case string: |
| 256 | s = strconv.Quote(v) |
| 257 | case []byte: |
| 258 | s = fmt.Sprintf("%q", v) |
| 259 | default: |
| 260 | s = fmt.Sprint(v) |
| 261 | } |
| 262 | rs.recs = append(rs.recs, [2]string{a, s}) |
| 263 | } |
| 264 | } |
| 265 | |
| 266 | func (rs *records) Join() string { |
| 267 | var ss []string |
| 268 | |
| 269 | // In single line mode, simply join all records with commas. |
| 270 | if !rs.allowMulti { |
| 271 | for _, r := range rs.recs { |
| 272 | ss = append(ss, r[0]+formatColon(0)+r[1]) |
| 273 | } |
| 274 | return joinStrings(ss, false) |
| 275 | } |
| 276 | |
| 277 | // In allowMulti line mode, align single line records for more readable output. |
| 278 | var maxLen int |
| 279 | flush := func(i int) { |
| 280 | for _, r := range rs.recs[len(ss):i] { |
| 281 | ss = append(ss, r[0]+formatColon(maxLen-len(r[0]))+r[1]) |
| 282 | } |
| 283 | maxLen = 0 |
| 284 | } |
| 285 | for i, r := range rs.recs { |
| 286 | if isMulti := strings.Contains(r[1], "\n"); isMulti { |
| 287 | flush(i) |
| 288 | ss = append(ss, r[0]+formatColon(0)+strings.Join(strings.Split(r[1], "\n"), "\n\t")) |
| 289 | } else if maxLen < len(r[0]) { |
| 290 | maxLen = len(r[0]) |
| 291 | } |
| 292 | } |
| 293 | flush(len(rs.recs)) |
| 294 | return joinStrings(ss, true) |
| 295 | } |
| 296 | |
| 297 | func formatColon(padding int) string { |
| 298 | // Deliberately introduce instability into the debug output to |
| 299 | // discourage users from performing string comparisons. |
| 300 | // This provides us flexibility to change the output in the future. |
| 301 | if detrand.Bool() { |
| 302 | return ":" + strings.Repeat(" ", 1+padding) // use non-breaking spaces (U+00a0) |
| 303 | } else { |
| 304 | return ":" + strings.Repeat(" ", 1+padding) // use regular spaces (U+0020) |
| 305 | } |
| 306 | } |
| 307 | |
| 308 | func joinStrings(ss []string, isMulti bool) string { |
| 309 | if len(ss) == 0 { |
| 310 | return "" |
| 311 | } |
| 312 | if isMulti { |
| 313 | return "\n\t" + strings.Join(ss, "\n\t") + "\n" |
| 314 | } |
| 315 | return strings.Join(ss, ", ") |
| 316 | } |