@azure-tools/typespec-rust 0.29.0 → 0.30.0

package/dist/src/codegen/clients.js

@@ -10,6 +10,7 @@ import { CodegenError } from './errors.js';
 import * as helpers from './helpers.js';
 import queryString from 'query-string';
 import { Use } from './use.js';
+import * as rust from '../codemodel/index.js';
 import * as shared from '../shared/shared.js';
 /**
  * emits the content for all client files
@@ -43,7 +44,7 @@ export function emitClients(crate) {
             body += `${indent.get()}${helpers.emitVisibility(field.visibility)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
         }
         body += '}\n\n'; // end client
-        if (client.constructable) {
+        if (client.constructable && !client.constructable.suppressed) {
             // if client options doesn't require an impl for Default then just derive it
             let deriveDefault = 'Default, ';
             if (clientOptionsImplDefault(client.constructable)) {
@@ -67,7 +68,7 @@ export function emitClients(crate) {
             }
         }
         body += `impl ${client.name} {\n`;
-        if (client.constructable) {
+        if (client.constructable && !client.constructable.suppressed) {
             // this is an instantiable client, so we need to emit client options and constructors
             use.add('azure_core', 'Result');
             for (let i = 0; i < client.constructable.constructors.length; ++i) {
@@ -188,7 +189,7 @@ export function emitClients(crate) {
                 case 'lro':
                     isPublicApi = true;
                     methodBody = (indentation) => {
-                        return getLroMethodBody(indentation, use, client, method);
+                        return getLroMethodBody(crate, indentation, use, client, method);
                     };
                     break;
                 case 'clientaccessor':
@@ -657,14 +658,15 @@ function getMethodParamGroup(method) {
  * @param indent the indentation helper currently in scope
  * @param param the parameter to which the contents of setter apply
  * @param setter the callback that emits the code to read from a param var
- * @param inClosure indicates if the value is being read from within a closure (e.g. pageable methods)
+ * @param optionsPrefix Syntax to access the options structure, including the dot
  * @returns
  */
