Compilation error: LRO (sometimes?) doesn't clone the members required for setting header params

[antkmsft]

This affects specification/containerservice/resource-manager/Microsoft.ContainerService/fleet

It goes like this (see comments starting with <--)

pub fn create(
        &self,
        resource_group_name: &str,
        fleet_name: &str,
        fleet_member_name: &str,
        resource: RequestContent<FleetMember>,
        options: Option<ContainerServiceFleetMembersClientCreateOptions<'_>>,
    ) -> Result<Poller<ContainerServiceFleetMembersClientCreateOperationStatus>> {
        let options = options.unwrap_or_default().into_owned();
        let pipeline = self.pipeline.clone();
        let mut url = self.endpoint.clone();
        let mut path = String::from("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/members/{fleetMemberName}");
        path = path.replace("{fleetMemberName}", fleet_member_name);
        path = path.replace("{fleetName}", fleet_name);
        path = path.replace("{resourceGroupName}", resource_group_name);
        path = path.replace("{subscriptionId}", &self.subscription_id);
        url.append_path(&path);
        let mut query_builder = url.query_builder();
        query_builder.set_pair("api-version", &self.api_version);
        query_builder.build();
        let api_version = self.api_version.clone();
        Ok(Poller::new(
            move |poller_state: PollerState, poller_options| {
                let (mut request, continuation) = match poller_state {
                    PollerState::More(continuation) => {
                        let (mut next_link, final_link) = match continuation {
                            PollerContinuation::Links {
                                next_link,
                                final_link,
                            } => (next_link, final_link),
                            _ => {
                                unreachable!()
                            }
                        };
                        let mut query_builder = next_link.query_builder();
                        query_builder.set_pair("api-version", &api_version);
                        query_builder.build();
                        let mut request = Request::new(next_link.clone(), Method::Get);
                        request.insert_header("accept", "application/json");
                        request.insert_header("content-type", "application/json");
                        if let Some(if_match) = options.if_match.as_ref() { // <-- ok here
                            request.insert_header("if-match", if_match);
                        }
                        if let Some(if_none_match) = options.if_none_match.as_ref() {
                            request.insert_header("if-none-match", if_none_match);
                        }
                        (
                            request,
                            PollerContinuation::Links {
                                next_link,
                                final_link,
                            },
                        )
                    }
                    PollerState::Initial => {
                        let mut request = Request::new(url.clone(), Method::Put);
                        request.insert_header("accept", "application/json");
                        request.insert_header("content-type", "application/json");
                        if let Some(if_match) = options.if_match.as_ref() {
                            request.insert_header("if-match", if_match);
                        }
                        if let Some(if_none_match) = options.if_none_match.as_ref() {
                            request.insert_header("if-none-match", if_none_match);
                        }
                        request.set_body(resource.clone());
                        (
                            request,
                            PollerContinuation::Links {
                                next_link: url.clone(),
                                final_link: None,
                            },
                        )
                    }
                };
                let ctx = poller_options.context.clone();
                let pipeline = pipeline.clone();
                let url = url.clone();
                // <-- doesn't clone if_match here
                Box::pin(async move {
                    let rsp = pipeline
                        .send(
                            &ctx,
                            &mut request,
                            Some(PipelineSendOptions {
                                check_success: CheckSuccessOptions {
                                    success_codes: &[200, 201],
                                },
                                ..Default::default()
                            }),
                        )
                        .await?;
                    let (status, headers, body) = rsp.deconstruct();
                    let continuation = if let Some(final_link) = headers
                        .get_optional_string(&HeaderName::from_static("azure-asyncoperation"))
                    {
                        let final_link = Url::parse(&final_link)?;
                        match continuation {
                            PollerContinuation::Links { next_link, .. } => {
                                PollerContinuation::Links {
                                    next_link,
                                    final_link: Some(final_link),
                                }
                            }
                            _ => {
                                unreachable!()
                            }
                        }
                    } else {
                        continuation
                    };
                    let final_link = match &continuation {
                        PollerContinuation::Links { final_link, .. } => {
                            final_link.clone().unwrap_or_else(|| url.clone())
                        }
                        _ => {
                            unreachable!()
                        }
                    };
                    let retry_after = get_retry_after(
                        &headers,
                        &[X_MS_RETRY_AFTER_MS, RETRY_AFTER_MS, RETRY_AFTER],
                        &poller_options,
                    );
                    let res: ContainerServiceFleetMembersClientCreateOperationStatus =
                        json::from_json(&body)?;
                    let rsp = RawResponse::from_bytes(status, headers, body).into();
                    Ok(match res.status() {
                        PollerStatus::InProgress => PollerResult::InProgress {
                            response: rsp,
                            retry_after,
                            continuation,
                        },
                        PollerStatus::Succeeded => PollerResult::Succeeded {
                            response: rsp,
                            target: Box::new(move || {
                                Box::pin(async move {
                                    let mut request = Request::new(final_link, Method::Get);
                                    request.insert_header("accept", "application/json");
                                    request.insert_header("content-type", "application/json");
                                    if let Some(if_match) = if_match.as_ref() { // <-- fails here
                                        request.insert_header("if-match", if_match);
                                    }
                                    if let Some(if_none_match) = if_none_match.as_ref() {
                                        request.insert_header("if-none-match", if_none_match);
                                    }
                                    Ok(pipeline.send(&ctx, &mut request, None).await?.into())
                                })
                            }),
                        },
                        _ => PollerResult::Done { response: rsp },
                    })
                })
            },
            Some(options.method_options),
        ))
    }

