@azure-tools/typespec-go 0.4.12 → 0.5.1

package/dist/codegen.go/src/operations.js

@@ -73,7 +73,7 @@ export async function generateOperations(codeModel) {
         const optionalParams = new Array();
         const isParamPointer = function (param) {
             // for client params, only optional and flag types are passed by pointer
-            return param.kind === 'flag' || param.kind === 'optional';
+            return param.style === 'flag' || param.style === 'optional';
         };
         // now emit any client params (non parameterized host params case)
         if (client.parameters.length > 0) {
@@ -131,11 +131,11 @@ export async function generateOperations(codeModel) {
             }
             opText += generateOperation(client, method, imports, codeModel.options.injectSpans, codeModel.options.generateFakes);
             opText += createProtocolRequest(azureARM, client, method, imports);
-            if (!go.isLROMethod(method) || go.isPageableMethod(method)) {
+            if (method.kind !== 'lroMethod') {
                 // LRO responses are handled elsewhere, with the exception of pageable LROs
                 opText += createProtocolResponse(client, method, imports);
             }
-            if (go.isPageableMethod(method) && method.nextPageMethod && !nextPageMethods.includes(method.nextPageMethod)) {
+            if ((method.kind === 'lroPageableMethod' || method.kind === 'pageableMethod') && method.nextPageMethod && !nextPageMethods.includes(method.nextPageMethod)) {
                 // track the next page methods to generate as multiple operations can use the same next page operation
                 nextPageMethods.push(method.nextPageMethod);
             }
@@ -214,10 +214,10 @@ function createARMClientConstructor(client, imports) {
 // use this to generate the code that will help process values returned in response headers
 function formatHeaderResponseValue(headerResp, imports, respObj, zeroResp) {
     // dictionaries are handled slightly different so we do that first
-    if (go.isHeaderMapResponse(headerResp)) {
+    if (headerResp.kind === 'headerMapResponse') {
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
         imports.add('strings');
-        const headerPrefix = headerResp.collectionPrefix;
+        const headerPrefix = headerResp.headerName;
         let text = '\tfor hh := range resp.Header {\n';
         text += `\t\tif len(hh) > len("${headerPrefix}") && strings.EqualFold(hh[:len("${headerPrefix}")], "${headerPrefix}") {\n`;
         text += `\t\t\tif ${respObj}.${headerResp.fieldName} == nil {\n`;
@@ -345,7 +345,7 @@ function emitPagerDefinition(client, method, imports, injectSpans, generateFakes
     }
     if (method.nextLinkName) {
         let nextLinkVar;
-        if (!go.isLROMethod(method)) {
+        if (method.kind === 'pageableMethod') {
             text += '\t\t\tnextLink := ""\n';
             nextLinkVar = 'nextLink';
             text += '\t\t\tif page != nil {\n';
@@ -410,7 +410,7 @@ function genApiVersionDoc(apiVersions) {
     return `//\n// Generated from API version ${apiVersions.join(', ')}\n`;
 }
 function genRespErrorDoc(method) {
-    if (!(method.responseEnvelope.result && go.isHeadAsBooleanResult(method.responseEnvelope.result)) && !go.isPageableMethod(method)) {
+    if (!(method.responseEnvelope.result?.kind === 'headAsBooleanResult') && !go.isPageableMethod(method)) {
         // when head-as-boolean is enabled, no error is returned for 4xx status codes.
         // pager constructors don't return an error
         return '// If the operation fails it returns an *azcore.ResponseError type.\n';
@@ -421,7 +421,7 @@ function generateOperation(client, method, imports, injectSpans, generateFakes)
     const params = getAPIParametersSig(method, imports);
     const returns = generateReturnsInfo(method, 'op');
     let methodName = method.name;
-    if (go.isPageableMethod(method) && !go.isLROMethod(method)) {
+    if (method.kind === 'pageableMethod') {
         methodName = fixUpMethodName(method);
     }
     let text = '';
@@ -448,7 +448,7 @@ function generateOperation(client, method, imports, injectSpans, generateFakes)
     }
     text += `func (client *${client.name}) ${methodName}(${params}) (${returns.join(', ')}) {\n`;
     const reqParams = helpers.getCreateRequestParameters(method);
-    if (go.isPageableMethod(method) && !go.isLROMethod(method)) {
+    if (method.kind === 'pageableMethod') {
         text += '\treturn ';
         text += emitPagerDefinition(client, method, imports, injectSpans, generateFakes);
         text += '}\n\n';
@@ -481,7 +481,7 @@ function generateOperation(client, method, imports, injectSpans, generateFakes)
     text += `\t\treturn ${zeroResp}, err\n`;
     text += '\t}\n';
     // HAB with headers response is handled in protocol responder
-    if (method.responseEnvelope.result && go.isHeadAsBooleanResult(method.responseEnvelope.result) && method.responseEnvelope.headers.length === 0) {
+    if (method.responseEnvelope.result?.kind === 'headAsBooleanResult' && method.responseEnvelope.headers.length === 0) {
         text += `\treturn ${method.responseEnvelope.name}{${method.responseEnvelope.result.fieldName}: httpResp.StatusCode >= 200 && httpResp.StatusCode < 300}, nil\n`;
     }
     else {
@@ -493,7 +493,7 @@ function generateOperation(client, method, imports, injectSpans, generateFakes)
             text += `\tresp, err := client.${method.naming.responseMethod}(httpResp)\n`;
             text += '\treturn resp, err\n';
         }
-        else if (method.responseEnvelope.result && go.isBinaryResult(method.responseEnvelope.result)) {
+        else if (method.responseEnvelope.result?.kind === 'binaryResult') {
             text += `\treturn ${method.responseEnvelope.name}{${method.responseEnvelope.result.fieldName}: httpResp.Body}, nil\n`;
         }
         else {
@@ -505,7 +505,7 @@ function generateOperation(client, method, imports, injectSpans, generateFakes)
 }
 function createProtocolRequest(azureARM, client, method, imports) {
     let name = method.name;
-    if (go.isMethod(method)) {
+    if (method.kind !== 'nextPageMethod') {
         name = method.naming.requestMethod;
     }
     for (const param of values(method.parameters)) {
@@ -519,7 +519,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
     text += `func (client *${client.name}) ${name}(${helpers.getCreateRequestParametersSig(method)}) (${returns.join(', ')}) {\n`;
     const hostParams = new Array();
     for (const parameter of client.parameters) {
-        if (go.isURIParameter(parameter)) {
+        if (parameter.kind === 'uriParam') {
             hostParams.push(parameter);
         }
     }
@@ -537,7 +537,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         }
         // check for any method local host params
         for (const param of values(method.parameters)) {
-            if (param.location === 'method' && go.isURIParameter(param)) {
+            if (param.location === 'method' && param.kind === 'uriParam') {
                 text += `\thost = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(helpers.getParamName(param), param.type, imports)})\n`;
             }
         }
@@ -554,7 +554,8 @@ function createProtocolRequest(azureARM, client, method, imports) {
     else {
         throw new CodegenError('InternalError', `no host or endpoint defined for method ${client.name}.${method.name}`);
     }
-    const hasPathParams = values(method.parameters).where((each) => { return go.isPathParameter(each); }).any();
+    const methodParamGroups = helpers.getMethodParamGroups(method);
+    const hasPathParams = methodParamGroups.pathParams.length > 0;
     // storage needs the client.u to be the source-of-truth for the full path.
     // however, swagger requires that all operations specify a path, which is at odds with storage.
     // to work around this, storage specifies x-ms-path paths with path params but doesn't
@@ -571,10 +572,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         // swagger defines path params, emit path and replace tokens
         imports.add('strings');
         // replace path parameters
-        for (const pp of values(method.parameters)) {
-            if (!go.isPathParameter(pp)) {
-                continue;
-            }
+        for (const pp of methodParamGroups.pathParams) {
             // emit check to ensure path param isn't an empty string.  we only need
             // to do this for params that have an underlying type of string.
             const choiceIsString = function (type) {
@@ -583,7 +581,8 @@ function createProtocolRequest(azureARM, client, method, imports) {
                 }
                 return type.type === 'string';
             };
-            if (((go.isPrimitiveType(pp.type) && pp.type.typeName === 'string') || choiceIsString(pp.type)) && pp.isEncoded) {
+            // TODO: https://github.com/Azure/autorest.go/issues/1593
+            if (pp.kind === 'pathScalarParam' && ((go.isPrimitiveType(pp.type) && pp.type.typeName === 'string' || choiceIsString(pp.type)) && pp.isEncoded)) {
                 const paramName = helpers.getParamName(pp);
                 imports.add('errors');
                 text += `\tif ${paramName} == "" {\n`;
@@ -619,25 +618,14 @@ function createProtocolRequest(azureARM, client, method, imports) {
         return `\tif ${optionalParamGroupCheck}${client}${paramGroupName}.${capitalize(param.name)} != nil {\n`;
     };
     // add query parameters
-    const encodedParams = new Array();
-    const unencodedParams = new Array();
-    for (const qp of values(method.parameters)) {
-        if (!go.isQueryParameter(qp)) {
-            continue;
-        }
-        if (qp.isEncoded) {
-            encodedParams.push(qp);
-        }
-        else {
-            unencodedParams.push(qp);
-        }
-    }
+    const encodedParams = methodParamGroups.encodedQueryParams;
+    const unencodedParams = methodParamGroups.unencodedQueryParams;
     const emitQueryParam = function (qp, setter) {
         let qpText = '';
-        if (qp.location === 'method' && go.isClientSideDefault(qp.kind)) {
-            qpText = emitClientSideDefault(qp, qp.kind, (name, val) => { return `\treqQP.Set(${name}, ${val})`; }, imports);
+        if (qp.location === 'method' && go.isClientSideDefault(qp.style)) {
+            qpText = emitClientSideDefault(qp, qp.style, (name, val) => { return `\treqQP.Set(${name}, ${val})`; }, imports);
         }
-        else if (go.isRequiredParameter(qp) || go.isLiteralParameter(qp) || (qp.location === 'client' && go.isClientSideDefault(qp.kind))) {
+        else if (go.isRequiredParameter(qp) || go.isLiteralParameter(qp) || (qp.location === 'client' && go.isClientSideDefault(qp.style))) {
             qpText = `\t${setter}\n`;
         }
         else if (qp.location === 'client' && !qp.group) {
@@ -658,7 +646,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         text += '\treqQP := req.Raw().URL.Query()\n';
         for (const qp of values(encodedParams.sort((a, b) => { return helpers.sortAscending(a.queryParameter, b.queryParameter); }))) {
             let setter;
-            if (go.isQueryCollectionParameter(qp) && qp.collectionFormat === 'multi') {
+            if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
                 setter = `\tfor _, qv := range ${helpers.getParamName(qp)} {\n`;
                 // emit a type conversion for the qv based on the array's element type
                 let queryVal;
@@ -702,7 +690,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         }
         for (const qp of values(unencodedParams.sort((a, b) => { return helpers.sortAscending(a.queryParameter, b.queryParameter); }))) {
             let setter;
-            if (go.isQueryCollectionParameter(qp) && qp.collectionFormat === 'multi') {
+            if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
                 setter = `\tfor _, qv := range ${helpers.getParamName(qp)} {\n`;
                 setter += `\t\tunencodedParams = append(unencodedParams, "${qp.queryParameter}="+qv)\n`;
                 setter += '\t}';
@@ -715,49 +703,43 @@ function createProtocolRequest(azureARM, client, method, imports) {
         imports.add('strings');
         text += '\treq.Raw().URL.RawQuery = strings.Join(unencodedParams, "&")\n';
     }
-    if (go.isMethod(method) && method.responseEnvelope.result && go.isBinaryResult(method.responseEnvelope.result)) {
+    if (method.kind !== 'nextPageMethod' && method.responseEnvelope.result?.kind === 'binaryResult') {
         // skip auto-body downloading for binary stream responses
         text += '\truntime.SkipBodyDownload(req)\n';
     }
     // add specific request headers
     const emitHeaderSet = function (headerParam, prefix) {
-        if (headerParam.location === 'method' && go.isClientSideDefault(headerParam.kind)) {
-            return emitClientSideDefault(headerParam, headerParam.kind, (name, val) => {
-                return `${prefix}req.Raw().Header[${name}] = []string{${val}}`;
-            }, imports);
-        }
-        else if (go.isHeaderMapParameter(headerParam)) {
+        if (headerParam.kind === 'headerMapParam') {
             let headerText = `${prefix}for k, v := range ${helpers.getParamName(headerParam)} {\n`;
             headerText += `${prefix}\tif v != nil {\n`;
-            headerText += `${prefix}\t\treq.Raw().Header["${headerParam.collectionPrefix}"+k] = []string{*v}\n`;
+            headerText += `${prefix}\t\treq.Raw().Header["${headerParam.headerName}"+k] = []string{*v}\n`;
             headerText += `${prefix}}\n`;
             headerText += `${prefix}}\n`;
             return headerText;
         }
+        else if (headerParam.location === 'method' && go.isClientSideDefault(headerParam.style)) {
+            return emitClientSideDefault(headerParam, headerParam.style, (name, val) => {
+                return `${prefix}req.Raw().Header[${name}] = []string{${val}}`;
+            }, imports);
+        }
         else {
             return `${prefix}req.Raw().Header["${headerParam.headerName}"] = []string{${helpers.formatParamValue(headerParam, imports)}}\n`;
         }
     };
-    const headerParams = new Array();
-    for (const param of values(method.parameters)) {
-        if (go.isHeaderParameter(param)) {
-            headerParams.push(param);
-        }
-    }
     let contentType;
-    for (const param of headerParams.sort((a, b) => { return helpers.sortAscending(a.headerName, b.headerName); })) {
+    for (const param of methodParamGroups.headerParams.sort((a, b) => { return helpers.sortAscending(a.headerName, b.headerName); })) {
         if (param.headerName.match(/^content-type$/)) {
             // canonicalize content-type as req.SetBody checks for it via its canonicalized name :(
             param.headerName = 'Content-Type';
         }
-        if (param.headerName === 'Content-Type' && param.kind === 'literal') {
+        if (param.headerName === 'Content-Type' && param.style === 'literal') {
             // the content-type header will be set as part of emitSetBodyWithErrCheck
             // to handle cases where the body param is optional. we don't want to set
             // the content-type if the body is nil.
             // we do it like this as tsp specifies content-type while swagger does not.
             contentType = helpers.formatParamValue(param, imports);
         }
-        else if (go.isRequiredParameter(param) || go.isLiteralParameter(param) || go.isClientSideDefault(param.kind)) {
+        else if (go.isRequiredParameter(param) || go.isLiteralParameter(param) || go.isClientSideDefault(param.style)) {
             text += emitHeaderSet(param, '\t');
         }
         else if (param.location === 'client' && !param.group) {
@@ -772,8 +754,11 @@ function createProtocolRequest(azureARM, client, method, imports) {
             text += '\t}\n';
         }
     }
-    const partialBodyParams = values(method.parameters).where((param) => { return go.isPartialBodyParameter(param); }).toArray();
-    const bodyParam = values(method.parameters).where((each) => { return go.isBodyParameter(each) || go.isFormBodyParameter(each) || go.isMultipartFormBodyParameter(each); }).first();
+    // note that these are mutually exclusive
+    const bodyParam = methodParamGroups.bodyParam;
+    const formBodyParams = methodParamGroups.formBodyParams;
+    const multipartBodyParams = methodParamGroups.multipartBodyParams;
+    const partialBodyParams = methodParamGroups.partialBodyParams;
     const emitSetBodyWithErrCheck = function (setBodyParam, contentType) {
         let content = `if err := ${setBodyParam}; err != nil {\n\treturn nil, err\n}\n;`;
         if (contentType) {
@@ -781,7 +766,111 @@ function createProtocolRequest(azureARM, client, method, imports) {
         }
         return content;
     };
-    if (partialBodyParams.length > 0) {
+    if (bodyParam) {
+        if (bodyParam.bodyFormat === 'JSON' || bodyParam.bodyFormat === 'XML') {
+            // default to the body param name
+            let body = helpers.getParamName(bodyParam);
+            if (go.isLiteralValue(bodyParam.type)) {
+                // if the value is constant, embed it directly
+                body = helpers.formatLiteralValue(bodyParam.type, true);
+            }
+            else if (bodyParam.bodyFormat === 'XML' && go.isSliceType(bodyParam.type)) {
+                // for XML payloads, create a wrapper type if the payload is an array
+                imports.add('encoding/xml');
+                text += '\ttype wrapper struct {\n';
+                let tagName = go.getTypeDeclaration(bodyParam.type);
+                if (bodyParam.xml?.name) {
+                    tagName = bodyParam.xml.name;
+                }
+                text += `\t\tXMLName xml.Name \`xml:"${tagName}"\`\n`;
+                const fieldName = capitalize(bodyParam.name);
+                let tag = go.getTypeDeclaration(bodyParam.type.elementType);
+                if (go.isModelType(bodyParam.type.elementType) && bodyParam.type.elementType.xml?.name) {
+                    tag = bodyParam.type.elementType.xml.name;
+                }
+                text += `\t\t${fieldName} *${go.getTypeDeclaration(bodyParam.type)} \`xml:"${tag}"\`\n`;
+                text += '\t}\n';
+                let addr = '&';
+                if (!go.isRequiredParameter(bodyParam) && !bodyParam.byValue) {
+                    addr = '';
+                }
+                body = `wrapper{${fieldName}: ${addr}${body}}`;
+            }
+            else if (go.isTimeType(bodyParam.type) && bodyParam.type.dateTimeFormat !== 'dateTimeRFC3339') {
+                // wrap the body in the internal time type
+                // no need for dateTimeRFC3339 as the JSON marshaler defaults to that.
+                body = `${bodyParam.type.dateTimeFormat}(${body})`;
+            }
+            else if (isArrayOfDateTimeForMarshalling(bodyParam.type)) {
+                const timeInfo = isArrayOfDateTimeForMarshalling(bodyParam.type);
+                let elementPtr = '*';
+                if (timeInfo?.elemByVal) {
+                    elementPtr = '';
+                }
+                text += `\taux := make([]${elementPtr}${timeInfo?.format}, len(${body}))\n`;
+                text += `\tfor i := 0; i < len(${body}); i++ {\n`;
+                text += `\t\taux[i] = (${elementPtr}${timeInfo?.format})(${body}[i])\n`;
+                text += '\t}\n';
+                body = 'aux';
+            }
+            else if (isMapOfDateTime(bodyParam.type)) {
+                const timeType = isMapOfDateTime(bodyParam.type);
+                text += `\taux := map[string]*${timeType}{}\n`;
+                text += `\tfor k, v := range ${body} {\n`;
+                text += `\t\taux[k] = (*${timeType})(v)\n`;
+                text += '\t}\n';
+                body = 'aux';
+            }
+            let setBody = `runtime.MarshalAs${getMediaFormat(bodyParam.type, bodyParam.bodyFormat, `req, ${body}`)}`;
+            if (go.isSliceType(bodyParam.type) && bodyParam.type.rawJSONAsBytes) {
+                imports.add('bytes');
+                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
+                setBody = `req.SetBody(streaming.NopCloser(bytes.NewReader(${body})), "application/${bodyParam.bodyFormat.toLowerCase()}")`;
+            }
+            if (go.isRequiredParameter(bodyParam) || go.isLiteralParameter(bodyParam)) {
+                text += `\t${emitSetBodyWithErrCheck(setBody, contentType)}`;
+                text += '\treturn req, nil\n';
+            }
+            else {
+                text += emitParamGroupCheck(bodyParam);
+                text += `\t${emitSetBodyWithErrCheck(setBody, contentType)}`;
+                text += '\t\treturn req, nil\n';
+                text += '\t}\n';
+                text += '\treturn req, nil\n';
+            }
+        }
+        else if (bodyParam.bodyFormat === 'binary') {
+            if (go.isRequiredParameter(bodyParam)) {
+                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${bodyParam.contentType})`, contentType)}`;
+                text += '\treturn req, nil\n';
+            }
+            else {
+                text += emitParamGroupCheck(bodyParam);
+                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(${helpers.getParamName(bodyParam)}, ${bodyParam.contentType})`, contentType)}`;
+                text += '\treturn req, nil\n';
+                text += '\t}\n';
+                text += '\treturn req, nil\n';
+            }
+        }
+        else if (bodyParam.bodyFormat === 'Text') {
+            imports.add('strings');
+            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
+            if (go.isRequiredParameter(bodyParam)) {
+                text += `\tbody := streaming.NopCloser(strings.NewReader(${bodyParam.name}))\n`;
+                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType)}`;
+                text += '\treturn req, nil\n';
+            }
+            else {
+                text += emitParamGroupCheck(bodyParam);
+                text += `\tbody := streaming.NopCloser(strings.NewReader(${helpers.getParamName(bodyParam)}))\n`;
+                text += `\t${emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType)}`;
+                text += '\treturn req, nil\n';
+                text += '\t}\n';
+                text += '\treturn req, nil\n';
+            }
+        }
+    }
+    else if (partialBodyParams.length > 0) {
         // partial body params are discrete params that are all fields within an internal struct.
         // define and instantiate an instance of the wire type, using the values from each param.
         text += '\tbody := struct {\n';
@@ -808,123 +897,14 @@ function createProtocolRequest(azureARM, client, method, imports) {
         text += '\tif err := runtime.MarshalAsJSON(req, body); err != nil {\n\t\treturn nil, err\n\t}\n';
         text += '\treturn req, nil\n';
     }
-    else if (!bodyParam) {
-        text += '\treturn req, nil\n';
-    }
-    else if (bodyParam.bodyFormat === 'JSON' || bodyParam.bodyFormat === 'XML') {
-        // default to the body param name
-        let body = helpers.getParamName(bodyParam);
-        if (go.isLiteralValue(bodyParam.type)) {
-            // if the value is constant, embed it directly
-            body = helpers.formatLiteralValue(bodyParam.type, true);
-        }
-        else if (bodyParam.bodyFormat === 'XML' && go.isSliceType(bodyParam.type)) {
-            // for XML payloads, create a wrapper type if the payload is an array
-            imports.add('encoding/xml');
-            text += '\ttype wrapper struct {\n';
-            let tagName = go.getTypeDeclaration(bodyParam.type);
-            if (bodyParam.xml?.name) {
-                tagName = bodyParam.xml.name;
-            }
-            text += `\t\tXMLName xml.Name \`xml:"${tagName}"\`\n`;
-            const fieldName = capitalize(bodyParam.name);
-            let tag = go.getTypeDeclaration(bodyParam.type.elementType);
-            if (go.isModelType(bodyParam.type.elementType) && bodyParam.type.elementType.xml?.name) {
-                tag = bodyParam.type.elementType.xml.name;
-            }
-            text += `\t\t${fieldName} *${go.getTypeDeclaration(bodyParam.type)} \`xml:"${tag}"\`\n`;
-            text += '\t}\n';
-            let addr = '&';
-            if (!go.isRequiredParameter(bodyParam) && !bodyParam.byValue) {
-                addr = '';
-            }
-            body = `wrapper{${fieldName}: ${addr}${body}}`;
-        }
-        else if (go.isTimeType(bodyParam.type) && bodyParam.type.dateTimeFormat !== 'dateTimeRFC3339') {
-            // wrap the body in the internal time type
-            // no need for dateTimeRFC3339 as the JSON marshaler defaults to that.
-            body = `${bodyParam.type.dateTimeFormat}(${body})`;
-        }
-        else if (isArrayOfDateTimeForMarshalling(bodyParam.type)) {
-            const timeInfo = isArrayOfDateTimeForMarshalling(bodyParam.type);
-            let elementPtr = '*';
-            if (timeInfo?.elemByVal) {
-                elementPtr = '';
-            }
-            text += `\taux := make([]${elementPtr}${timeInfo?.format}, len(${body}))\n`;
-            text += `\tfor i := 0; i < len(${body}); i++ {\n`;
-            text += `\t\taux[i] = (${elementPtr}${timeInfo?.format})(${body}[i])\n`;
-            text += '\t}\n';
-            body = 'aux';
-        }
-        else if (isMapOfDateTime(bodyParam.type)) {
-            const timeType = isMapOfDateTime(bodyParam.type);
-            text += `\taux := map[string]*${timeType}{}\n`;
-            text += `\tfor k, v := range ${body} {\n`;
-            text += `\t\taux[k] = (*${timeType})(v)\n`;
-            text += '\t}\n';
-            body = 'aux';
-        }
-        let setBody = `runtime.MarshalAs${getMediaFormat(bodyParam.type, bodyParam.bodyFormat, `req, ${body}`)}`;
-        if (go.isSliceType(bodyParam.type) && bodyParam.type.rawJSONAsBytes) {
-            imports.add('bytes');
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
-            setBody = `req.SetBody(streaming.NopCloser(bytes.NewReader(${body})), "application/${bodyParam.bodyFormat.toLowerCase()}")`;
-        }
-        if (go.isRequiredParameter(bodyParam) || go.isLiteralParameter(bodyParam)) {
-            text += `\t${emitSetBodyWithErrCheck(setBody, contentType)}`;
-            text += '\treturn req, nil\n';
-        }
-        else {
-            text += emitParamGroupCheck(bodyParam);
-            text += `\t${emitSetBodyWithErrCheck(setBody, contentType)}`;
-            text += '\t\treturn req, nil\n';
-            text += '\t}\n';
-            text += '\treturn req, nil\n';
-        }
-    }
-    else if (bodyParam.bodyFormat === 'binary') {
-        if (go.isRequiredParameter(bodyParam)) {
-            text += `\t${emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${bodyParam.contentType})`, contentType)}`;
-            text += '\treturn req, nil\n';
-        }
-        else {
-            text += emitParamGroupCheck(bodyParam);
-            text += `\t${emitSetBodyWithErrCheck(`req.SetBody(${helpers.getParamName(bodyParam)}, ${bodyParam.contentType})`, contentType)}`;
-            text += '\treturn req, nil\n';
-            text += '\t}\n';
-            text += '\treturn req, nil\n';
-        }
-    }
-    else if (bodyParam.bodyFormat === 'Text') {
-        imports.add('strings');
-        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
-        const bodyParam = values(method.parameters).where((each) => { return go.isBodyParameter(each); }).first();
-        if (go.isRequiredParameter(bodyParam)) {
-            text += `\tbody := streaming.NopCloser(strings.NewReader(${bodyParam.name}))\n`;
-            text += `\t${emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType)}`;
-            text += '\treturn req, nil\n';
-        }
-        else {
-            text += emitParamGroupCheck(bodyParam);
-            text += `\tbody := streaming.NopCloser(strings.NewReader(${helpers.getParamName(bodyParam)}))\n`;
-            text += `\t${emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType)}`;
-            text += '\treturn req, nil\n';
-            text += '\t}\n';
-            text += '\treturn req, nil\n';
-        }
-    }
-    else if (go.isMultipartFormBodyParameter(bodyParam)) {
-        if (go.isModelType(bodyParam.type) && bodyParam.type.annotations.multipartFormData) {
-            text += `\tformData, err := ${bodyParam.name}.toMultipartFormData()\n`;
+    else if (multipartBodyParams.length > 0) {
+        if (multipartBodyParams.length === 1 && go.isModelType(multipartBodyParams[0].type) && multipartBodyParams[0].type.annotations.multipartFormData) {
+            text += `\tformData, err := ${multipartBodyParams[0].name}.toMultipartFormData()\n`;
             text += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         }
         else {
             text += '\tformData := map[string]any{}\n';
-            for (const param of values(method.parameters)) {
-                if (!go.isMultipartFormBodyParameter(param)) {
-                    continue;
-                }
+            for (const param of multipartBodyParams) {
                 const setter = `formData["${param.name}"] = ${helpers.getParamName(param)}`;
                 if (go.isRequiredParameter(param)) {
                     text += `\t${setter}\n`;
@@ -938,7 +918,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         text += '\tif err := runtime.SetMultipartFormData(req, formData); err != nil {\n\t\treturn nil, err\n\t}\n';
         text += '\treturn req, nil\n';
     }
-    else if (go.isFormBodyParameter(bodyParam)) {
+    else if (formBodyParams.length > 0) {
         const emitFormData = function (param, setter) {
             let formDataText = '';
             if (go.isRequiredParameter(param)) {
@@ -956,11 +936,9 @@ function createProtocolRequest(azureARM, client, method, imports) {
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
         text += '\tformData := url.Values{}\n';
         // find all the form body params
-        for (const param of values(method.parameters)) {
-            if (go.isFormBodyParameter(param)) {
-                const setter = `formData.Set("${param.formDataName}", ${helpers.formatParamValue(param, imports)})`;
-                text += emitFormData(param, setter);
-            }
+        for (const param of formBodyParams) {
+            const setter = `formData.Set("${param.formDataName}", ${helpers.formatParamValue(param, imports)})`;
+            text += emitFormData(param, setter);
         }
         text += '\tbody := streaming.NopCloser(strings.NewReader(formData.Encode()))\n';
         text += `\t${emitSetBodyWithErrCheck('req.SetBody(body, "application/x-www-form-urlencoded")')}`;
@@ -979,11 +957,15 @@ function emitClientSideDefault(param, csd, setterFormat, imports) {
     text += `\t\t${defaultVar} = *options.${capitalize(param.name)}\n`;
     text += '}\n';
     let serializedName;
-    if (go.isHeaderParameter(param)) {
-        serializedName = param.headerName;
-    }
-    else {
-        serializedName = param.queryParameter;
+    switch (param.kind) {
+        case 'headerCollectionParam':
+        case 'headerScalarParam':
+            serializedName = param.headerName;
+            break;
+        case 'queryCollectionParam':
+        case 'queryScalarParam':
+            serializedName = param.queryParameter;
+            break;
     }
     text += setterFormat(`"${serializedName}"`, helpers.formatValue(defaultVar, param.type, imports)) + '\n';
     return text;
@@ -1111,56 +1093,59 @@ function createProtocolResponse(client, method, imports) {
         text += `\tresult := ${method.responseEnvelope.name}{}\n`;
         addHeaders(method.responseEnvelope.headers);
     }
-    else if (go.isAnyResult(result)) {
-        imports.add('fmt');
-        text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-        addHeaders(method.responseEnvelope.headers);
-        text += '\tswitch resp.StatusCode {\n';
-        for (const statusCode of method.httpStatusCodes) {
-            text += `\tcase ${helpers.formatStatusCodes([statusCode])}:\n`;
-            const resultType = result.httpStatusCodeType[statusCode];
-            if (!resultType) {
-                // the operation contains a mix of schemas and non-schema responses
-                continue;
-            }
-            text += `\tvar val ${go.getTypeDeclaration(resultType)}\n`;
-            text += generateResponseUnmarshaller(method, resultType, result.format, 'val');
-            text += '\tresult.Value = val\n';
-        }
-        text += '\tdefault:\n';
-        text += `\t\treturn ${getZeroReturnValue(method, 'handler')}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)\n`;
-        text += '\t}\n';
-    }
-    else if (go.isBinaryResult(result)) {
-        text += `\tresult := ${method.responseEnvelope.name}{${result.fieldName}: resp.Body}\n`;
-        addHeaders(method.responseEnvelope.headers);
-    }
-    else if (go.isHeadAsBooleanResult(result)) {
-        text += `\tresult := ${method.responseEnvelope.name}{${result.fieldName}: resp.StatusCode >= 200 && resp.StatusCode < 300}\n`;
-        addHeaders(method.responseEnvelope.headers);
-    }
-    else if (go.isMonomorphicResult(result)) {
-        text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-        addHeaders(method.responseEnvelope.headers);
-        let target = `result.${helpers.getResultFieldName(method)}`;
-        // when unmarshalling a wrapped XML array, unmarshal into the response envelope
-        if (result.format === 'XML' && go.isSliceType(result.monomorphicType)) {
-            target = 'result';
-        }
-        text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target);
-    }
-    else if (go.isPolymorphicResult(result)) {
-        text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-        addHeaders(method.responseEnvelope.headers);
-        text += generateResponseUnmarshaller(method, result.interfaceType, result.format, 'result');
-    }
-    else if (go.isModelResult(result)) {
-        text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-        addHeaders(method.responseEnvelope.headers);
-        text += generateResponseUnmarshaller(method, result.modelType, result.format, `result.${helpers.getResultFieldName(method)}`);
-    }
     else {
-        throw new CodegenError('InternalError', `unhandled result type for ${client.name}.${method.name}`);
+        switch (result.kind) {
+            case 'anyResult':
+                imports.add('fmt');
+                text += `\tresult := ${method.responseEnvelope.name}{}\n`;
+                addHeaders(method.responseEnvelope.headers);
+                text += '\tswitch resp.StatusCode {\n';
+                for (const statusCode of method.httpStatusCodes) {
+                    text += `\tcase ${helpers.formatStatusCodes([statusCode])}:\n`;
+                    const resultType = result.httpStatusCodeType[statusCode];
+                    if (!resultType) {
+                        // the operation contains a mix of schemas and non-schema responses
+                        continue;
+                    }
+                    text += `\tvar val ${go.getTypeDeclaration(resultType)}\n`;
+                    text += generateResponseUnmarshaller(method, resultType, result.format, 'val');
+                    text += '\tresult.Value = val\n';
+                }
+                text += '\tdefault:\n';
+                text += `\t\treturn ${getZeroReturnValue(method, 'handler')}, fmt.Errorf("unhandled HTTP status code %d", resp.StatusCode)\n`;
+                text += '\t}\n';
+                break;
+            case 'binaryResult':
+                text += `\tresult := ${method.responseEnvelope.name}{${result.fieldName}: resp.Body}\n`;
+                addHeaders(method.responseEnvelope.headers);
+                break;
+            case 'headAsBooleanResult':
+                text += `\tresult := ${method.responseEnvelope.name}{${result.fieldName}: resp.StatusCode >= 200 && resp.StatusCode < 300}\n`;
+                addHeaders(method.responseEnvelope.headers);
+                break;
+            case 'modelResult':
+                text += `\tresult := ${method.responseEnvelope.name}{}\n`;
+                addHeaders(method.responseEnvelope.headers);
+                text += generateResponseUnmarshaller(method, result.modelType, result.format, `result.${helpers.getResultFieldName(method)}`);
+                break;
+            case 'monomorphicResult':
+                text += `\tresult := ${method.responseEnvelope.name}{}\n`;
+                addHeaders(method.responseEnvelope.headers);
+                let target = `result.${helpers.getResultFieldName(method)}`;
+                // when unmarshalling a wrapped XML array, unmarshal into the response envelope
+                if (result.format === 'XML' && go.isSliceType(result.monomorphicType)) {
+                    target = 'result';
+                }
+                text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target);
+                break;
+            case 'polymorphicResult':
+                text += `\tresult := ${method.responseEnvelope.name}{}\n`;
+                addHeaders(method.responseEnvelope.headers);
+                text += generateResponseUnmarshaller(method, result.interfaceType, result.format, 'result');
+                break;
+            default:
+                result;
+        }
     }
     text += '\treturn result, nil\n';
     text += '}\n\n';
@@ -1192,7 +1177,7 @@ function isMapOfDateTime(paramType) {
 function getAPIParametersSig(method, imports, pkgName) {
     const methodParams = helpers.getMethodParameters(method);
     const params = new Array();
-    if (!go.isPageableMethod(method) || go.isLROMethod(method)) {
+    if (method.kind !== 'pageableMethod') {
         imports.add('context');
         params.push('ctx context.Context');
     }
@@ -1209,34 +1194,37 @@ function getAPIParametersSig(method, imports, pkgName) {
 // handler - for the response handler
 function generateReturnsInfo(method, apiType) {
     let returnType = method.responseEnvelope.name;
-    if (go.isLROMethod(method)) {
-        switch (apiType) {
-            case 'api':
-                if (go.isPageableMethod(method)) {
-                    returnType = `*runtime.Poller[*runtime.Pager[${returnType}]]`;
-                }
-                else {
-                    returnType = `*runtime.Poller[${returnType}]`;
-                }
-                break;
-            case 'handler':
-                // we only have a handler for operations that return a schema
-                if (!go.isPageableMethod(method)) {
-                    throw new CodegenError('InternalError', `handler being generated for non-pageable LRO ${method.name} which is unexpected`);
-                }
-                break;
-            case 'op':
-                returnType = '*http.Response';
-                break;
-        }
-    }
-    else if (go.isPageableMethod(method)) {
-        switch (apiType) {
-            case 'api':
-            case 'op':
-                // pager operations don't return an error
-                return [`*runtime.Pager[${returnType}]`];
-        }
+    switch (method.kind) {
+        case 'lroMethod':
+        case 'lroPageableMethod':
+            switch (apiType) {
+                case 'api':
+                    if (method.kind === 'lroPageableMethod') {
+                        returnType = `*runtime.Poller[*runtime.Pager[${returnType}]]`;
+                    }
+                    else {
+                        returnType = `*runtime.Poller[${returnType}]`;
+                    }
+                    break;
+                case 'handler':
+                    // we only have a handler for operations that return a schema
+                    if (method.kind !== 'lroPageableMethod') {
+                        throw new CodegenError('InternalError', `handler being generated for non-pageable LRO ${method.name} which is unexpected`);
+                    }
+                    break;
+                case 'op':
+                    returnType = '*http.Response';
+                    break;
+            }
+            break;
+        case 'pageableMethod':
+            switch (apiType) {
+                case 'api':
+                case 'op':
+                    // pager operations don't return an error
+                    return [`*runtime.Pager[${returnType}]`];
+            }
+            break;
     }
     return [returnType, 'error'];
 }
@@ -1258,7 +1246,7 @@ function generateLROBeginMethod(client, method, imports, injectSpans, generateFa
     text += `func (client *${client.name}) ${fixUpMethodName(method)}(${params}) (${returns.join(', ')}) {\n`;
     let pollerType = 'nil';
     let pollerTypeParam = `[${method.responseEnvelope.name}]`;
-    if (go.isPageableMethod(method)) {
+    if (method.kind === 'lroPageableMethod') {
         // for paged LROs, we construct a pager and pass it to the LRO ctor.
         pollerTypeParam = `[*runtime.Pager${pollerTypeParam}]`;
         pollerType = '&pager';
@@ -1347,21 +1335,24 @@ function generateLROBeginMethod(client, method, imports, injectSpans, generateFa
     return text;
 }
 export function fixUpMethodName(method) {
-    if (go.isLROMethod(method)) {
-        return `Begin${method.name}`;
-    }
-    if (go.isPageableMethod(method)) {
-        let N = 'N';
-        let name = method.name;
-        if (method.name[0] !== method.name[0].toUpperCase()) {
-            // the method isn't exported; don't export the pager ctor
-            N = 'n';
-            // ensure correct casing of the emitted function name e.g.,
-            // "listThings" -> "newListThingsPager"
-            name = name[0].toUpperCase() + name.substring(1);
+    switch (method.kind) {
+        case 'lroMethod':
+        case 'lroPageableMethod':
+            return `Begin${method.name}`;
+        case 'pageableMethod': {
+            let N = 'N';
+            let name = method.name;
+            if (method.name[0] !== method.name[0].toUpperCase()) {
+                // the method isn't exported; don't export the pager ctor
+                N = 'n';
+                // ensure correct casing of the emitted function name e.g.,
+                // "listThings" -> "newListThingsPager"
+                name = name[0].toUpperCase() + name.substring(1);
+            }
+            return `${N}ew${name}Pager`;
         }
-        return `${N}ew${name}Pager`;
+        case 'method':
+            return method.name;
     }
-    return method.name;
 }
 //# sourceMappingURL=operations.js.map