-function getParamValueHelper(indent, param, inClosure, setter) {
+function getParamValueHelper(indent, param, setter, optionsPrefix = 'options.') {
     if (param.optional && param.type.kind !== 'literal') {
+        const asRef = nonCopyableType(param.type) || isEnumString(param.type) ? '.as_ref()' : '';
         // optional params are in the unwrapped options local var
         const op = indent.get() + helpers.buildIfBlock(indent, {
-            condition: `let Some(${param.name}) = ${inClosure && nonCopyableType(param.type) ? '&' : ''}options.${param.name}`,
+            condition: `let Some(${param.name}) = ${param.location === 'client' ? 'self.' : optionsPrefix}${param.name}${asRef}`,
             body: setter,
         });
         return op + '\n';
@@ -777,7 +779,7 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
                     }
                 }
                 if (pathParam.optional) {
-                    body += `${indent.get()}${pathVarName} = ${helpers.buildMatch(indent, `options.${pathParam.name}`, [{
+                    body += `${indent.get()}${pathVarName} = ${helpers.buildMatch(indent, `options.${pathParam.name}${nonCopyableType(pathParam.type) ? '.as_ref()' : ''}`, [{
                             pattern: `Some(${pathParam.name})`,
                             body: (indent) => wrapSortedVec(`${indent.get()}${pathVarName}.replace("{${pathParam.segment}}", ${paramExpression})\n`),
                         }, {
@@ -793,8 +795,15 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
             body += `${indent.get()}${urlVarName}.append_path(${path});\n`;
         }
     }
+    let hasQueryBuilder = false;
+    const getQueryBuilder = function () {
+        hasQueryBuilder = true;
+        use.add('azure_core::http', 'UrlExt');
+        return `${indent.get()}let mut query_builder = ${urlVarName}.query_builder();\n`;
+    };
     if (pathChunks.length === 2) {
-        body += `${indent.get()}${urlVarName}.query_pairs_mut()`;
+        body += getQueryBuilder();
+        body += `${indent.get()}query_builder`;
         // set the query params that were in the path
         const qps = queryString.parse(pathChunks[1]);
         for (const qp of Object.keys(qps)) {
@@ -815,39 +824,47 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
         }
         body += ';\n';
     }
+    if (paramGroups.query.length > 0 && !hasQueryBuilder) {
+        body += getQueryBuilder();
+    }
     for (const queryParam of paramGroups.query) {
         if (queryParam.kind === 'queryCollection' && queryParam.format === 'multi') {
-            body += getParamValueHelper(indent, queryParam, false, () => {
+            body += getParamValueHelper(indent, queryParam, () => {
                 const valueVar = queryParam.name[0];
                 let text = `${indent.get()}for ${valueVar} in ${queryParam.name}.iter() {\n`;
-                text += `${indent.push().get()}${urlVarName}.query_pairs_mut().append_pair("${queryParam.key}", ${valueVar});\n`;
+                // if queryParam is a &[&str] then we'll need to deref the iterator
+                const deref = shared.asTypeOf(queryParam.type, 'str', 'ref', 'slice', 'ref') ? '*' : '';
+                text += `${indent.push().get()}query_builder.append_pair("${queryParam.key}", ${deref}${getHeaderPathQueryParamValue(use, queryParam, !queryParam.optional, false, valueVar)});\n`;
                 text += `${indent.pop().get()}}\n`;
                 return text;
             });
         }
         else if (queryParam.kind === 'queryHashMap') {
-            body += getParamValueHelper(indent, queryParam, false, () => {
+            body += getParamValueHelper(indent, queryParam, () => {
                 let text = `${indent.get()}{\n`;
                 text += `${indent.push().get()}let mut ${queryParam.name}_vec = ${queryParam.name}.iter().collect::<Vec<_>>();\n`;
                 text += `${indent.get()}${queryParam.name}_vec.sort_by_key(|p| p.0);\n`;
                 if (queryParam.explode) {
                     text += `${indent.get()}for (k, v) in ${queryParam.name}_vec.iter() {\n`;
-                    text += `${indent.push().get()}${urlVarName}.query_pairs_mut().append_pair(k, &v.to_string());\n`;
+                    text += `${indent.push().get()}query_builder.append_pair(*k, v.to_string());\n`;
                     text += `${indent.pop().get()}}\n`;
                 }
                 else {
-                    text += `${indent.get()}${urlVarName}.query_pairs_mut().append_pair("${queryParam.key}", ${queryParam.name}_vec.iter().map(|(k, v)| format!("{k},{v}")).collect::<Vec<String>>().join(",").as_str());\n`;
+                    text += `${indent.get()}query_builder.set_pair("${queryParam.key}", ${queryParam.name}_vec.iter().map(|(k, v)| format!("{k},{v}")).collect::<Vec<String>>().join(","));\n`;
                 }
                 text += `${indent.pop().get()}}\n`;
                 return text;
             });
         }
         else {
-            body += getParamValueHelper(indent, queryParam, false, () => {
-                return `${indent.get()}${urlVarName}.query_pairs_mut().append_pair("${queryParam.key}", ${getHeaderPathQueryParamValue(use, queryParam, !queryParam.optional, false)});\n`;
+            body += getParamValueHelper(indent, queryParam, () => {
+                return `${indent.get()}query_builder.set_pair("${queryParam.key}", ${getHeaderPathQueryParamValue(use, queryParam, !queryParam.optional, false)});\n`;
             });
         }
     }
+    if (hasQueryBuilder) {
+        body += `${indent.get()}query_builder.build();\n`;
+    }
     return body;
 }
 /**
@@ -858,9 +875,11 @@ function constructUrl(indent, use, method, paramGroups, urlVarName) {
  * @param method the method for which we're building the body
  * @param paramGroups the param groups for the provided method
  * @param inClosure indicates if the request is being constructed within a closure (e.g. pageable methods)
+ * @param requestVarName name for the request variable
+ * @param optionsPrefix Syntax to access the options structure, including the dot
  * @returns the code which sets HTTP headers for the request
  */
-function applyHeaderParams(indent, use, method, paramGroups, inClosure, requestVarName) {
+function applyHeaderParams(indent, use, method, paramGroups, inClosure, requestVarName, optionsPrefix = 'options.') {
     var _a, _b, _c;
     let body = '';
     for (const headerParam of paramGroups.header) {
@@ -875,7 +894,7 @@ function applyHeaderParams(indent, use, method, paramGroups, inClosure, requestV
                 },
                 {
                     pattern: 'PagerState::Initial',
-                    body: (indent) => `${indent.get()}&options.${headerParam.name}\n`,
+                    body: (indent) => `${indent.get()}&${optionsPrefix}${headerParam.name}\n`,
                 }
             ]) + ';\n';
             body += indent.get() + helpers.buildIfBlock(indent, {
@@ -890,15 +909,15 @@ function applyHeaderParams(indent, use, method, paramGroups, inClosure, requestV
             // this logic happens elsewhere so we skip it here.
             continue;
         }
-        body += getParamValueHelper(indent, headerParam, inClosure, () => {
+        body += getParamValueHelper(indent, headerParam, () => {
             if (headerParam.kind === 'headerHashMap') {
-                let setter = `for (k, v) in ${headerParam.type.kind === 'ref' ? '' : '&'}${headerParam.name} {\n`;
+                let setter = `for (k, v) in ${headerParam.name} {\n`;
                 setter += `${indent.push().get()}${requestVarName}.insert_header(format!("${headerParam.header}-{k}"), v);\n`;
                 setter += `${indent.pop().get()}}\n`;
                 return setter;
             }
             return `${indent.get()}${requestVarName}.insert_header("${headerParam.header.toLowerCase()}", ${getHeaderPathQueryParamValue(use, headerParam, !inClosure, false)});\n`;
-        });
+        }, optionsPrefix);
     }
     return body;
 }
@@ -936,7 +955,7 @@ function constructRequest(indent, use, method, paramGroups, inClosure, urlVarNam
     }
     const bodyParam = paramGroups.body;
     if (bodyParam) {
-        body += getParamValueHelper(indent, bodyParam, inClosure, () => {
+        body += getParamValueHelper(indent, bodyParam, () => {
             let bodyParamContent = '';
             if (optionalContentTypeParam) {
                 bodyParamContent = `${indent.get()}${requestVarName}.insert_header("${optionalContentTypeParam.header.toLowerCase()}", ${getHeaderPathQueryParamValue(use, optionalContentTypeParam, !inClosure, false)});\n`;
@@ -1117,21 +1136,14 @@ function getPageableMethodBody(indent, use, client, method) {
                     // if the url already contains the token query param,
                     // e.g. we started on some page, then we need to remove
                     // it before appending the token for the next page.
+                    use.add('azure_core::http', 'UrlExt');
                     const reqTokenValue = method.strategy.requestToken.key;
                     body += `${indent.get()}${helpers.buildIfBlock(indent, {
                         condition: `let PagerState::More(${reqTokenParam}) = ${reqTokenParam}`,
                         body: (indent) => {
-                            let body = indent.get() + helpers.buildIfBlock(indent, {
-                                condition: `url.query_pairs().any(|(name, _)| name.eq("${reqTokenValue}"))`,
-                                body: (indent) => {
-                                    let body = `${indent.get()}let mut new_url = url.clone();\n`;
-                                    body += `${indent.get()}new_url.query_pairs_mut().clear().extend_pairs(url.query_pairs().filter(|(name, _)| name.ne("${reqTokenValue}")));\n`;
-                                    body += `${indent.get()}url = new_url;\n`;
-                                    return body;
-                                },
-                            }) + '\n';
-                            body += `${indent.get()}url.query_pairs_mut().append_pair("${reqTokenValue}", &${reqTokenParam});\n`;
-                            return body;
+                            return `${indent.get()}let mut query_builder = url.query_builder();\n`
+                                + `${indent.get()}query_builder.set_pair("${reqTokenValue}", &${reqTokenParam});\n`
+                                + `${indent.get()}query_builder.build();\n`;
                         }
                     })}\n`;
                 }
@@ -1147,26 +1159,32 @@ function getPageableMethodBody(indent, use, client, method) {
                         body: (indent) => {
                             const cloneNextLink = `${indent.get()}let mut ${nextLinkName} = ${nextLinkName}.clone();\n`;
                             let content = '';
+                            let hasQueryBuilder = false;
                             if (paramGroups.apiVersion && paramGroups.apiVersion.kind === 'queryScalar') {
-                                const apiVersionKey = `"${paramGroups.apiVersion.key}"`;
-                                // there are no APIs to set/update an existing query parameter.
-                                // so, we filter the existing query params to remove the api-version
-                                // query param. we then add back the filtered set and then add the
-                                // api-version as specified on the client.
-                                content = `${indent.get()}let qp = ${nextLinkName}.query_pairs().filter(|(name, _)| name.ne(${apiVersionKey}));\n`;
                                 content += cloneNextLink;
-                                content += `${indent.get()}${nextLinkName}.query_pairs_mut().clear().extend_pairs(qp).append_pair(${apiVersionKey}, &${paramGroups.apiVersion.name});\n`;
+                                hasQueryBuilder = true;
+                                use.add('azure_core::http', 'UrlExt');
+                                content += `${indent.get()}let mut query_builder = ${nextLinkName}.query_builder();\n`;
+                                content += `${indent.get()}query_builder.set_pair("${paramGroups.apiVersion.key}", &${paramGroups.apiVersion.name});\n`;
                             }
                             else if (reinjectedParams.length > 0) {
                                 // if we didn't clone it above, we'll need to clone it for this case
                                 content += cloneNextLink;
                             }
                             // add query params for reinjection
+                            if (reinjectedParams.length > 0 && !hasQueryBuilder) {
+                                hasQueryBuilder = true;
+                                use.add('azure_core::http', 'UrlExt');
+                                content += `${indent.get()}let mut query_builder = ${nextLinkName}.query_builder();\n`;
+                            }
                             for (const reinjectedParam of reinjectedParams) {
-                                content += getParamValueHelper(indent, reinjectedParam, true, () => {
-                                    return `${indent.get()}${nextLinkName}.query_pairs_mut().append_pair("${reinjectedParam.key}", ${getHeaderPathQueryParamValue(use, reinjectedParam, false, false)});\n`;
+                                content += getParamValueHelper(indent, reinjectedParam, () => {
+                                    return `${indent.get()}query_builder.set_pair("${reinjectedParam.key}", ${getHeaderPathQueryParamValue(use, reinjectedParam, false, false)});\n`;
                                 });
                             }
+                            if (hasQueryBuilder) {
+                                content += `${indent.get()}query_builder.build();\n`;
+                            }
                             content += `${indent.get()}${nextLinkName}\n`;
                             return content;
                         }
@@ -1284,18 +1302,22 @@ function getPageableMethodBody(indent, use, client, method) {
 /**
  * constructs the body for an LRO client method
  *
+ * @param crate the crate to which method belongs
  * @param indent the indentation helper currently in scope
  * @param use the use statement builder currently in scope
  * @param client the client to which the method belongs
  * @param method the method for the body to build
  * @returns the contents of the method body
  */
-function getLroMethodBody(indent, use, client, method) {
-    var _a, _b;
-    const pollingStepHeaderName = ((_a = method.responseHeaders) === null || _a === void 0 ? void 0 : _a.headers.some(h => h.header.toLowerCase() === 'operation-location'))
-        ? 'operation-location'
-        : ((_b = method.responseHeaders) === null || _b === void 0 ? void 0 : _b.headers.some(h => h.header.toLowerCase() === 'azure-asyncoperation'))
-            ? 'azure-asyncoperation' : undefined;
+function getLroMethodBody(crate, indent, use, client, method) {
+    var _a;
+    let pollingStepHeaderName = undefined;
+    for (const header of ['operation-location', 'azure-asyncoperation', 'location']) {
+        if ((_a = method.responseHeaders) === null || _a === void 0 ? void 0 : _a.headers.some(h => h.header.toLowerCase() === header)) {
+            pollingStepHeaderName = header;
+            break;
+        }
+    }
     const bodyFormat = helpers.convertResponseFormat(method.returns.type.type.format);
     use.add('azure_core::http', 'Method', 'RawResponse', 'Request', 'Url');
     use.add('azure_core::http::headers', 'RETRY_AFTER', 'X_MS_RETRY_AFTER_MS', 'RETRY_AFTER_MS');
@@ -1319,39 +1341,46 @@ function getLroMethodBody(indent, use, client, method) {
     const applyApiVersionParam = function (indent, paramGroups, newLinkVarName, existingLinkVarAccessor) {
         var _a;
         if (((_a = paramGroups.apiVersion) === null || _a === void 0 ? void 0 : _a.kind) === 'queryScalar') {
-            return `${indent.get()}let qp = ${existingLinkVarAccessor}.query_pairs().filter(|(name, _)| name.ne("${paramGroups.apiVersion.key}"));\n`
-                + `${indent.get()}let mut ${newLinkVarName} = ${existingLinkVarAccessor}.clone();\n`
-                + `${indent.get()}${newLinkVarName}.query_pairs_mut().clear().extend_pairs(qp).append_pair("${paramGroups.apiVersion.key}", &${paramGroups.apiVersion.name});\n`;
+            use.add('azure_core::http', 'UrlExt');
+            return `${indent.get()}let mut ${newLinkVarName} = ${existingLinkVarAccessor}.clone();\n`
+                + `${indent.get()}let mut query_builder = ${newLinkVarName}.query_builder();\n`
+                + `${indent.get()}query_builder.set_pair("${paramGroups.apiVersion.key}", &${paramGroups.apiVersion.name});\n`
+                + `${indent.get()}query_builder.build();\n`;
         }
         return '';
     };
-    const declareRequest = function (indent, use, method, paramGroups, requestVarName, linkVarName, forceMut) {
+    const declareRequest = function (indent, use, method, paramGroups, requestVarName, linkExpr, forceMut, optionsPrefix) {
         let mutRequest = '';
         // if the only header is optional Content-Type it will not be used
         // by applyHeaderParams() in this case so don't make request mutable
         if (forceMut || paramGroups.header.length > 1 || (paramGroups.header.length === 1 && !isOptionalContentTypeHeader(paramGroups.header[0]))) {
             mutRequest = 'mut ';
         }
-        return `${indent.get()}let ${mutRequest}${requestVarName} = Request::new(${linkVarName}.clone(), Method::Get);\n`
-            + applyHeaderParams(indent, use, method, paramGroups, true, requestVarName);
+        return `${indent.get()}let ${mutRequest}${requestVarName} = Request::new(${linkExpr}, Method::Get);\n`
+            + applyHeaderParams(indent, use, method, paramGroups, true, requestVarName, optionsPrefix);
     };
     let stateVarName = 'next_link';
     let stateVarType = 'Url';
     let progressVarName = 'next_link';
     let stateNextLinkAccessor = 'next_link';
     let pollerStateMoreReturn = 'next_link';
-    let pollerStateInitialReturn = 'url.clone()';
+    let pollerStateInitialReturn = `${urlVar}.clone()`;
     let pollerStatusInProgressReturn = 'next_link';
-    if (method.finalResultStrategy.kind === 'originalUri') {
-        body += `${indent.get()}struct Progress{ next_link: Url, first_rsp: Option<RawResponse>, }`;
+    if (method.finalResultStrategy.kind === 'header' && method.finalResultStrategy.headerName !== pollingStepHeaderName) {
+        // A case when the initial response contains two headers - one (usually, 'azure-asyncoperation') to poll operation status
+        // and another (usually, 'location') to collect the final result. Both values are URLs.
+        // But only the initial response will have these headers, i.e. responses from 'azure-asyncoperation' URL won't have the 'location'.
+        // Therefore, we need to preserve both URLs and pass them between poller states, up to the moment when the operation status
+        // is Succeeded, so that when operation is Succeeded, the poller can send a request to 'location' to collect the result.
+        body += `${indent.get()}struct Progress{ next_link: Url, final_link: Url, }`;
         body += `${indent.get()}impl AsRef<str> for Progress{ fn as_ref(&self) -> &str{ self.next_link.as_ref() }}\n`;
         stateVarName = 'state';
         stateVarType = 'Progress';
         progressVarName = 'progress';
         stateNextLinkAccessor = 'progress.next_link';
-        pollerStateMoreReturn = 'Progress{next_link, first_rsp: progress.first_rsp}';
-        pollerStateInitialReturn = 'Progress{next_link: url.clone(), first_rsp: None}';
-        pollerStatusInProgressReturn = 'Progress{next_link, first_rsp}';
+        pollerStateMoreReturn = 'Progress{next_link, final_link: progress.final_link}';
+        pollerStateInitialReturn = `Progress{next_link: ${urlVar}.clone(), final_link: ${urlVar}.clone()}`;
+        pollerStatusInProgressReturn = 'Progress{next_link, final_link}';
     }
     body += `${indent.get()}Ok(${method.returns.type.name}::from_callback(\n`;
     body += `${indent.push().get()}move |${stateVarName}: PollerState<${stateVarType}>, poller_options| {\n`;
@@ -1359,7 +1388,7 @@ function getLroMethodBody(indent, use, client, method) {
             pattern: `PollerState::More(${progressVarName})`,
             body: (indent) => {
                 return applyApiVersionParam(indent, paramGroups, 'next_link', stateNextLinkAccessor)
-                    + declareRequest(indent, use, method, paramGroups, initialRequestResult.requestVarName, 'next_link')
+                    + declareRequest(indent, use, method, paramGroups, initialRequestResult.requestVarName, 'next_link.clone()')
                     + `${indent.get()}(${initialRequestResult.requestVarName}, ${pollerStateMoreReturn})\n`;
             },
         }, {
@@ -1372,12 +1401,72 @@ function getLroMethodBody(indent, use, client, method) {
         }])};\n`;
     body += `${indent.get()}let ctx = poller_options.context.clone();\n`;
     body += `${indent.get()}let pipeline = pipeline.clone();\n`;
+    if (method.finalResultStrategy.kind === 'originalUri') {
+        body += `${indent.get()}let final_link = url.clone();\n`;
+        for (const headerParam of paramGroups.header.filter(h => h.type.kind !== 'literal' && !isOptionalContentTypeHeader(h))) {
+            if (headerParam.type.kind !== 'enum') {
+                const optionsPrefix = headerParam.optional ? 'options.' : '';
+                body += `${indent.get()}let ${headerParam.name} = ${optionsPrefix}${headerParam.name}.clone();\n`;
+            }
+        }
+    }
+    // Match an ARM PUT operation ("create or update"), which may have immediate 200 OK response with no headers and no poller status
+    const isArmPutLro = bodyFormat === 'json'
+        && method.httpMethod === 'put'
+        && method.returns.type.resultType !== undefined
+        && method.finalResultStrategy.kind === 'header'
+        && method.finalResultStrategy.headerName === 'azure-asyncoperation'
+        && pollingStepHeaderName === 'azure-asyncoperation'
+        && method.statusCodes.some(sc => sc == 200)
+        && method.statusCodes.some(sc => sc == 201);
+    // Match an ARM PATCH operation ("update"), which may have immediate 200 OK response with no headers and no poller status
+    const isArmPatchLro = bodyFormat === 'json'
+        && method.httpMethod === 'patch'
+        && method.returns.type.resultType !== undefined
+        && method.finalResultStrategy.kind === 'header'
+        && method.finalResultStrategy.headerName === 'location'
+        && pollingStepHeaderName === 'location'
+        && method.statusCodes.some(sc => sc == 200)
+        && method.statusCodes.some(sc => sc == 202);
+    // Match an ARM POST operation ("export"), which may have empty initial response
+    const isArmPostLro = bodyFormat === 'json'
+        && method.httpMethod === 'post'
+        && method.returns.type.resultType !== undefined
+        && method.finalResultStrategy.kind === 'header'
+        && method.finalResultStrategy.headerName === 'location'
+        && pollingStepHeaderName === 'azure-asyncoperation'
+        && method.statusCodes.some(sc => sc == 200)
+        && method.statusCodes.some(sc => sc == 202);
+    // Match an ARM DELETE operation, which may have empty responses and only communicate via status codes
+    const isArmDeleteLro = bodyFormat === 'json'
+        && method.httpMethod === 'delete'
+        && method.returns.type.resultType === undefined
+        && method.finalResultStrategy.kind === 'header'
+        && method.finalResultStrategy.headerName === 'location'
+        && pollingStepHeaderName === 'location'
+        && method.statusCodes.some(sc => sc == 200)
+        && method.statusCodes.some(sc => sc == 202)
+        && method.statusCodes.some(sc => sc == 204);
+    if (isArmPutLro || isArmPatchLro) {
+        body += 'let original_url = url.clone();\n';
+    }
     body += `${indent.get()}async move {\n`;
     body += `${indent.push().get()}let rsp = pipeline.send(&ctx, &mut ${initialRequestResult.requestVarName}, ${getPipelineOptions(indent, use, method)}).await?;\n`;
-    body += `${indent.get()}let (status, headers, body) = rsp.deconstruct();\n`;
+    const needsMutBody = isArmPutLro || isArmPatchLro || isArmPostLro || isArmDeleteLro;
+    body += `${indent.get()}let (status, headers, ${needsMutBody ? 'mut' : ''} body) = rsp.deconstruct();\n`;
+    if (isArmPostLro || isArmDeleteLro) {
+        body += `${indent.get()}if body.is_empty() {\n`;
+        let emptyBodyExpr = '"{}"';
+        if (isArmDeleteLro) {
+            use.add('azure_core::http', 'StatusCode');
+            emptyBodyExpr = `if status == StatusCode::NoContent { "{\\"status\\":\\"Succeeded\\"}" } else { "{}" }`;
+        }
+        body += `${indent.push().get()}body = azure_core::http::response::ResponseBody::from_bytes(${emptyBodyExpr});\n`;
+        body += `${indent.pop().get()}}\n`;
+    }
     if (pollingStepHeaderName !== undefined) {
         body += `${indent.get()}let next_link = ${helpers.buildMatch(indent, `headers.get_optional_string(&HeaderName::from_static("${pollingStepHeaderName}"))`, [{
-                pattern: `Some(operation_location)`,
+                pattern: 'Some(operation_location)',
                 body: (indent) => {
                     return `${indent.get()}Url::parse(&operation_location)?\n`;
                 }
@@ -1388,32 +1477,48 @@ function getLroMethodBody(indent, use, client, method) {
                 }
             }])};\n`;
     }
-    let resultRspVarName = 'first_rsp';
-    if (method.finalResultStrategy.kind === 'header' && method.finalResultStrategy.headerName !== pollingStepHeaderName) { // separate link for picking up the result
-        body += `${indent.get()}let final_link = Url::parse(headers.get_str(&HeaderName::from_static("${method.finalResultStrategy.headerName}"))?)?;\n`;
+    if (isArmPutLro || isArmPatchLro) {
+        use.add('azure_core::http', 'StatusCode');
+        body += `${indent.get()}let mut final_body = None;\n`;
+        body += `${indent.get()}if status == StatusCode::Ok && next_link.as_str() == original_url.as_str() {\n`;
+        body += `${indent.push().get()}final_body = Some(body);\n`;
+        body += `${indent.get()}body = azure_core::http::response::ResponseBody::from_bytes("{\\"status\\":\\"Succeeded\\"}");\n`;
+        body += `${indent.pop().get()}}\n`;
     }
-    else if (method.finalResultStrategy.kind === 'originalUri') { // result available via original request immediately
-        resultRspVarName = 'first_rsp';
-        body += `${indent.get()}let mut ${resultRspVarName} = progress.first_rsp;\n`;
-        body += `${indent.get()}if first_rsp.is_none() { ${resultRspVarName} = Some(RawResponse::from_bytes(status, headers.clone(), body.clone())); }\n`;
+    if (method.finalResultStrategy.kind === 'header' && method.finalResultStrategy.headerName !== pollingStepHeaderName) { // separate link for picking up the result
+        body += `${indent.get()}let final_link = ${helpers.buildMatch(indent, `headers.get_optional_string(&HeaderName::from_static("${method.finalResultStrategy.headerName}"))`, [{
+                pattern: 'Some(final_link)',
+                body: (indent) => {
+                    return `${indent.get()}Url::parse(&final_link)?\n`;
+                }
+            }, {
+                pattern: 'None',
+                body: (indent) => {
+                    return `${indent.get()}progress.final_link`;
+                }
+            }])};\n`;
     }
     body += `${indent.get()}let retry_after = get_retry_after(&headers, &[X_MS_RETRY_AFTER_MS, RETRY_AFTER_MS, RETRY_AFTER], &poller_options);\n`;
     const deserialize = `${bodyFormat}::from_${bodyFormat}`;
     use.add('azure_core', bodyFormat);
-    body += `${indent.get()}let res: ${helpers.getTypeDeclaration(helpers.unwrapType(method.returns.type))} = ${deserialize}(&body)?;\n`;
-    if (method.finalResultStrategy.kind === 'header' && method.finalResultStrategy.headerName === pollingStepHeaderName) { // result available at the poll step link when finished
-        resultRspVarName = 'final_rsp';
-        body += `${indent.get()}let mut ${resultRspVarName} = None;\n`;
-        body += `${indent.get()}if res.status() == PollerStatus::Succeeded {\n`;
-        indent.push();
+    body += `${indent.push().get()}let res: ${helpers.getTypeDeclaration(helpers.unwrapType(method.returns.type))} = ${deserialize}(&body)?;\n`;
+    if (method.finalResultStrategy.kind === 'header' && method.finalResultStrategy.headerName === pollingStepHeaderName) {
+        body += `${indent.get()}let mut final_rsp: Option<RawResponse> = None;\n`;
+        body += `if res.status() == PollerStatus::Succeeded {\n`;
         let responseBodyExpr = 'body.clone()';
-        if (method.finalResultStrategy.propertyName !== undefined) {
+        if (isArmPutLro || isArmPatchLro) {
+            responseBodyExpr = 'if let Some(final_body) = final_body { final_body } else { body.clone() }';
+        }
+        else if (method.finalResultStrategy.propertyName !== undefined) {
             responseBodyExpr = 'body';
-            body += `${indent.get()}let ${responseBodyExpr} = azure_core::http::response::ResponseBody::from_bytes(`
-                + `serde_json::from_str::<azure_core::Value>(body.clone().into_string()?.as_str())?["${method.finalResultStrategy.propertyName}"].to_string());\n`;
+            if (bodyFormat === 'json') {
+                crate.addDependency(new rust.CrateDependency('serde_json'));
+                body += `${indent.get()}let body = azure_core::http::response::ResponseBody::from_bytes(`
+                    + `serde_json::from_str::<azure_core::Value>(body.clone().into_string()?.as_str())?["${method.finalResultStrategy.propertyName}"].to_string());\n`;
+            }
         }
-        body += `${indent.get()}${resultRspVarName} = Some(RawResponse::from_bytes(status, headers.clone(), ${responseBodyExpr}));\n`;
-        body += `${indent.pop().get()}}\n`;
+        body += `${indent.get()}final_rsp = Some(RawResponse::from_bytes(status, headers.clone(), ${responseBodyExpr}));\n`;
+        body += `}\n`;
     }
     body += `${indent.get()}let rsp = RawResponse::from_bytes(status, headers, body).into();\n`;
     const arms = [{
@@ -1426,19 +1531,24 @@ function getLroMethodBody(indent, use, client, method) {
     arms.push({
         pattern: `PollerStatus::Succeeded`,
         body: (indent) => {
-            return `{\n`
+            let body = `{\n`
                 + `${indent.push().get()}PollerResult::Succeeded {\n`
                 + `${indent.push().get()}response: rsp,\n`
                 + `${indent.get()}target: Box::new(move || {\n`
-                + `${indent.push().get()}Box::pin(async move {\n`
-                + ((method.finalResultStrategy.kind === 'header' && method.finalResultStrategy.headerName !== pollingStepHeaderName)
-                    ? (declareRequest(indent, use, method, paramGroups, initialRequestResult.requestVarName, 'final_link', true)
-                        + `Ok(pipeline.send(&ctx, &mut ${initialRequestResult.requestVarName}, None).await?.into())\n`)
-                    : `Ok(${resultRspVarName}.unwrap().into())\n`)
-                + `${indent.pop().get()}})\n`
+                + `${indent.push().get()}Box::pin(async move {\n`;
+            if (method.finalResultStrategy.kind === 'header' && method.finalResultStrategy.headerName === pollingStepHeaderName) {
+                use.add('azure_core::error', 'Error', 'ErrorKind');
+                body += `Ok(final_rsp.ok_or_else(|| { Error::new(ErrorKind::Other, "missing final response")})?.into())\n`;
+            }
+            else {
+                body += declareRequest(indent, use, method, paramGroups, initialRequestResult.requestVarName, 'final_link', true, '')
+                    + `Ok(pipeline.send(&ctx, &mut ${initialRequestResult.requestVarName}, None).await?.into())\n`;
+            }
+            body += `${indent.pop().get()}})\n`
                 + `${indent.get()}}),\n`
                 + `${indent.pop().get()}}`
                 + `${indent.pop().get()}}`;
+            return body;
         }
     });
     arms.push({
@@ -1494,9 +1604,10 @@ function getClientSupplementalEndpointParamValue(param) {
  * @param param the param for which to get the value
  * @param fromSelf applicable for client params. when true, the prefix "self." is included
  * @param neverBorrow indicates that the borrowing calculation should be skipped
+ * @param overrideParamName optional value to use as the parameter name instead of param.name
  * @returns the code to use for the param's value
  */
-function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow) {
+function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow, overrideParamName) {
     let paramName = param.name;
     // when fromSelf is false we assume that there's a local with the same name.
     // e.g. in pageable methods where we need to clone the params so they can be
@@ -1504,6 +1615,9 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow) {
     if (param.location === 'client' && fromSelf) {
         paramName = 'self.' + paramName;
     }
+    else if (overrideParamName) {
+        paramName = overrideParamName;
+    }
     const encodeBytes = function (type, param) {
         const encoding = helpers.getBytesEncodingMethod(type.encoding, 'encode', use);
         if (param) {
@@ -1531,13 +1645,11 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow) {
     let paramValue;
     // contains the result from calculating if the
     // param requires borrowing.
-    let mustBorrow = true;
+    let mustBorrow = !helpers.isQueryParameter(param);
     const paramType = helpers.unwrapType(param.type);
-    if (param.kind === 'headerCollection' || param.kind === 'queryCollection') {
-        if (param.format === 'multi') {
-            throw new CodegenError('InternalError', 'multi should have been handled outside getHeaderPathQueryParamValue');
-        }
-        else if (paramType.kind === 'String' || paramType.kind === 'str') {
+    // we want multi to hit the else case so the necessary conversions etc can happen
+    if ((param.kind === 'headerCollection' || param.kind === 'queryCollection') && param.format !== 'multi') {
+        if (paramType.kind === 'String' || paramType.kind === 'str') {
             paramValue = `${paramName}.join("${getCollectionDelimiter(param.format)}")`;
         }
         else {
@@ -1560,8 +1672,8 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow) {
         switch (paramType.kind) {
             case 'String':
                 paramValue = paramName;
-                // if the param is on the client, or it's optional, then we must borrow
-                mustBorrow = (param.location === 'client' && fromSelf) || param.optional;
+                // if the param is on the client, then we must borrow
+                mustBorrow = param.location === 'client' && fromSelf;
                 break;
             case 'str':
                 paramValue = paramName;
@@ -1576,7 +1688,7 @@ function getHeaderPathQueryParamValue(use, param, fromSelf, neverBorrow) {
                 break;
             case 'enum':
             case 'scalar':
-                if (paramType.kind === 'enum' && (param.kind === 'pathScalar' || param.kind === 'queryScalar') && paramType.type === 'String') {
+                if (isEnumString(paramType) && (helpers.isPathParameter(param) || helpers.isQueryParameter(param))) {
                     // append_pair and path.replace() want a reference to the string
                     paramValue = `${paramName}.as_ref()`;
                     // as_ref() elides the need to borrow
@@ -1676,4 +1788,9 @@ function getPipelineOptions(indent, use, method) {
         return 'None';
     }
 }
+/** narrows type to an Enum type IFF its underlying type is String within the conditional block */
+function isEnumString(type) {
+    const unwrapped = helpers.unwrapType(type);
+    return unwrapped.kind === 'enum' && unwrapped.type === 'String';
+}
 //# sourceMappingURL=clients.js.map