[antkmsft]

Similarly, in specification/eventgrid/data-plane/EventGridNamespace

#[derive(Clone, Default, SafeDebug)]
pub struct DataProtectionBackupInstancesClientCreateOrUpdateOptions<'a> {
    /// Allows customization of the method call.
    pub method_options: PollerOptions<'a>,

    pub x_ms_authorization_auxiliary: Option<String>,
}

and then

                        PollerStatus::Succeeded => PollerResult::Succeeded {
                            response: rsp,
                            target: Box::new(move || {
                                Box::pin(async move {
                                    let mut request = Request::new(final_link, Method::Get);
                                    request.insert_header("accept", "application/json");
                                    request.insert_header("content-type", "application/json");
                                    if let Some(x_ms_authorization_auxiliary) =
                                        x_ms_authorization_auxiliary.as_ref()
                                    {
                                        request.insert_header(
                                            "x-ms-authorization-auxiliary",
                                            x_ms_authorization_auxiliary,
                                        );
                                    }
                                    Ok(pipeline.send(&ctx, &mut request, None).await?.into())
                                })
                            }),
                        },

[antkmsft]

Similar, but slightly different (affects specification/apimanagement/resource-manager/Microsoft.ApiManagement/ApiManagement).
This is not only about options members - in the case below, if_match is a function parameter, i.e.

error[E0507]: cannot move out of `if_match`, a captured variable in an `Fn` closure
   --> spec\rmApiMgmt\src\generated\clients\api_management_api_client.rs:355:26
    |
295 |         if_match: String,
    |         --------  ------ move occurs because `if_match` has type `std::string::String`, which does not implement the `Copy` trait
    |         |
    |         captured outer variable
