Struct MethodPlan 

pub struct MethodPlan {

    pub metadata: MethodMetadata,
    pub handler_function_name: String,
    pub http_pattern: HttpPattern,
    pub http_method: String,
    pub parameters: Vec<RequestParam>,
    pub has_response: bool,
    pub request_type: RequestType,
    pub output_resource_type: Option<String>,
    pub has_request_body: bool,
    pub needs_request_parts: bool,
    pub scoped_verb: Option<String>,
    pub shape: MethodShape,
    pub has_http_route: bool,
}

Plan for generating code for a single method

Fields

metadata: MethodMetadata

Original method metadata

handler_function_name: String

Rust function name for the handler method

http_pattern: HttpPattern

Pre-parsed HTTP URL pattern

http_method: String

HTTP method string for routing (e.g., “GET”, “POST”)

parameters: Vec<RequestParam>

Parameters passed to the method (path, query, and body)

has_response: bool

Whether this method returns a response body

request_type: RequestType

Request type for this method

output_resource_type: Option<String>

The resource type name returned by this method (if any)

has_request_body: bool

Whether the HTTP request carries a JSON body (create / update / custom POST·PATCH).

Derived once from RequestType so the client emitter doesn’t re-match the enum to decide whether to attach .json(request).

needs_request_parts: bool

Whether the Axum server extractor reads from request parts (path/query only) rather than the body — i.e. this is a FromRequestParts method, not FromRequest.

Derived once from RequestType so the server emitter (extractor selection and the RequestPartsExt import) doesn’t re-match the enum.

scoped_verb: Option<String>

The verb name to call on a resource-scoped client (get / update / delete), or None for methods that are not standard instance verbs.

Derived once from RequestType; the scoped binding call uses this instead of re-deciding the verb from the enum (see MethodPlan::resource_client_method).

shape: MethodShape

Where this method sits relative to a resource (collection / instance / unbound).

Assigned in analyze_service once the owning service’s managed resources are known, so it reflects both the method’s verb/name shape and whether the service is resource-scoped.

has_http_route: bool

Whether this method has a google.api.http route.

Analysis is protocol-agnostic: every method gets a plan. A method without an HTTP annotation still produces a plan (with all request fields as body, no path/query) so the ConnectRPC emitter can use it — but it has no REST route, so the REST client/handler emitters skip it. true for methods with an HTTP annotation, false otherwise.

Implementations

impl MethodPlan

pub fn path_parameters(&self) -> impl Iterator<Item = &PathParam>

pub fn formats_path_values(&self) -> bool

Whether the REST client formats path parameters into the URL.

pub fn query_parameters(&self) -> impl Iterator<Item = &QueryParam>

pub fn body_fields(&self) -> impl Iterator<Item = &BodyField>

Trait Implementations

impl Clone for MethodPlan

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MethodPlan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.