@azure-tools/typespec-go 0.8.2 → 0.8.3

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

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as go from '../../codemodel.go/src/index.js';
+import { ensureNameCase } from '../../naming.go/src/naming.js';
 import { capitalize, comment, uncapitalize } from '@azure-tools/codegen';
 import { values } from '@azure-tools/linq';
 import * as helpers from './helpers.js';
@@ -35,20 +36,14 @@ export async function generateOperations(codeModel) {
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/policy');
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
         }
-        let clientPkg = 'azcore';
-        if (azureARM) {
-            clientPkg = 'arm';
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/arm');
-            client.constructors.push(createARMClientConstructor(client, imports));
-        }
-        else {
+        if (!azureARM) {
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
         }
         // generate client type
         let clientText = helpers.formatDocComment(client.docs);
         clientText += '// Don\'t use this type directly, use ';
-        if (client.constructors.length === 1) {
-            clientText += `${client.constructors[0].name}() instead.\n`;
+        if (client.instance?.kind === 'constructable' && client.instance.constructors.length === 1) {
+            clientText += `${client.instance.constructors[0].name}() instead.\n`;
         }
         else if (client.parent) {
             // find the accessor method
@@ -68,7 +63,7 @@ export async function generateOperations(codeModel) {
             clientText += 'a constructor function instead.\n';
         }
         clientText += `type ${client.name} struct {\n`;
-        clientText += `\tinternal *${clientPkg}.Client\n`;
+        clientText += `\tinternal *${azureARM ? 'arm' : 'azcore'}.Client\n`;
         // check for any optional host params
         const optionalParams = new Array();
         const isParamPointer = function (param) {
@@ -79,7 +74,7 @@ export async function generateOperations(codeModel) {
         if (client.parameters.length > 0) {
             const addedGroups = new Set();
             for (const clientParam of values(client.parameters)) {
-                if (go.isLiteralParameter(clientParam)) {
+                if (go.isLiteralParameter(clientParam.style)) {
                     continue;
                 }
                 if (clientParam.group) {
@@ -96,7 +91,7 @@ export async function generateOperations(codeModel) {
                 else {
                     clientText += `${helpers.formatParameterTypeName(clientParam)}\n`;
                 }
-                if (!go.isRequiredParameter(clientParam)) {
+                if (!go.isRequiredParameter(clientParam.style)) {
                     optionalParams.push(clientParam);
                 }
             }
@@ -106,8 +101,7 @@ export async function generateOperations(codeModel) {
         if (azureARM && optionalParams.length > 0) {
             throw new CodegenError('UnsupportedTsp', 'optional client parameters for ARM is not supported');
         }
-        // generate client constructors
-        clientText += generateConstructors(azureARM, client, imports);
+        clientText += generateConstructors(client, imports);
         // generate client accessors and operations
         let opText = '';
         for (const clientAccessor of client.clientAccessors) {
@@ -117,6 +111,9 @@ export async function generateOperations(codeModel) {
             opText += '\t\tinternal: client.internal,\n';
             // propagate all client params
             for (const param of client.parameters) {
+                if (go.isLiteralParameter(param.style)) {
+                    continue;
+                }
                 opText += `\t\t${param.name}: client.${param.name},\n`;
             }
             opText += '\t}\n}\n\n';
@@ -127,13 +124,13 @@ export async function generateOperations(codeModel) {
             // it must be done before the imports are written out
             if (go.isLROMethod(method)) {
                 // generate Begin method
-                opText += generateLROBeginMethod(client, method, imports, codeModel.options.injectSpans, codeModel.options.generateFakes);
+                opText += generateLROBeginMethod(method, imports, codeModel.options.injectSpans, codeModel.options.generateFakes);
             }
-            opText += generateOperation(client, method, imports, codeModel.options.injectSpans, codeModel.options.generateFakes);
-            opText += createProtocolRequest(azureARM, client, method, imports);
+            opText += generateOperation(method, imports, codeModel.options.injectSpans, codeModel.options.generateFakes);
+            opText += createProtocolRequest(azureARM, method, imports);
             if (method.kind !== 'lroMethod') {
                 // LRO responses are handled elsewhere, with the exception of pageable LROs
-                opText += createProtocolResponse(client, method, imports);
+                opText += createProtocolResponse(method, imports);
             }
             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
@@ -141,7 +138,7 @@ export async function generateOperations(codeModel) {
             }
         }
         for (const method of nextPageMethods) {
-            opText += createProtocolRequest(azureARM, client, method, imports);
+            opText += createProtocolRequest(azureARM, method, imports);
         }
         // stitch it all together
         let text = helpers.contentPreamble(codeModel);
@@ -152,65 +149,222 @@ export async function generateOperations(codeModel) {
     }
     return operations;
 }
-// generates all modeled client constructors
-function generateConstructors(azureARM, client, imports) {
-    if (client.constructors.length === 0) {
+/**
+ * generates all modeled client constructors and client options types.
+ * if there are no client constructors, the empty string is returned.
+ *
+ * @param client the client for which to generate constructors and the client options type
+ * @param imports the import manager currently in scope
+ * @returns the client constructor code or the empty string
+ */
+function generateConstructors(client, imports) {
+    if (client.instance?.kind !== 'constructable') {
         return '';
     }
+    const clientOptions = client.instance.options;
     let ctorText = '';
-    for (const constructor of client.constructors) {
+    if (clientOptions.kind === 'clientOptions') {
+        // for non-ARM, the options type will always be a parameter group
+        ctorText += `// ${clientOptions.name} contains the optional values for creating a [${client.name}].\n`;
+        ctorText += `type ${clientOptions.name} struct {\n\tazcore.ClientOptions\n`;
+        for (const param of clientOptions.params) {
+            if (go.isAPIVersionParameter(param)) {
+                // we use azcore.ClientOptions.APIVersion
+                continue;
+            }
+            ctorText += helpers.formatDocCommentWithPrefix(ensureNameCase(param.name), param.docs);
+            if (go.isClientSideDefault(param.style)) {
+                if (!param.docs.description && !param.docs.summary) {
+                    ctorText += '\n';
+                }
+                ctorText += `\t${comment(`The default value is ${helpers.formatLiteralValue(param.style.defaultValue, false)}`, '// ')}.\n`;
+            }
+            ctorText += `\t${ensureNameCase(param.name)} *${go.getTypeDeclaration(param.type)}\n`;
+        }
+        ctorText += '}\n\n';
+    }
+    for (const constructor of client.instance.constructors) {
         const ctorParams = new Array();
         const paramDocs = new Array();
-        constructor.parameters.sort(helpers.sortParametersByRequired);
-        for (const ctorParam of constructor.parameters) {
+        // ctor params can also be present in the supplemental endpoint parameters
+        const consolidatedCtorParams = new Array(...constructor.parameters);
+        if (client.instance.endpoint) {
+            consolidatedCtorParams.push(...client.instance.endpoint.parameters);
+        }
+        consolidatedCtorParams.sort(helpers.sortParametersByRequired);
+        for (const ctorParam of consolidatedCtorParams) {
+            if (!go.isRequiredParameter(ctorParam.style)) {
+                // param is part of the options group
+                continue;
+            }
             imports.addImportForType(ctorParam.type);
             ctorParams.push(`${ctorParam.name} ${helpers.formatParameterTypeName(ctorParam)}`);
             if (ctorParam.docs.summary || ctorParam.docs.description) {
                 paramDocs.push(helpers.formatCommentAsBulletItem(ctorParam.name, ctorParam.docs));
             }
         }
+        const emitProlog = function (optionsTypeName, tokenAuth, plOpts) {
+            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
+            let bodyText = `\tif options == nil {\n\t\toptions = &${optionsTypeName}{}\n\t}\n`;
+            let apiVersionConfig = '';
+            // check if there's an api version parameter
+            let apiVersionParam;
+            for (const param of consolidatedCtorParams) {
+                switch (param.kind) {
+                    case 'headerScalarParam':
+                    case 'pathScalarParam':
+                    case 'queryScalarParam':
+                    case 'uriParam':
+                        if (param.isApiVersion) {
+                            apiVersionParam = param;
+                        }
+                }
+            }
+            if (tokenAuth) {
+                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud');
+                imports.add('fmt');
+                imports.add('reflect');
+                bodyText += '\tif reflect.ValueOf(options.Cloud).IsZero() {\n';
+                bodyText += '\t\toptions.Cloud = cloud.AzurePublic\n\t}\n';
+                bodyText += '\tc, ok := options.Cloud.Services[ServiceName]\n';
+                bodyText += '\tif !ok {\n';
+                bodyText += '\t\treturn nil, fmt.Errorf("provided Cloud field is missing configuration for %s", ServiceName)\n';
+                bodyText += '\t} else if c.Audience == "" {\n';
+                bodyText += '\t\treturn nil, fmt.Errorf("provided Cloud field is missing Audience for %s", ServiceName)\n\t}\n';
+            }
+            if (apiVersionParam) {
+                let location;
+                let name;
+                switch (apiVersionParam.kind) {
+                    case 'headerScalarParam':
+                        location = 'Header';
+                        name = apiVersionParam.headerName;
+                        break;
+                    case 'pathScalarParam':
+                    case 'uriParam':
+                        location = 'Path';
+                        // name isn't used for the path case
+                        break;
+                    case 'queryScalarParam':
+                        location = 'QueryParam';
+                        name = apiVersionParam.queryParameter;
+                        break;
+                }
+                if (name) {
+                    name = `\n\t\t\tName: "${name}",`;
+                }
+                else {
+                    name = '';
+                }
+                apiVersionConfig = `\n\t\tAPIVersion: runtime.APIVersionOptions{${name}\n\t\t\tLocation: runtime.APIVersionLocation${location},\n\t\t},`;
+                if (!plOpts) {
+                    apiVersionConfig += '\n';
+                }
+            }
+            bodyText += `\tcl, err := azcore.NewClient(moduleName, moduleVersion, runtime.PipelineOptions{${apiVersionConfig}${plOpts ?? ''}}, &options.ClientOptions)\n`;
+            return bodyText;
+        };
+        let prolog;
+        switch (constructor.authentication.kind) {
+            case 'none':
+                if (clientOptions.kind !== 'clientOptions') {
+                    throw new CodegenError('InternalError', `unexpected client options kind ${clientOptions.kind}`);
+                }
+                prolog = emitProlog(clientOptions.name, false);
+                break;
+            case 'token':
+                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
+                ctorParams.push('credential azcore.TokenCredential');
+                paramDocs.push(helpers.formatCommentAsBulletItem('credential', { summary: 'used to authorize requests. Usually a credential from azidentity.' }));
+                switch (clientOptions.kind) {
+                    case 'clientOptions': {
+                        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/policy');
+                        const tokenPolicyOpts = '&policy.BearerTokenOptions{\n\t\t\tInsecureAllowCredentialWithHTTP: options.InsecureAllowCredentialWithHTTP,\n\t\t}';
+                        // we assume a single scope. this is enforced when adapting the data from tcgc
+                        const tokenPolicy = `\n\t\tPerCall: []policy.Policy{\n\t\truntime.NewBearerTokenPolicy(credential, []string{c.Audience + "${helpers.splitScope(constructor.authentication.scopes[0]).scope}"}, ${tokenPolicyOpts}),\n\t\t},\n`;
+                        prolog = emitProlog(clientOptions.name, true, tokenPolicy);
+                        break;
+                    }
+                    case 'parameter':
+                        // this is the ARM case
+                        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/arm');
+                        prolog = '\tcl, err := arm.NewClient(moduleName, moduleVersion, credential, options)\n';
+                        break;
+                }
+                break;
+        }
         // add client options last
-        ctorParams.push(`${client.options.name} ${helpers.formatParameterTypeName(client.options)}`);
-        paramDocs.push(helpers.formatCommentAsBulletItem(client.options.name, client.options.docs));
+        ctorParams.push(`options ${helpers.formatParameterTypeName(clientOptions)}`);
+        paramDocs.push(helpers.formatCommentAsBulletItem('options', { summary: 'Contains optional client configuration. Pass nil to accept the default values.' }));
         ctorText += `// ${constructor.name} creates a new instance of ${client.name} with the specified values.\n`;
         for (const doc of paramDocs) {
             ctorText += doc;
         }
         ctorText += `func ${constructor.name}(${ctorParams.join(', ')}) (*${client.name}, error) {\n`;
-        let clientType = 'azcore';
-        if (azureARM) {
-            clientType = 'arm';
-        }
-        ctorText += `\tcl, err := ${clientType}.NewClient(moduleName, moduleVersion, credential, options)\n`;
+        ctorText += prolog;
         ctorText += '\tif err != nil {\n';
         ctorText += '\t\treturn nil, err\n';
         ctorText += '\t}\n';
+        const emitClientSideDefault = function (param) {
+            if (go.isClientSideDefault(param.style)) {
+                let name;
+                if (go.isAPIVersionParameter(param)) {
+                    name = 'APIVersion';
+                }
+                else {
+                    name = ensureNameCase(param.name);
+                }
+                ctorText += `\t${param.name} := ${helpers.formatLiteralValue(param.style.defaultValue, false)}\n`;
+                ctorText += `\tif options.${name} != ${helpers.zeroValue(param)} {\n\t\t${param.name} = ${helpers.star(param.byValue)}options.${name}\n\t}\n`;
+            }
+        };
+        // handle any client-side defaults
+        if (clientOptions.kind === 'clientOptions') {
+            for (const param of clientOptions.params) {
+                emitClientSideDefault(param);
+            }
+        }
+        // construct the supplemental path and join it to the endpoint
+        if (client.instance.endpoint) {
+            for (const param of client.instance.endpoint.parameters) {
+                emitClientSideDefault(param);
+            }
+            imports.add('strings');
+            ctorText += `\thost := "${client.instance.endpoint.path}"\n`;
+            for (const param of client.instance.endpoint.parameters) {
+                ctorText += `\thost = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(param.name, param.type, imports)})\n`;
+            }
+            // the endpoint param is always the first ctor param
+            const endpointParam = client.instance.constructors[0].parameters[0];
+            ctorText += `\t${endpointParam.name} = runtime.JoinPaths(${endpointParam.name}, host)\n`;
+        }
         // construct client literal
-        ctorText += `\tclient := &${client.name}{\n`;
+        let clientVar = 'client';
+        // ensure clientVar doesn't collide with any params
+        for (const param of consolidatedCtorParams) {
+            if (param.name === clientVar) {
+                clientVar = ensureNameCase(client.name, true);
+                break;
+            }
+        }
+        ctorText += `\t${clientVar} := &${client.name}{\n`;
+        // NOTE: we don't enumerate consolidatedCtorParams here
+        // as any supplemental endpoint params are ephemeral and
+        // consumed during client construction.
         for (const parameter of values(client.parameters)) {
+            if (go.isLiteralParameter(parameter.style)) {
+                continue;
+            }
             // each client field will have a matching parameter with the same name
             ctorText += `\t\t${parameter.name}: ${parameter.name},\n`;
         }
         ctorText += '\tinternal: cl,\n';
         ctorText += '\t}\n';
-        ctorText += '\treturn client, nil\n';
+        ctorText += `\treturn ${clientVar}, nil\n`;
         ctorText += '}\n\n';
     }
     return ctorText;
 }
-// creates a modeled constructor for an ARM client
-function createARMClientConstructor(client, imports) {
-    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/arm');
-    const ctor = new go.Constructor(`New${client.name}`);
-    // add any modeled parameter first, which should only be the subscriptionID, then add TokenCredential
-    for (const param of client.parameters) {
-        ctor.parameters.push(param);
-    }
-    const tokenCredParam = new go.Parameter('credential', new go.QualifiedType('TokenCredential', 'github.com/Azure/azure-sdk-for-go/sdk/azcore'), 'required', true, 'client');
-    tokenCredParam.docs.summary = 'used to authorize requests. Usually a credential from azidentity.';
-    ctor.parameters.push(tokenCredParam);
-    return ctor;
-}
 // 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
@@ -305,7 +459,7 @@ function formatHeaderResponseValue(headerResp, imports, respObj, zeroResp) {
     return text;
 }
 function getZeroReturnValue(method, apiType) {
-    let returnType = `${method.responseEnvelope.name}{}`;
+    let returnType = `${method.returns.name}{}`;
     if (go.isLROMethod(method)) {
         if (apiType === 'api' || apiType === 'op') {
             // the api returns a *Poller[T]
@@ -325,10 +479,10 @@ function generateNilChecks(path, prefix = 'page') {
     }
     return checks.join(' && ');
 }
-function emitPagerDefinition(client, method, imports, injectSpans, generateFakes) {
+function emitPagerDefinition(method, imports, injectSpans, generateFakes) {
     imports.add('context');
-    let text = `runtime.NewPager(runtime.PagingHandler[${method.responseEnvelope.name}]{\n`;
-    text += `\t\tMore: func(page ${method.responseEnvelope.name}) bool {\n`;
+    let text = `runtime.NewPager(runtime.PagingHandler[${method.returns.name}]{\n`;
+    text += `\t\tMore: func(page ${method.returns.name}) bool {\n`;
     // there is no advancer for single-page pagers
     if (method.nextLinkName) {
         const nilChecks = generateNilChecks(method.nextLinkName);
@@ -339,10 +493,10 @@ function emitPagerDefinition(client, method, imports, injectSpans, generateFakes
         text += '\t\t\treturn false\n';
         text += '\t\t},\n';
     }
-    text += `\t\tFetcher: func(ctx context.Context, page *${method.responseEnvelope.name}) (${method.responseEnvelope.name}, error) {\n`;
+    text += `\t\tFetcher: func(ctx context.Context, page *${method.returns.name}) (${method.returns.name}, error) {\n`;
     const reqParams = helpers.getCreateRequestParameters(method);
     if (generateFakes) {
-        text += `\t\tctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "${client.name}.${fixUpMethodName(method)}")\n`;
+        text += `\t\tctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "${method.receiver.type.name}.${fixUpMethodName(method)}")\n`;
     }
     if (method.nextLinkName) {
         let nextLinkVar;
@@ -378,7 +532,7 @@ function emitPagerDefinition(client, method, imports, injectSpans, generateFakes
         else {
             text += 'nil)\n';
         }
-        text += `\t\t\tif err != nil {\n\t\t\t\treturn ${method.responseEnvelope.name}{}, err\n\t\t\t}\n`;
+        text += `\t\t\tif err != nil {\n\t\t\t\treturn ${method.returns.name}{}, err\n\t\t\t}\n`;
         text += `\t\t\treturn client.${method.naming.responseMethod}(resp)\n`;
         text += '\t\t\t},\n';
     }
@@ -386,14 +540,14 @@ function emitPagerDefinition(client, method, imports, injectSpans, generateFakes
         // this is the singular page case, no fetcher helper required
         text += `\t\t\treq, err := client.${method.naming.requestMethod}(${reqParams})\n`;
         text += '\t\t\tif err != nil {\n';
-        text += `\t\t\t\treturn ${method.responseEnvelope.name}{}, err\n`;
+        text += `\t\t\t\treturn ${method.returns.name}{}, err\n`;
         text += '\t\t\t}\n';
         text += '\t\t\tresp, err := client.internal.Pipeline().Do(req)\n';
         text += '\t\t\tif err != nil {\n';
-        text += `\t\t\t\treturn ${method.responseEnvelope.name}{}, err\n`;
+        text += `\t\t\t\treturn ${method.returns.name}{}, err\n`;
         text += '\t\t\t}\n';
         text += '\t\t\tif !runtime.HasStatusCode(resp, http.StatusOK) {\n';
-        text += `\t\t\t\treturn ${method.responseEnvelope.name}{}, runtime.NewResponseError(resp)\n`;
+        text += `\t\t\t\treturn ${method.returns.name}{}, runtime.NewResponseError(resp)\n`;
         text += '\t\t\t}\n';
         text += `\t\t\treturn client.${method.naming.responseMethod}(resp)\n`;
         text += '\t\t},\n';
@@ -411,14 +565,23 @@ function genApiVersionDoc(apiVersions) {
     return `//\n// Generated from API version ${apiVersions.join(', ')}\n`;
 }
 function genRespErrorDoc(method) {
-    if (!(method.responseEnvelope.result?.kind === 'headAsBooleanResult') && !go.isPageableMethod(method)) {
+    if (!(method.returns.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';
     }
     return '';
 }
-function generateOperation(client, method, imports, injectSpans, generateFakes) {
+/**
+ * returns the receiver definition for a client
+ *
+ * @param receiver the receiver for which to emit the definition
+ * @returns the receiver definition
+ */
+function getClientReceiverDefinition(receiver) {
+    return `(${receiver.name} ${receiver.byValue ? '' : '*'}${receiver.type.name})`;
+}
+function generateOperation(method, imports, injectSpans, generateFakes) {
     const params = getAPIParametersSig(method, imports);
     const returns = generateReturnsInfo(method, 'op');
     let methodName = method.name;
@@ -447,16 +610,16 @@ function generateOperation(client, method, imports, injectSpans, generateFakes)
             text += helpers.formatCommentAsBulletItem(param.name, param.docs);
         }
     }
-    text += `func (client *${client.name}) ${methodName}(${params}) (${returns.join(', ')}) {\n`;
+    text += `func ${getClientReceiverDefinition(method.receiver)} ${methodName}(${params}) (${returns.join(', ')}) {\n`;
     const reqParams = helpers.getCreateRequestParameters(method);
     if (method.kind === 'pageableMethod') {
         text += '\treturn ';
-        text += emitPagerDefinition(client, method, imports, injectSpans, generateFakes);
+        text += emitPagerDefinition(method, imports, injectSpans, generateFakes);
         text += '}\n\n';
         return text;
     }
     text += '\tvar err error\n';
-    let operationName = `"${client.name}.${fixUpMethodName(method)}"`;
+    let operationName = `"${method.receiver.type.name}.${fixUpMethodName(method)}"`;
     if (generateFakes && injectSpans) {
         text += `\tconst operationName = ${operationName}\n`;
         operationName = 'operationName';
@@ -482,8 +645,8 @@ 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?.kind === 'headAsBooleanResult' && method.responseEnvelope.headers.length === 0) {
-        text += `\treturn ${method.responseEnvelope.name}{${method.responseEnvelope.result.fieldName}: httpResp.StatusCode >= 200 && httpResp.StatusCode < 300}, nil\n`;
+    if (method.returns.result?.kind === 'headAsBooleanResult' && method.returns.headers.length === 0) {
+        text += `\treturn ${method.returns.name}{${method.returns.result.fieldName}: httpResp.StatusCode >= 200 && httpResp.StatusCode < 300}, nil\n`;
     }
     else {
         if (go.isLROMethod(method)) {
@@ -494,32 +657,32 @@ 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?.kind === 'binaryResult') {
-            text += `\treturn ${method.responseEnvelope.name}{${method.responseEnvelope.result.fieldName}: httpResp.Body}, nil\n`;
+        else if (method.returns.result?.kind === 'binaryResult') {
+            text += `\treturn ${method.returns.name}{${method.returns.result.fieldName}: httpResp.Body}, nil\n`;
         }
         else {
-            text += `\treturn ${method.responseEnvelope.name}{}, nil\n`;
+            text += `\treturn ${method.returns.name}{}, nil\n`;
         }
     }
     text += '}\n\n';
     return text;
 }
-function createProtocolRequest(azureARM, client, method, imports) {
+function createProtocolRequest(azureARM, method, imports) {
     let name = method.name;
     if (method.kind !== 'nextPageMethod') {
         name = method.naming.requestMethod;
     }
     for (const param of values(method.parameters)) {
-        if (param.location !== 'method' || !go.isRequiredParameter(param)) {
+        if (param.location !== 'method' || !go.isRequiredParameter(param.style)) {
             continue;
         }
         imports.addImportForType(param.type);
     }
     const returns = ['*policy.Request', 'error'];
     let text = `${comment(name, '// ')} creates the ${method.name} request.\n`;
-    text += `func (client *${client.name}) ${name}(${helpers.getCreateRequestParametersSig(method)}) (${returns.join(', ')}) {\n`;
+    text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(${helpers.getCreateRequestParametersSig(method)}) (${returns.join(', ')}) {\n`;
     const hostParams = new Array();
-    for (const parameter of client.parameters) {
+    for (const parameter of method.receiver.type.parameters) {
         if (parameter.kind === 'uriParam') {
             hostParams.push(parameter);
         }
@@ -528,10 +691,10 @@ function createProtocolRequest(azureARM, client, method, imports) {
     if (azureARM) {
         hostParam = 'client.internal.Endpoint()';
     }
-    else if (client.templatedHost) {
+    else if (method.receiver.type.instance?.kind === 'templatedHost') {
         imports.add('strings');
         // we have a templated host
-        text += `\thost := "${client.templatedHost}"\n`;
+        text += `\thost := "${method.receiver.type.instance.path}"\n`;
         // get all the host params on the client
         for (const hostParam of hostParams) {
             text += `\thost = strings.ReplaceAll(host, "{${hostParam.uriPathSegment}}", ${helpers.formatValue(`client.${hostParam.name}`, hostParam.type, imports)})\n`;
@@ -549,7 +712,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         hostParam = 'client.' + hostParams[0].name;
     }
     else {
-        throw new CodegenError('InternalError', `no host or endpoint defined for method ${client.name}.${method.name}`);
+        throw new CodegenError('InternalError', `no host or endpoint defined for method ${method.receiver.type.name}.${method.name}`);
     }
     const methodParamGroups = helpers.getMethodParamGroups(method);
     const hasPathParams = methodParamGroups.pathParams.length > 0;
@@ -565,36 +728,6 @@ function createProtocolRequest(azureARM, client, method, imports) {
         text += `\turlPath := "${method.httpPath}"\n`;
         hostParam = `runtime.JoinPaths(${hostParam}, urlPath)`;
     }
-    if (hasPathParams) {
-        // swagger defines path params, emit path and replace tokens
-        imports.add('strings');
-        // replace path parameters
-        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) {
-                return type.kind === 'constant' && type.type === 'string';
-            };
-            // TODO: https://github.com/Azure/autorest.go/issues/1593
-            if (pp.kind === 'pathScalarParam' && ((pp.type.kind === 'string' || choiceIsString(pp.type)) && pp.isEncoded)) {
-                const paramName = helpers.getParamName(pp);
-                imports.add('errors');
-                text += `\tif ${paramName} == "" {\n`;
-                text += `\t\treturn nil, errors.New("parameter ${paramName} cannot be empty")\n`;
-                text += '\t}\n';
-            }
-            let paramValue = helpers.formatParamValue(pp, imports);
-            if (pp.isEncoded) {
-                imports.add('net/url');
-                paramValue = `url.PathEscape(${helpers.formatParamValue(pp, imports)})`;
-            }
-            text += `\turlPath = strings.ReplaceAll(urlPath, "{${pp.pathSegment}}", ${paramValue})\n`;
-        }
-    }
-    text += `\treq, err := runtime.NewRequest(ctx, http.Method${capitalize(method.httpMethod)}, ${hostParam})\n`;
-    text += '\tif err != nil {\n';
-    text += '\t\treturn nil, err\n';
-    text += '\t}\n';
     // helper to build nil checks for param groups
     const emitParamGroupCheck = function (param) {
         if (!param.group) {
@@ -611,6 +744,81 @@ function createProtocolRequest(azureARM, client, method, imports) {
         }
         return `\tif ${optionalParamGroupCheck}${client}${paramGroupName}.${capitalize(param.name)} != nil {\n`;
     };
+    if (hasPathParams) {
+        // swagger defines path params, emit path and replace tokens
+        imports.add('strings');
+        // replace path parameters
+        for (const pp of methodParamGroups.pathParams) {
+            let paramValue;
+            let optionalPathSep = false;
+            if (pp.style !== 'optional') {
+                // emit check to ensure path param isn't an empty string
+                if (pp.kind === 'pathScalarParam') {
+                    const choiceIsString = function (type) {
+                        return type.kind === 'constant' && type.type === 'string';
+                    };
+                    // we only need to do this for params that have an underlying type of string
+                    if ((pp.type.kind === 'string' || choiceIsString(pp.type)) && !pp.omitEmptyStringCheck) {
+                        const paramName = helpers.getParamName(pp);
+                        imports.add('errors');
+                        text += `\tif ${paramName} == "" {\n`;
+                        text += `\t\treturn nil, errors.New("parameter ${paramName} cannot be empty")\n`;
+                        text += '\t}\n';
+                    }
+                }
+                paramValue = helpers.formatParamValue(pp, imports);
+                // for collection-based path params, we emit the empty check
+                // after calling helpers.formatParamValue as that will have the
+                // var name that contains the slice.
+                if (pp.kind === 'pathCollectionParam') {
+                    const paramName = helpers.getParamName(pp);
+                    const joinedParamName = `${paramName}Param`;
+                    text += `\t${joinedParamName} := ${paramValue}\n`;
+                    imports.add('errors');
+                    text += `\tif len(${joinedParamName}) == 0 {\n`;
+                    text += `\t\treturn nil, errors.New("parameter ${paramName} cannot be empty")\n`;
+                    text += '\t}\n';
+                    paramValue = joinedParamName;
+                }
+            }
+            else {
+                // param isn't required, so emit a local var with
+                // the correct default value, then populate it with
+                // the optional value when set.
+                paramValue = `optional${capitalize(pp.name)}`;
+                text += `\t${paramValue} := ""\n`;
+                text += emitParamGroupCheck(pp);
+                text += `\t${paramValue} = ${helpers.formatParamValue(pp, imports)}\n\t}\n`;
+                // there are two cases for optional path params.
+                //  - /foo/bar/{optional}
+                //  - /foo/bar{/optional}
+                // for the second case, we need to include a forward slash
+                if (method.httpPath[method.httpPath.indexOf(`{${pp.pathSegment}}`) - 1] !== '/') {
+                    optionalPathSep = true;
+                }
+            }
+            const emitPathEscape = function () {
+                if (pp.isEncoded) {
+                    imports.add('net/url');
+                    return `url.PathEscape(${paramValue})`;
+                }
+                return paramValue;
+            };
+            if (optionalPathSep) {
+                text += `\tif len(${paramValue}) > 0 {\n`;
+                text += `\t\t${paramValue} = "/"+${emitPathEscape()}\n`;
+                text += '\t}\n';
+            }
+            else {
+                paramValue = emitPathEscape();
+            }
+            text += `\turlPath = strings.ReplaceAll(urlPath, "{${pp.pathSegment}}", ${paramValue})\n`;
+        }
+    }
+    text += `\treq, err := runtime.NewRequest(ctx, http.Method${capitalize(method.httpMethod)}, ${hostParam})\n`;
+    text += '\tif err != nil {\n';
+    text += '\t\treturn nil, err\n';
+    text += '\t}\n';
     // add query parameters
     const encodedParams = methodParamGroups.encodedQueryParams;
     const unencodedParams = methodParamGroups.unencodedQueryParams;
@@ -619,7 +827,7 @@ function createProtocolRequest(azureARM, client, method, 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.style))) {
+        else if (go.isRequiredParameter(qp.style) || go.isLiteralParameter(qp.style) || (qp.location === 'client' && go.isClientSideDefault(qp.style))) {
             qpText = `\t${setter}\n`;
         }
         else if (qp.location === 'client' && !qp.group) {
@@ -697,7 +905,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         imports.add('strings');
         text += '\treq.Raw().URL.RawQuery = strings.Join(unencodedParams, "&")\n';
     }
-    if (method.kind !== 'nextPageMethod' && method.responseEnvelope.result?.kind === 'binaryResult') {
+    if (method.kind !== 'nextPageMethod' && method.returns.result?.kind === 'binaryResult') {
         // skip auto-body downloading for binary stream responses
         text += '\truntime.SkipBodyDownload(req)\n';
     }
@@ -733,7 +941,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
             // 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.style)) {
+        else if (go.isRequiredParameter(param.style) || go.isLiteralParameter(param.style) || go.isClientSideDefault(param.style)) {
             text += emitHeaderSet(param, '\t');
         }
         else if (param.location === 'client' && !param.group) {
@@ -785,7 +993,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
                 text += `\t\t${fieldName} *${go.getTypeDeclaration(bodyParam.type)} \`xml:"${tag}"\`\n`;
                 text += '\t}\n';
                 let addr = '&';
-                if (!go.isRequiredParameter(bodyParam) && !bodyParam.byValue) {
+                if (!go.isRequiredParameter(bodyParam.style) && !bodyParam.byValue) {
                     addr = '';
                 }
                 body = `wrapper{${fieldName}: ${addr}${body}}`;
@@ -821,7 +1029,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
                 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)) {
+            if (go.isRequiredParameter(bodyParam.style) || go.isLiteralParameter(bodyParam.style)) {
                 text += `\t${emitSetBodyWithErrCheck(setBody, contentType)}`;
                 text += '\treturn req, nil\n';
             }
@@ -834,7 +1042,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
             }
         }
         else if (bodyParam.bodyFormat === 'binary') {
-            if (go.isRequiredParameter(bodyParam)) {
+            if (go.isRequiredParameter(bodyParam.style)) {
                 text += `\t${emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${bodyParam.contentType})`, contentType)}`;
                 text += '\treturn req, nil\n';
             }
@@ -849,7 +1057,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
         else if (bodyParam.bodyFormat === 'Text') {
             imports.add('strings');
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
-            if (go.isRequiredParameter(bodyParam)) {
+            if (go.isRequiredParameter(bodyParam.style)) {
                 text += `\tbody := streaming.NopCloser(strings.NewReader(${bodyParam.name}))\n`;
                 text += `\t${emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType)}`;
                 text += '\treturn req, nil\n';
@@ -869,19 +1077,19 @@ function createProtocolRequest(azureARM, client, method, imports) {
         // define and instantiate an instance of the wire type, using the values from each param.
         text += '\tbody := struct {\n';
         for (const partialBodyParam of partialBodyParams) {
-            text += `\t\t${capitalize(partialBodyParam.serializedName)} ${helpers.star(partialBodyParam)}${go.getTypeDeclaration(partialBodyParam.type)} \`${partialBodyParam.format.toLowerCase()}:"${partialBodyParam.serializedName}"\`\n`;
+            text += `\t\t${capitalize(partialBodyParam.serializedName)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type)} \`${partialBodyParam.format.toLowerCase()}:"${partialBodyParam.serializedName}"\`\n`;
         }
         text += '\t}{\n';
         // required params are emitted as initializers in the struct literal
         for (const partialBodyParam of partialBodyParams) {
-            if (go.isRequiredParameter(partialBodyParam)) {
+            if (go.isRequiredParameter(partialBodyParam.style)) {
                 text += `\t\t${capitalize(partialBodyParam.serializedName)}: ${uncapitalize(partialBodyParam.name)},\n`;
             }
         }
         text += '\t}\n';
         // now populate any optional params from the options type
         for (const partialBodyParam of partialBodyParams) {
-            if (!go.isRequiredParameter(partialBodyParam)) {
+            if (!go.isRequiredParameter(partialBodyParam.style)) {
                 text += emitParamGroupCheck(partialBodyParam);
                 text += `\t\tbody.${capitalize(partialBodyParam.serializedName)} = options.${capitalize(partialBodyParam.name)}\n\t}\n`;
             }
@@ -900,7 +1108,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
             text += '\tformData := map[string]any{}\n';
             for (const param of multipartBodyParams) {
                 const setter = `formData["${param.name}"] = ${helpers.getParamName(param)}`;
-                if (go.isRequiredParameter(param)) {
+                if (go.isRequiredParameter(param.style)) {
                     text += `\t${setter}\n`;
                 }
                 else {
@@ -915,7 +1123,7 @@ function createProtocolRequest(azureARM, client, method, imports) {
     else if (formBodyParams.length > 0) {
         const emitFormData = function (param, setter) {
             let formDataText = '';
-            if (go.isRequiredParameter(param)) {
+            if (go.isRequiredParameter(param.style)) {
                 formDataText = `\t${setter}\n`;
             }
             else {
@@ -997,7 +1205,7 @@ function isArrayOfDateTimeForMarshalling(paramType) {
 // returns true if the method requires a response handler.
 // this is used to unmarshal the response body, parse response headers, or both.
 function needsResponseHandler(method) {
-    return helpers.hasSchemaResponse(method) || method.responseEnvelope.headers.length > 0;
+    return helpers.hasSchemaResponse(method) || method.returns.headers.length > 0;
 }
 function generateResponseUnmarshaller(method, type, format, unmarshalTarget) {
     let unmarshallerText = '';
@@ -1065,34 +1273,34 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget) {
     }
     else {
         // the remaining formats should have been handled elsewhere
-        throw new CodegenError('InternalError', `unhandled format ${format} for operation ${method.client.name}.${method.name}`);
+        throw new CodegenError('InternalError', `unhandled format ${format} for operation ${method.receiver.type.name}.${method.name}`);
     }
     return unmarshallerText;
 }
-function createProtocolResponse(client, method, imports) {
+function createProtocolResponse(method, imports) {
     if (!needsResponseHandler(method)) {
         return '';
     }
     const name = method.naming.responseMethod;
     let text = `${comment(name, '// ')} handles the ${method.name} response.\n`;
-    text += `func (client *${client.name}) ${name}(resp *http.Response) (${generateReturnsInfo(method, 'handler').join(', ')}) {\n`;
+    text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(resp *http.Response) (${generateReturnsInfo(method, 'handler').join(', ')}) {\n`;
     const addHeaders = function (headers) {
         for (const header of values(headers)) {
-            text += formatHeaderResponseValue(header, imports, 'result', `${method.responseEnvelope.name}{}`);
+            text += formatHeaderResponseValue(header, imports, 'result', `${method.returns.name}{}`);
         }
     };
-    const result = method.responseEnvelope.result;
+    const result = method.returns.result;
     if (!result) {
         // only headers
-        text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-        addHeaders(method.responseEnvelope.headers);
+        text += `\tresult := ${method.returns.name}{}\n`;
+        addHeaders(method.returns.headers);
     }
     else {
         switch (result.kind) {
             case 'anyResult':
                 imports.add('fmt');
-                text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-                addHeaders(method.responseEnvelope.headers);
+                text += `\tresult := ${method.returns.name}{}\n`;
+                addHeaders(method.returns.headers);
                 text += '\tswitch resp.StatusCode {\n';
                 for (const statusCode of method.httpStatusCodes) {
                     text += `\tcase ${helpers.formatStatusCodes([statusCode])}:\n`;
@@ -1110,21 +1318,21 @@ function createProtocolResponse(client, method, imports) {
                 text += '\t}\n';
                 break;
             case 'binaryResult':
-                text += `\tresult := ${method.responseEnvelope.name}{${result.fieldName}: resp.Body}\n`;
-                addHeaders(method.responseEnvelope.headers);
+                text += `\tresult := ${method.returns.name}{${result.fieldName}: resp.Body}\n`;
+                addHeaders(method.returns.headers);
                 break;
             case 'headAsBooleanResult':
-                text += `\tresult := ${method.responseEnvelope.name}{${result.fieldName}: resp.StatusCode >= 200 && resp.StatusCode < 300}\n`;
-                addHeaders(method.responseEnvelope.headers);
+                text += `\tresult := ${method.returns.name}{${result.fieldName}: resp.StatusCode >= 200 && resp.StatusCode < 300}\n`;
+                addHeaders(method.returns.headers);
                 break;
             case 'modelResult':
-                text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-                addHeaders(method.responseEnvelope.headers);
+                text += `\tresult := ${method.returns.name}{}\n`;
+                addHeaders(method.returns.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);
+                text += `\tresult := ${method.returns.name}{}\n`;
+                addHeaders(method.returns.headers);
                 let target = `result.${helpers.getResultFieldName(method)}`;
                 // when unmarshalling a wrapped XML array, unmarshal into the response envelope
                 if (result.format === 'XML' && result.monomorphicType.kind === 'slice') {
@@ -1133,8 +1341,8 @@ function createProtocolResponse(client, method, imports) {
                 text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target);
                 break;
             case 'polymorphicResult':
-                text += `\tresult := ${method.responseEnvelope.name}{}\n`;
-                addHeaders(method.responseEnvelope.headers);
+                text += `\tresult := ${method.returns.name}{}\n`;
+                addHeaders(method.returns.headers);
                 text += generateResponseUnmarshaller(method, result.interface, result.format, 'result');
                 break;
             default:
@@ -1187,7 +1395,7 @@ function getAPIParametersSig(method, imports, pkgName) {
 //    op - for the operation
 // handler - for the response handler
 function generateReturnsInfo(method, apiType) {
-    let returnType = method.responseEnvelope.name;
+    let returnType = method.returns.name;
     switch (method.kind) {
         case 'lroMethod':
         case 'lroPageableMethod':
@@ -1222,7 +1430,7 @@ function generateReturnsInfo(method, apiType) {
     }
     return [returnType, 'error'];
 }
-function generateLROBeginMethod(client, method, imports, injectSpans, generateFakes) {
+function generateLROBeginMethod(method, imports, injectSpans, generateFakes) {
     const params = getAPIParametersSig(method, imports);
     const returns = generateReturnsInfo(method, 'api');
     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime');
@@ -1237,15 +1445,15 @@ function generateLROBeginMethod(client, method, imports, injectSpans, generateFa
     for (const param of values(methodParams)) {
         text += helpers.formatCommentAsBulletItem(param.name, param.docs);
     }
-    text += `func (client *${client.name}) ${fixUpMethodName(method)}(${params}) (${returns.join(', ')}) {\n`;
+    text += `func ${getClientReceiverDefinition(method.receiver)} ${fixUpMethodName(method)}(${params}) (${returns.join(', ')}) {\n`;
     let pollerType = 'nil';
-    let pollerTypeParam = `[${method.responseEnvelope.name}]`;
+    let pollerTypeParam = `[${method.returns.name}]`;
     if (method.kind === 'lroPageableMethod') {
         // for paged LROs, we construct a pager and pass it to the LRO ctor.
         pollerTypeParam = `[*runtime.Pager${pollerTypeParam}]`;
         pollerType = '&pager';
         text += '\tpager := ';
-        text += emitPagerDefinition(client, method, imports, injectSpans, generateFakes);
+        text += emitPagerDefinition(method, imports, injectSpans, generateFakes);
     }
     text += '\tif options == nil || options.ResumeToken == "" {\n';
     // creating the poller from response branch