Update APIs to use new Google cloud paths.

grpc/cmd/rpc/printer.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package main
 
 import (
         "fmt"
         "io"
         "strings"
 
+        "github.com/luci/luci-go/common/proto/google/descutil"
+
         "github.com/luci/luci-go/common/data/text/indented"
-        "github.com/luci/luci-go/common/proto/google/descriptor"
+        "google.golang.org/genproto/protobuf"
 )
 
 // printer prints a proto3 definition from a description.
 // Does not support options.
 type printer struct {
         // File is the file containing the desriptors being printed.
         // Used to relativize names and print comments.
         File *descriptor.FileDescriptorProto
         Out  indented.Writer
 
@@ skipping 33 matching lines @@
 // MaybeLeadingComments prints leading comments of the protobuf entity
 // at path, if found.
 //
 // For path, see comment in SourceCodeInfo.Location message in
 // common/proto/google/descriptor/descriptor.proto.
 func (p *printer) MaybeLeadingComments(path []int) {
         if p.File == nil || p.File.SourceCodeInfo == nil || len(path) == 0 {
                 return
         }
 
-        loc := p.File.SourceCodeInfo.FindLocation(path)
+        loc := descutil.FindLocation(p.File.SourceCodeInfo, path)
         if loc == nil {
                 return
         }
 
         comments := loc.GetLeadingComments()
         // print comments, but insert "//" before each newline.
         for len(comments) > 0 {
                 var toPrint string
                 if lineEnd := strings.Index(comments, "\n"); lineEnd >= 0 {
                         toPrint = comments[:lineEnd+1] // includes newline
@@ skipping 16 matching lines @@
         }
         return name
 }
 
 // Service prints a service definition.
 // If methodIndex != -1, only one method is printed.
 // If serviceIndex != -1, leading comments are printed if found.
 func (p *printer) Service(service *descriptor.ServiceDescriptorProto, serviceIndex, methodIndex int) {
         var path []int
         if serviceIndex != -1 {
-                path = []int{descriptor.NumberFileDescriptorProto_Service, serviceIndex}
+                path = []int{descutil.FileDescriptorProtoServiceTag, serviceIndex}
                 p.MaybeLeadingComments(path)
         }
         defer p.open("service %s", service.GetName())()
 
         printMethod := func(i int) {
                 var methodPath []int
                 if path != nil {
-                        methodPath = append(path, descriptor.NumberServiceDescriptorProto_Method, i)
+                        methodPath = append(path, descutil.ServiceDescriptorProtoMethodTag, i)
                 }
                 p.Method(service.Method[i], methodPath)
         }
 
         if methodIndex < 0 {
                 for i := range service.Method {
                         printMethod(i)
                 }
         } else {
                 printMethod(methodIndex)
@@ skipping 36 matching lines @@
         descriptor.FieldDescriptorProto_TYPE_SINT64:   "sint64",
 }
 
 // Field prints a field definition.
 //
 // If path is specified, leading comments are printed if found.
 // See also comment in SourceCodeInfo.Location message in
 // common/proto/google/descriptor/descriptor.proto.
 func (p *printer) Field(field *descriptor.FieldDescriptorProto, path []int) {
         p.MaybeLeadingComments(path)
-        if field.Repeated() {
+        if descutil.Repeated(field) {
                 p.Printf("repeated ")
         }
 
         typeName := fieldTypeName[field.GetType()]
         if typeName == "" {
                 typeName = p.shorten(field.GetTypeName())
         }
         if typeName == "" {
                 typeName = "<unsupported type>"
         }
@@ skipping 10 matching lines @@
         defer p.open("message %s", msg.GetName())()
 
         for i := range msg.GetOneofDecl() {
                 p.OneOf(msg, i, path)
         }
 
         for i, f := range msg.Field {
                 if f.OneofIndex == nil {
                         var fieldPath []int
                         if len(path) > 0 {
-                                fieldPath = append(path, descriptor.NumberDescriptorProto_Field, i)
+                                fieldPath = append(path, descutil.DescriptorProtoFieldTag, i)
                         }
                         p.Field(msg.Field[i], fieldPath)
                 }
         }
 }
 
 // OneOf prints a oneof definition.
 //
 // If path is specified, leading comments are printed if found.
 // See also comment in SourceCodeInfo.Location message in
 // common/proto/google/descriptor/descriptor.proto.
 func (p *printer) OneOf(msg *descriptor.DescriptorProto, oneOfIndex int, msgPath []int) {
         of := msg.GetOneofDecl()[oneOfIndex]
         if len(msgPath) > 0 {
-                p.MaybeLeadingComments(append(msgPath, descriptor.NumberDescriptorProto_OneOf, oneOfIndex))
+                p.MaybeLeadingComments(append(msgPath, descutil.DescriptorProtoOneOfTag, oneOfIndex))
         }
         defer p.open("oneof %s", of.GetName())()
 
         for i, f := range msg.Field {
                 if f.OneofIndex != nil && int(f.GetOneofIndex()) == oneOfIndex {
                         var fieldPath []int
                         if len(msgPath) > 0 {
-                                fieldPath = append(msgPath, descriptor.NumberDescriptorProto_Field, i)
+                                fieldPath = append(msgPath, descutil.DescriptorProtoFieldTag, i)
                         }
                         p.Field(msg.Field[i], fieldPath)
                 }
         }
 }
 
 // Enum prints an enum definition.
 //
 // If path is specified, leading comments are printed if found.
 // See also comment in SourceCodeInfo.Location message in
 // common/proto/google/descriptor/descriptor.proto.
 func (p *printer) Enum(enum *descriptor.EnumDescriptorProto, path []int) {
         p.MaybeLeadingComments(path)
         defer p.open("enum %s", enum.GetName())()
 
         for i, v := range enum.Value {
                 var valuePath []int
                 if len(path) > 0 {
-                        valuePath = append(path, descriptor.NumberEnumDescriptorProto_Value, i)
+                        valuePath = append(path, descutil.EnumDescriptorProtoValueTag, i)
                 }
                 p.EnumValue(v, valuePath)
         }
 }
 
 // EnumValue prints an enum value definition.
 //
 // If path is specified, leading comments are printed if found.
 // See also comment in SourceCodeInfo.Location message in
 // common/proto/google/descriptor/descriptor.proto.
 func (p *printer) EnumValue(v *descriptor.EnumValueDescriptorProto, path []int) {
         p.MaybeLeadingComments(path)
         p.Printf("%s = %d;\n", v.GetName(), v.GetNumber())
 }