...
315 |             move |poller_state: PollerState, poller_options| {
    |             ------------------------------------------------ captured by this `Fn` closure
...
355 |                 Box::pin(async move {
    |                          ^^^^^^^^^^ `if_match` is moved here
...
431 |                                     request.insert_header("if-match", &if_match);
    |                                                                        -------- variable moved due to use in coroutine
    |

#[tracing::function("Microsoft.ApiManagement.ApiContracts.delete")]
    pub fn delete(
        &self,
        resource_group_name: &str,
        service_name: &str,
        api_id: &str,
        if_match: String,
        options: Option<ApiManagementApiClientDeleteOptions<'_>>,
    ) -> Result<Poller<ApiManagementApiClientDeleteOperationStatus>> {
        let options = options.unwrap_or_default().into_owned();
        let pipeline = self.pipeline.clone();
        let mut url = self.endpoint.clone();
        let mut path = String::from("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/apis/{apiId}");
        path = path.replace("{apiId}", api_id);
        path = path.replace("{resourceGroupName}", resource_group_name);
        path = path.replace("{serviceName}", service_name);
        path = path.replace("{subscriptionId}", &self.subscription_id);
        url.append_path(&path);
        let mut query_builder = url.query_builder();
        query_builder.set_pair("api-version", &self.api_version);
        if let Some(delete_revisions) = options.delete_revisions {
            query_builder.set_pair("deleteRevisions", delete_revisions.to_string());
        }
        query_builder.build();
        let api_version = self.api_version.clone();
        Ok(Poller::new(
            move |poller_state: PollerState, poller_options| {
                let (mut request, continuation) = match poller_state {
                    PollerState::More(continuation) => {
                        let (mut next_link, final_link) = match continuation.clone() {
                            PollerContinuation::Links {
                                next_link,
                                final_link,
                            } => (next_link, final_link),
                            _ => {
                                unreachable!()
                            }
                        };
                        let mut query_builder = next_link.query_builder();
                        query_builder.set_pair("api-version", &api_version);
                        query_builder.build();
                        let mut request = Request::new(next_link.clone(), Method::Get);
                        request.insert_header("if-match", &if_match);
                        (
                            request,
                            PollerContinuation::Links {
                                next_link,
                                final_link,
                            },
                        )
                    }
                    PollerState::Initial => {
                        let mut request = Request::new(url.clone(), Method::Delete);
                        request.insert_header("if-match", &if_match);
                        (
                            request,
                            PollerContinuation::Links {
                                next_link: url.clone(),
                                final_link: None,
                            },
                        )
                    }
                };
                let ctx = poller_options.context.clone();
                let pipeline = pipeline.clone();
                let url = url.clone();
                Box::pin(async move {
                    let rsp = pipeline
                        .send(
                            &ctx,
                            &mut request,
                            Some(PipelineSendOptions {
                                check_success: CheckSuccessOptions {
                                    success_codes: &[200, 202, 204],
                                },
                                ..Default::default()
                            }),
                        )
                        .await?;
                    let (status, headers, body) = rsp.deconstruct();
                    let continuation = if let Some(operation_location) = headers
                        .get_optional_string(&HeaderName::from_static("azure-asyncoperation"))
                    {
                        let next_link = Url::parse(&operation_location)?;
                        match continuation {
                            PollerContinuation::Links { final_link, .. } => {
                                PollerContinuation::Links {
                                    next_link,
                                    final_link,
                                }
                            }
                            _ => {
                                unreachable!()
                            }
                        }
                    } else {
                        continuation
                    };
                    let continuation = if let Some(final_link) =
                        headers.get_optional_string(&HeaderName::from_static("location"))
                    {
                        let final_link = Url::parse(&final_link)?;
                        match continuation {
                            PollerContinuation::Links { next_link, .. } => {
                                PollerContinuation::Links {
                                    next_link,
                                    final_link: Some(final_link),
                                }
                            }
                            _ => {
                                unreachable!()
                            }
                        }
                    } else {
                        continuation
                    };
                    let final_link = match &continuation {
                        PollerContinuation::Links { final_link, .. } => {
                            final_link.clone().unwrap_or_else(|| url.clone())
                        }
                        _ => {
                            unreachable!()
                        }
                    };
                    let retry_after = get_retry_after(
                        &headers,
                        &[X_MS_RETRY_AFTER_MS, RETRY_AFTER_MS, RETRY_AFTER],
                        &poller_options,
                    );
                    let res: ApiManagementApiClientDeleteOperationStatus = json::from_json(&body)?;
                    let rsp = RawResponse::from_bytes(status, headers, body).into();
                    Ok(match res.status() {
                        PollerStatus::InProgress => PollerResult::InProgress {
                            response: rsp,
                            retry_after,
                            continuation,
                        },
                        PollerStatus::Succeeded => PollerResult::Succeeded {
                            response: rsp,
                            target: Box::new(move || {
                                Box::pin(async move {
                                    let mut request = Request::new(final_link, Method::Get);
                                    request.insert_header("if-match", &if_match);
                                    Ok(pipeline.send(&ctx, &mut request, None).await?.into())
                                })
                            }),
                        },
                        _ => PollerResult::Done { response: rsp },
                    })
                })
            },
            Some(options.method_options),
        ))
    }

[RickWinter]

Analysis: LRO target closure missing clones for header params and method params

Problem

In generated LRO (Long-Running Operation) methods, the PollerStatus::Succeeded target closure (a Box::new(move || Box::pin(async move { ... }))) references option fields (e.g., options.if_match) and method parameters (e.g., if_match: String) that were not cloned before entering the nested closure chain.

The outer closure is Fn (must be callable multiple times), but the inner async move block tries to move captured variables. This causes:

• cannot move out of X, a captured variable in an Fn closure for non-Copy method parameters
• Undefined variable errors for option fields that were destructured in the outer scope but not cloned for the inner scope

Affected specs: ContainerService/fleet, EventGrid, DataProtection, ApiManagement.

Root Cause

In packages/typespec-rust/src/codegen/clients.ts (lines ~1638-1885), the LRO poller closure generation has a section before Box::pin(async move { ... }) that clones specific variables:

• ctx, pipeline, url, final_link are cloned (lines ~1672-1688)

However, header parameters from options (like if_match, if_none_match, x_ms_authorization_auxiliary) and non-Copy method parameters (like if_match: String) are NOT cloned before the inner async block or the nested target closure.

The target closure at lines ~1849-1868 generates Box::new(move || Box::pin(async move { ... })) which uses these parameters to set request headers, but since they weren''t cloned, Rust rejects the move.

Two sub-cases:

1. Option fields (e.g., options.if_match): Used in the outer Fn closure scope but need to be cloned before the target: Box::new(move || ...) block.
2. Method parameters (e.g., if_match: String): Captured by the outer Fn closure but async move tries to take ownership on each invocation.

Plan to Fix

In clients.ts, in the getLroMethodBody() function:

1. Before the Box::pin(async move { ... }) block: Identify all header parameters from options and non-Copy method parameters that are used inside the async block, and emit .clone() for each.
2. Before the target: Box::new(move || ...) block: Similarly clone all variables that the target closure needs to reference. This is the nested closure inside PollerStatus::Succeeded.
3. Use the same pattern already established for ctx, pipeline, and url: emit let if_match = options.if_match.clone(); (or let if_match = if_match.clone(); for method params) before each nested closure boundary.

Plan to Test

1. Unit test: Add a TypeSpec test under test/tsp/ with an LRO operation that has optional header parameters (e.g., if-match, if-none-match). Regenerate and verify compilation.
2. Targeted spec compilation: Generate ContainerService/fleet and ApiManagement specs and verify cargo check passes.
3. Regression: Regenerate all test crates; verify existing LRO test crates (e.g., test/other/lro/) still compile and pass tests.