What is the idiomatic way to get the corresponding struct field for a FieldDescriptorProto?

[junghoahnsc]

Hello,

I'm trying to loop each field of a message and check proto field option. For example,

rval := reflect.Value(m)
...
_, descProt := descriptor.ForMessage(m)
for _, fd := range d.GetField() {
  // check the field option
  opts := fd.GetOptions()
  c, err := proto.GetExtension(opts, xxx)
  ...
  if condition {
     field := rval.FieldByName(fd.GetName() ???)
  }
}

Here, fd.GetName() returns the proto field name, so we need to convert to Go name.
Should I use https://github.com/golang/protobuf/blob/master/protoc-gen-go/generator/generator.go#L2736 ? Or is there any better way to do that?

Thanks,

[dsnet]

Unfortunately, there's currently not really an idiomatic way to do this.

• The generated field name is a combination of both generator.CamelCase and generator.allocNames.
• There is no compatibility guarantees for the generator package and you should not depend on it.
• This code makes the assumption that generated structs are always just flat structs with fields. This may not always be the case in the future, and is certainly not true for all implementations of proto.Message.

The solution for this is #364, so that you can use some proto reflection API to obtain the field value.

[dsnet]

I'm going to close this in favor of #364.

[jhump]

FWIW, @junghoahnsc, it is possible to extract the field with existing APIs. But it isn't trivial (and not very pretty):

rval := reflect.Value(m)
props := proto.GetProperties(reflect.TypeOf(m).Elem())
// ...
_, descProt := descriptor.ForMessage(m)
for _, fd := range descProt.GetField(m) {
    // check the field option
    opts := fd.GetOptions()
    c, err := proto.GetExtension(opts, xxx)
    // ...
    if condition {
        var field reflect.Value
        for _, p := range props.Prop {
            if int32(p.Tag) == fd.GetNumber() {
                field = rval.FieldByName(p.Name)
                break
            }
        }
        if !field.IsValid() {
            // must be a one-of if not found above
            for _, oo := range props.OneofTypes {
                if int32(oo.Prop.Tag) == fd.GetNumber() {
                    field = rval.Field(oo.Field).Elem().FieldByName(oo.Prop.Name)
                    break
                }
            }
        }
        if !field.IsValid() {
            panic(fmt.Sprintf("cannot find struct field for %s, tag %d", fd.GetName(), fd.GetNumber()))
        }
        // do something with field...
    }
}

Note that this code is a naive implementation. (A better one would probably pre-compute a map of tag number -> accessor function to avoid paying the linear scan for each field query. As is, the example code is quadratic when it could be linear.)

[junghoahnsc]

@jhump Thanks for the tip!

And I noticed that StructProperties has decoderTags and decoderOrigNames and I guess it would be much easier if it has public APIs to use them.