impl(rust): generate gcp.resource.name using annotations (#2932)

This commit updates the Rust generator to populate the
`gcp.resource.name`
tracing attribute in `RequestOptions` by inspecting
`google.api.resource_reference`
annotations on request fields.

Key changes:
- Implements a revised heuristic in `annotate.go` that prioritizes
annotated fields,
  including nested fields up to one level deep.
- Updates `transport.rs.mustache` to inject runtime logic that evaluates
candidate
  fields in priority order (e.g., `name`, `parent`, `resource`).
- Adds `candidateField` struct and `findResourceNameFields` logic to
support
  runtime resolution of the resource name.

This ensures that traces generated by the Rust client libraries contain
the
correct resource name, improving observability and alignment with GCP
standards.

Author: westarle

internal/sidekick/api/model.go

@@ -747,6 +747,8 @@ type Field struct {
 	// - For OpenAPI, it is an optional field
 	// - For OpenAPI, it has format == "uuid"
 	AutoPopulated bool
+	// IsResourceReference is true if the field is annotated with google.api.resource_reference.
+	IsResourceReference bool
 	// FieldBehavior indicates how the field behaves in requests and responses.
 	//
 	// For example, that a field is required in requests, or given as output

internal/sidekick/parser/protobuf.go

@@ -499,14 +499,15 @@ func processMessage(state *api.APIState, m *descriptorpb.DescriptorProto, mFQN,
 	for _, mf := range m.Field {
 		isProtoOptional := mf.Proto3Optional != nil && *mf.Proto3Optional
 		field := &api.Field{
-			Name:          mf.GetName(),
-			ID:            mFQN + "." + mf.GetName(),
-			JSONName:      mf.GetJsonName(),
-			Deprecated:    mf.GetOptions().GetDeprecated(),
-			Optional:      isProtoOptional,
-			IsOneOf:       mf.OneofIndex != nil && !isProtoOptional,
-			AutoPopulated: protobufIsAutoPopulated(mf),
-			Behavior:      protobufFieldBehavior(mf),
+			Name:                mf.GetName(),
+			ID:                  mFQN + "." + mf.GetName(),
+			JSONName:            mf.GetJsonName(),
+			Deprecated:          mf.GetOptions().GetDeprecated(),
+			Optional:            isProtoOptional,
+			IsOneOf:             mf.OneofIndex != nil && !isProtoOptional,
+			AutoPopulated:       protobufIsAutoPopulated(mf),
+			IsResourceReference: protobufIsResourceReference(mf),
+			Behavior:            protobufFieldBehavior(mf),
 		}
 		normalizeTypes(state, mf, field)
 		message.Fields = append(message.Fields, field)

internal/sidekick/parser/protobuf_annotations.go

@@ -192,3 +192,10 @@ func protobufIsAutoPopulated(field *descriptorpb.FieldDescriptorProto) bool {
 
 	return true
 }
+
+func protobufIsResourceReference(field *descriptorpb.FieldDescriptorProto) bool {
+	if field.GetType() != descriptorpb.FieldDescriptorProto_TYPE_STRING {
+		return false
+	}
+	return proto.HasExtension(field.GetOptions(), annotations.E_ResourceReference)
+}

internal/sidekick/parser/protobuf_test.go

@@ -1595,12 +1595,13 @@ func TestProtobuf_AutoPopulated(t *testing.T) {
 		Documentation: "A request to create a `Foo` resource.",
 		Fields: []*api.Field{
 			{
-				Name:          "parent",
-				JSONName:      "parent",
-				ID:            ".test.CreateFooRequest.parent",
-				Documentation: "Required. The resource name of the project.",
-				Typez:         api.STRING_TYPE,
-				Behavior:      []api.FieldBehavior{api.FIELD_BEHAVIOR_REQUIRED},
+				Name:                "parent",
+				JSONName:            "parent",
+				ID:                  ".test.CreateFooRequest.parent",
+				Documentation:       "Required. The resource name of the project.",
+				Typez:               api.STRING_TYPE,
+				Behavior:            []api.FieldBehavior{api.FIELD_BEHAVIOR_REQUIRED},
+				IsResourceReference: true,
 			},
 			{
 				Name:          "foo_id",

internal/sidekick/rust/annotate.go

@@ -27,6 +27,14 @@ import (
 	"github.com/iancoleman/strcase"
 )
 
+// resourceNameCandidateField represents a potential field to use for the resource name.
+type resourceNameCandidateField struct {
+	FieldPath []string // e.g., ["book"], ["book", "name"]
+	Field     *api.Field
+	IsNested  bool
+	Accessor  string
+}
+
 type modelAnnotations struct {
 	PackageName      string
 	PackageVersion   string
@@ -223,6 +231,8 @@ type methodAnnotation struct {
 	Attributes                []string
 	RoutingRequired           bool
 	DetailedTracingAttributes bool
+	ResourceNameFields        []*resourceNameCandidateField
+	HasResourceNameFields     bool
 }
 
 type pathInfoAnnotation struct {
@@ -690,6 +700,139 @@ func (c *codec) addFeatureAnnotations(model *api.API, ann *modelAnnotations) {
 	}
 }
 
+// makeChainAccessor generates the Rust accessor code for a chain of fields.
+// It handles optional fields and oneofs correctly.
+// parentAccessor is the accessor for the parent message (e.g. "req").
+func makeChainAccessor(fields []*api.Field, parentAccessor string) string {
+	accessor := parentAccessor
+	for i, field := range fields {
+		fieldName := toSnake(field.Name)
+		if i == 0 {
+			// First field in the chain
+			if field.IsOneOf {
+				accessor = fmt.Sprintf("%s.%s()", accessor, fieldName)
+			} else if field.Optional {
+				accessor = fmt.Sprintf("%s.%s.as_ref()", accessor, fieldName)
+			} else {
+				accessor = fmt.Sprintf("Some(&%s.%s)", accessor, fieldName)
+			}
+		} else {
+			// Subsequent fields (nested)
+			if field.IsOneOf {
+				accessor = fmt.Sprintf("%s.and_then(|s| s.%s())", accessor, fieldName)
+			} else if field.Optional {
+				accessor = fmt.Sprintf("%s.and_then(|s| s.%s.as_ref())", accessor, fieldName)
+			} else {
+				accessor = fmt.Sprintf("%s.map(|s| &s.%s)", accessor, fieldName)
+			}
+		}
+	}
+	return accessor
+}
+
+// findResourceNameCandidates identifies all fields annotated with google.api.resource_reference.
+// It searches top-level fields and fields nested one level deep.
+func (c *codec) findResourceNameCandidates(m *api.Method) []*resourceNameCandidateField {
+	var candidates []*resourceNameCandidateField
+
+	// Find top-level annotated fields
+	for _, field := range m.InputType.Fields {
+		if field.IsResourceReference && !field.Repeated && !field.Map && field.Typez == api.STRING_TYPE {
+			candidates = append(candidates, &resourceNameCandidateField{
+				FieldPath: []string{field.Name},
+				Field:     field,
+				IsNested:  false,
+				Accessor:  makeChainAccessor([]*api.Field{field}, "req"),
+			})
+		}
+	}
+
+	// Find nested annotated fields (one level deep)
+	for _, field := range m.InputType.Fields {
+		if field.MessageType == nil || field.Repeated || field.Map {
+			continue
+		}
+		for _, nestedField := range field.MessageType.Fields {
+			if !nestedField.IsResourceReference || nestedField.Repeated || nestedField.Map || nestedField.Typez != api.STRING_TYPE {
+				continue
+			}
+			candidates = append(candidates, &resourceNameCandidateField{
+				FieldPath: []string{field.Name, nestedField.Name},
+				Field:     nestedField,
+				IsNested:  true,
+				Accessor:  makeChainAccessor([]*api.Field{field, nestedField}, "req"),
+			})
+		}
+	}
+	return candidates
+}
+
+func (c *codec) findResourceNameFields(m *api.Method) []*resourceNameCandidateField {
+	if m.InputType == nil {
+		return nil
+	}
+
+	candidates := c.findResourceNameCandidates(m)
+
+	if len(candidates) == 0 {
+		return nil
+	}
+
+	// Check for HTTP path presence
+	var httpParams map[string]bool
+	if m.PathInfo != nil && m.PathInfo.Codec != nil {
+		if pia, ok := m.PathInfo.Codec.(*pathInfoAnnotation); ok {
+			httpParams = make(map[string]bool)
+			for _, p := range pia.UniqueParameters {
+				httpParams[p.FieldName] = true
+			}
+		}
+	}
+
+	isInPath := func(c *resourceNameCandidateField) bool {
+		if httpParams == nil {
+			return false
+		}
+		var snakeParts []string
+		for _, p := range c.FieldPath {
+			snakeParts = append(snakeParts, toSnake(p))
+		}
+		fieldName := strings.Join(snakeParts, ".")
+		return httpParams[fieldName]
+	}
+
+	slices.SortStableFunc(candidates, compareResourceNameCandidates(isInPath))
+
+	return candidates
+}
+
+// sortResourceNameCandidates sorts candidates by priority:
+// 1. Top-level fields (IsNested == false).
+// 2. Fields in HTTP path (isInPath == true).
+// 3. Proto definition order (stable sort).
+func compareResourceNameCandidates(isInPath func(*resourceNameCandidateField) bool) func(a, b *resourceNameCandidateField) int {
+	return func(a, b *resourceNameCandidateField) int {
+		// 1. Top-level before Nested.
+		if a.IsNested != b.IsNested {
+			if !a.IsNested {
+				return -1 // a is top (false), b is nested (true) -> a < b
+			}
+			return 1
+		}
+		// 2. In-Path before Not-In-Path.
+		inPathA := isInPath(a)
+		inPathB := isInPath(b)
+		if inPathA != inPathB {
+			if inPathA {
+				return -1 // a is in-path (true), b is not (false) -> a < b
+			}
+			return 1
+		}
+		// 3. Stable sort preserves proto order.
+		return 0
+	}
+}
+
 // packageToModuleName maps "google.foo.v1" to "google::foo::v1".
 func packageToModuleName(p string) string {
 	components := strings.Split(p, ".")
@@ -805,6 +948,7 @@ func (c *codec) annotateMethod(m *api.Method) {
 		returnType = "()"
 	}
 	serviceName := c.ServiceName(m.Service)
+	resourceNameFields := c.findResourceNameFields(m)
 	annotation := &methodAnnotation{
 		Name:                      toSnake(m.Name),
 		NameNoMangling:            toSnakeNoMangling(m.Name),
@@ -820,6 +964,8 @@ func (c *codec) annotateMethod(m *api.Method) {
 		HasVeneer:                 c.hasVeneer,
 		RoutingRequired:           c.routingRequired,
 		DetailedTracingAttributes: c.detailedTracingAttributes,
+		ResourceNameFields:        resourceNameFields,
+		HasResourceNameFields:     len(resourceNameFields) > 0,
 	}
 	if annotation.Name == "clone" {
 		// Some methods look too similar to standard Rust traits. Clippy makes