@azure-tools/typespec-go 0.5.0 → 0.5.1

package/dist/codegen.go/src/fake/servers.js

@@ -98,7 +98,7 @@ export async function generateServers(codeModel) {
             const operationName = fixUpMethodName(method);
             content += `\t// ${operationName} is the fake for method ${client.name}.${operationName}\n`;
             const successCodes = new Array();
-            if (method.responseEnvelope.result && go.isAnyResult(method.responseEnvelope.result)) {
+            if (method.responseEnvelope.result?.kind === 'anyResult') {
                 for (const httpStatus of getMethodStatusCodes(method)) {
                     const result = method.responseEnvelope.result.httpStatusCodeType[httpStatus];
                     if (!result) {
@@ -322,19 +322,19 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
                 const formattedStatusCodes = helpers.formatStatusCodes(method.httpStatusCodes);
                 content += `\tif !contains([]int{${formattedStatusCodes}}, respContent.HTTPStatus) {\n`;
                 content += `\t\treturn nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are ${formattedStatusCodes}", respContent.HTTPStatus)}\n\t}\n`;
-                if (!method.responseEnvelope.result || go.isHeadAsBooleanResult(method.responseEnvelope.result)) {
+                if (!method.responseEnvelope.result || method.responseEnvelope.result.kind === 'headAsBooleanResult') {
                     content += '\tresp, err := server.NewResponse(respContent, req, nil)\n';
                 }
-                else if (go.isAnyResult(method.responseEnvelope.result)) {
+                else if (method.responseEnvelope.result.kind === 'anyResult') {
                     content += `\tresp, err := server.MarshalResponseAs${method.responseEnvelope.result.format}(respContent, server.GetResponse(respr).${getResultFieldName(method.responseEnvelope.result)}, req)\n`;
                 }
-                else if (go.isBinaryResult(method.responseEnvelope.result)) {
+                else if (method.responseEnvelope.result.kind === 'binaryResult') {
                     content += '\tresp, err := server.NewResponse(respContent, req, &server.ResponseOptions{\n';
                     content += `\t\tBody: server.GetResponse(respr).${getResultFieldName(method.responseEnvelope.result)},\n`;
                     content += '\t\tContentType: req.Header.Get("Content-Type"),\n';
                     content += '\t})\n';
                 }
-                else if (go.isMonomorphicResult(method.responseEnvelope.result)) {
+                else if (method.responseEnvelope.result.kind === 'monomorphicResult') {
                     if (go.isBytesType(method.responseEnvelope.result.monomorphicType)) {
                         const encoding = method.responseEnvelope.result.monomorphicType.encoding;
                         content += `\tresp, err := server.MarshalResponseAsByteArray(respContent, server.GetResponse(respr).${getResultFieldName(method.responseEnvelope.result)}, runtime.Base64${encoding}Format, req)\n`;
@@ -359,7 +359,7 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
                         content += `\tresp, err := server.MarshalResponseAs${method.responseEnvelope.result.format}(respContent, ${responseField}, req)\n`;
                     }
                 }
-                else if (go.isModelResult(method.responseEnvelope.result) || go.isPolymorphicResult(method.responseEnvelope.result)) {
+                else if (method.responseEnvelope.result.kind === 'modelResult' || method.responseEnvelope.result.kind === 'polymorphicResult') {
                     const respField = `.${getResultFieldName(method.responseEnvelope.result)}`;
                     const responseField = `server.GetResponse(respr)${respField}`;
                     content += `\tresp, err := server.MarshalResponseAs${method.responseEnvelope.result.format}(respContent, ${responseField}, req)\n`;
@@ -367,10 +367,10 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
                 content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
                 // propagate any header response values into the *http.Response
                 for (const header of values(method.responseEnvelope.headers)) {
-                    if (go.isHeaderMapResponse(header)) {
+                    if (header.kind === 'headerMapResponse') {
                         content += `\tfor k, v := range server.GetResponse(respr).${header.fieldName} {\n`;
                         content += '\t\tif v != nil {\n';
-                        content += `\t\t\tresp.Header.Set("${header.collectionPrefix}"+k, *v)\n`;
+                        content += `\t\t\tresp.Header.Set("${header.headerName}"+k, *v)\n`;
                         content += '\t\t}\n';
                         content += '\t}\n';
                     }
@@ -393,11 +393,12 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
     return content;
 }
 function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
-    const numPathParams = values(method.parameters).where((each) => { return go.isPathParameter(each) && !go.isLiteralParameter(each); }).count();
+    const methodParamGroups = helpers.getMethodParamGroups(method);
+    const numPathParams = values(methodParamGroups.pathParams).where((each) => { return !go.isLiteralParameter(each); }).count();
     let content = '';
     if (numPathParams > 0) {
         imports.add('regexp');
-        content += `\tconst regexStr = \`${createPathParamsRegex(method)}\`\n`;
+        content += `\tconst regexStr = \`${createPathParamsRegex(method, methodParamGroups.pathParams)}\`\n`;
         content += '\tregex := regexp.MustCompile(regexStr)\n';
         content += '\tmatches := regex.FindStringSubmatch(req.URL.EscapedPath())\n';
         // the total number of matches is the number of capture groups
@@ -405,30 +406,70 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         content += `\tif len(matches) < ${numPathParams + 1} {\n`;
         content += '\t\treturn nil, fmt.Errorf("failed to parse path %s", req.URL.Path)\n\t}\n';
     }
-    if (values(method.parameters).where((each) => { return go.isQueryParameter(each) && each.location === 'method' && !go.isLiteralParameter(each); }).any()) {
+    const allQueryParams = methodParamGroups.encodedQueryParams.concat(methodParamGroups.unencodedQueryParams);
+    if (values(allQueryParams).where((each) => { return each.location === 'method' && !go.isLiteralParameter(each); }).any()) {
         content += '\tqp := req.URL.Query()\n';
     }
-    const bodyParam = values(method.parameters).where((each) => {
-        return go.isBodyParameter(each) || go.isFormBodyParameter(each) || go.isMultipartFormBodyParameter(each) || go.isPartialBodyParameter(each);
-    }).first();
-    if (!bodyParam) {
-        // no body, just headers and/or query params
+    // note that these are mutually exclusive
+    const bodyParam = methodParamGroups.bodyParam;
+    const formBodyParams = methodParamGroups.formBodyParams;
+    const multipartBodyParams = methodParamGroups.multipartBodyParams;
+    const partialBodyParams = methodParamGroups.partialBodyParams;
+    if (bodyParam) {
+        switch (bodyParam.bodyFormat) {
+            case 'JSON':
+            case 'XML':
+                if (bodyParam && !go.isLiteralParameter(bodyParam)) {
+                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
+                    if (go.isBytesType(bodyParam.type)) {
+                        content += `\tbody, err := server.UnmarshalRequestAsByteArray(req, runtime.Base64${bodyParam.type.encoding}Format)\n`;
+                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                    }
+                    else if (go.isSliceType(bodyParam.type) && bodyParam.type.rawJSONAsBytes) {
+                        content += '\tbody, err := io.ReadAll(req.Body)\n';
+                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                        content += '\treq.Body.Close()\n';
+                    }
+                    else if (go.isInterfaceType(bodyParam.type)) {
+                        requiredHelpers.readRequestBody = true;
+                        content += '\traw, err := readRequestBody(req)\n';
+                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                        content += `\tbody, err := unmarshal${bodyParam.type.name}(raw)\n`;
+                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                    }
+                    else {
+                        let bodyTypeName = go.getTypeDeclaration(bodyParam.type, clientPkg);
+                        if (go.isTimeType(bodyParam.type)) {
+                            bodyTypeName = bodyParam.type.dateTimeFormat;
+                        }
+                        content += `\tbody, err := server.UnmarshalRequestAs${bodyParam.bodyFormat}[${bodyTypeName}](req)\n`;
+                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                    }
+                }
+                break;
+            case 'Text':
+                if (bodyParam && !go.isLiteralParameter(bodyParam)) {
+                    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
+                    content += '\tbody, err := server.UnmarshalRequestAsText(req)\n';
+                    content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                }
+                break;
+        }
+        // nothing to do for binary media type
     }
-    else if (go.isMultipartFormBodyParameter(bodyParam)) {
+    else if (multipartBodyParams.length > 0) {
         imports.add('io');
         imports.add('mime');
         imports.add('mime/multipart');
         content += '\t_, params, err := mime.ParseMediaType(req.Header.Get("Content-Type"))\n';
         content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         content += '\treader := multipart.NewReader(req.Body, params["boundary"])\n';
-        for (const param of values(method.parameters)) {
-            if (go.isMultipartFormBodyParameter(param)) {
-                let pkgPrefix = '';
-                if (go.isConstantType(param.type) || go.isModelType(param.type)) {
-                    pkgPrefix = clientPkg + '.';
-                }
-                content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
+        for (const param of multipartBodyParams) {
+            let pkgPrefix = '';
+            if (go.isConstantType(param.type) || go.isModelType(param.type)) {
+                pkgPrefix = clientPkg + '.';
             }
+            content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
         }
         content += '\tfor {\n';
         content += '\t\tvar part *multipart.Part\n';
@@ -567,95 +608,49 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
             }
             return caseContent;
         };
-        for (const param of values(method.parameters)) {
-            if (go.isMultipartFormBodyParameter(param)) {
-                if (go.isModelType(param.type)) {
-                    for (const field of param.type.fields) {
-                        content += emitCase(field.serializedName, `${param.name}.${field.name}`, field.type);
-                    }
-                }
-                else {
-                    content += emitCase(param.name, param.name, param.type);
+        for (const param of multipartBodyParams) {
+            if (go.isModelType(param.type)) {
+                for (const field of param.type.fields) {
+                    content += emitCase(field.serializedName, `${param.name}.${field.name}`, field.type);
                 }
             }
+            else {
+                content += emitCase(param.name, param.name, param.type);
+            }
         }
         content += '\t\tdefault:\n\t\t\treturn nil, fmt.Errorf("unexpected part %s", fn)\n';
         content += '\t\t}\n'; // end switch
         content += '\t}\n'; // end for
     }
-    else if (go.isFormBodyParameter(bodyParam)) {
-        for (const param of values(method.parameters)) {
-            if (go.isFormBodyParameter(param)) {
-                let pkgPrefix = '';
-                if (go.isConstantType(param.type)) {
-                    pkgPrefix = clientPkg + '.';
-                }
-                content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
+    else if (formBodyParams.length > 0) {
+        for (const param of formBodyParams) {
+            let pkgPrefix = '';
+            if (go.isConstantType(param.type)) {
+                pkgPrefix = clientPkg + '.';
             }
+            content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
         }
         content += '\tif err := req.ParseForm(); err != nil {\n\t\treturn nil, &nonRetriableError{fmt.Errorf("failed parsing form data: %v", err)}\n\t}\n';
         content += '\tfor key := range req.Form {\n';
         content += '\t\tswitch key {\n';
-        for (const param of values(method.parameters)) {
-            if (go.isFormBodyParameter(param)) {
-                content += `\t\tcase "${param.formDataName}":\n`;
-                let assignedValue;
-                if (go.isConstantType(param.type)) {
-                    assignedValue = `${go.getTypeDeclaration(param.type, clientPkg)}(req.FormValue(key))`;
-                }
-                else if (go.isPrimitiveType(param.type) && param.type.typeName === 'string') {
-                    assignedValue = 'req.FormValue(key)';
-                }
-                else {
-                    throw new CodegenError('InternalError', `uhandled form parameter type ${go.getTypeDeclaration(param.type)}`);
-                }
-                content += `\t\t\t${param.name} = ${assignedValue}\n`;
-            }
-        }
-        content += '\t\t}\n'; // end switch
-        content += '\t}\n'; // end for
-    }
-    else if (bodyParam.bodyFormat === 'binary') {
-        // nothing to do for binary media type
-    }
-    else if (bodyParam.bodyFormat === 'Text') {
-        if (bodyParam && !go.isLiteralParameter(bodyParam)) {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
-            content += '\tbody, err := server.UnmarshalRequestAsText(req)\n';
-            content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-        }
-    }
-    else if (bodyParam.bodyFormat === 'JSON' || bodyParam.bodyFormat === 'XML') {
-        if (bodyParam && !go.isLiteralParameter(bodyParam)) {
-            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
-            if (go.isBytesType(bodyParam.type)) {
-                content += `\tbody, err := server.UnmarshalRequestAsByteArray(req, runtime.Base64${bodyParam.type.encoding}Format)\n`;
-                content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-            }
-            else if (go.isSliceType(bodyParam.type) && bodyParam.type.rawJSONAsBytes) {
-                content += '\tbody, err := io.ReadAll(req.Body)\n';
-                content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-                content += '\treq.Body.Close()\n';
+        for (const param of formBodyParams) {
+            content += `\t\tcase "${param.formDataName}":\n`;
+            let assignedValue;
+            if (go.isConstantType(param.type)) {
+                assignedValue = `${go.getTypeDeclaration(param.type, clientPkg)}(req.FormValue(key))`;
             }
-            else if (go.isInterfaceType(bodyParam.type)) {
-                requiredHelpers.readRequestBody = true;
-                content += '\traw, err := readRequestBody(req)\n';
-                content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-                content += `\tbody, err := unmarshal${bodyParam.type.name}(raw)\n`;
-                content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+            else if (go.isPrimitiveType(param.type) && param.type.typeName === 'string') {
+                assignedValue = 'req.FormValue(key)';
             }
             else {
-                let bodyTypeName = go.getTypeDeclaration(bodyParam.type, clientPkg);
-                if (go.isTimeType(bodyParam.type)) {
-                    bodyTypeName = bodyParam.type.dateTimeFormat;
-                }
-                content += `\tbody, err := server.UnmarshalRequestAs${bodyParam.bodyFormat}[${bodyTypeName}](req)\n`;
-                content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                throw new CodegenError('InternalError', `uhandled form parameter type ${go.getTypeDeclaration(param.type)}`);
             }
+            content += `\t\t\t${param.name} = ${assignedValue}\n`;
         }
+        content += '\t\t}\n'; // end switch
+        content += '\t}\n'; // end for
     }
-    const partialBodyParams = values(method.parameters).where((param) => { return go.isPartialBodyParameter(param); }).toArray();
-    if (partialBodyParams.length > 0) {
+    else if (partialBodyParams.length > 0) {
         // construct the partial body params type and unmarshal it
         content += '\ttype partialBodyParams struct {\n';
         for (const partialBodyParam of partialBodyParams) {
@@ -751,7 +746,7 @@ function sanitizeRegexpCaptureGroupName(name) {
     // dash '-' characters are not allowed so replace them with '_'
     return name.replace('-', '_');
 }
-function createPathParamsRegex(method) {
+function createPathParamsRegex(method, pathParams) {
     // "/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}"
     // each path param will replaced with a regex capture.
     // note that some path params are optional.
@@ -760,10 +755,7 @@ function createPathParamsRegex(method) {
     // per RFC3986, these are the pchars that also double as regex tokens
     // . $ * + ()
     urlPath = urlPath.replace(/([.$*+()])/g, '\\$1');
-    for (const param of values(method.parameters)) {
-        if (!go.isPathParameter(param)) {
-            continue;
-        }
+    for (const param of pathParams) {
         const toReplace = `{${param.pathSegment}}`;
         let replaceWith = `(?P<${sanitizeRegexpCaptureGroupName(param.pathSegment)}>[!#&$-;=?-\\[\\]_a-zA-Z0-9~%@]+)`;
         if (param.style === 'optional' || param.style === 'flag') {
@@ -805,22 +797,28 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             // client params and parameter literals aren't passed to APIs
             continue;
         }
-        if (go.isResumeTokenParameter(param)) {
+        if (param.kind === 'resumeTokenParam') {
             // skip the ResumeToken param as we don't send that back to the caller
             continue;
         }
         // NOTE: param group check must happen before skipping body params.
         // this is to handle the case where the body param is grouped/optional
         if (param.group) {
-            if (!paramGroups.has(param.group)) {
-                paramGroups.set(param.group, new Array());
+            let params = paramGroups.get(param.group);
+            if (!params) {
+                params = new Array();
+                paramGroups.set(param.group, params);
             }
-            const params = paramGroups.get(param.group);
             params.push(param);
         }
-        if (go.isBodyParameter(param) || go.isFormBodyParameter(param) || go.isMultipartFormBodyParameter(param) || go.isPartialBodyParameter(param)) {
-            // body params will be unmarshalled, no need for parsing.
-            continue;
+        switch (param.kind) {
+            case 'bodyParam':
+            case 'formBodyCollectionParam':
+            case 'formBodyScalarParam':
+            case 'multipartFormBodyParam':
+            case 'partialBodyParam':
+                // body params will be unmarshalled, no need for parsing.
+                continue;
         }
         // paramValue is initialized with the "raw" source value.
         // e.g. getHeaderValue(...), qp.Get("foo") etc
@@ -830,7 +828,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
         let paramValue = getRawParamValue(param);
         // path/query params might be escaped, so we need to unescape them first.
         // must handle query collections first as it's a superset of query param.
-        if (go.isQueryCollectionParameter(param) && param.collectionFormat === 'multi') {
+        if (param.kind === 'queryCollectionParam' && param.collectionFormat === 'multi') {
             imports.add('net/url');
             const escapedParam = createLocalVariableName(param, 'Escaped');
             content += `\t${escapedParam} := ${paramValue}\n`;
@@ -882,7 +880,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             paramValue = paramVar;
         }
         // parse params as required
-        if (go.isHeaderCollectionParameter(param) || go.isPathCollectionParameter(param) || go.isQueryCollectionParameter(param)) {
+        if (param.kind === 'headerCollectionParam' || param.kind === 'pathCollectionParam' || param.kind === 'queryCollectionParam') {
             // any element type other than string will require some form of conversion/parsing
             if (!(go.isPrimitiveType(param.type.elementType) && param.type.elementType.typeName === 'string')) {
                 if (param.collectionFormat !== 'multi') {
@@ -1057,13 +1055,13 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             }
             content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         }
-        else if (go.isHeaderMapParameter(param)) {
+        else if (param.kind === 'headerMapParam') {
             imports.add('strings');
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
             const localVar = createLocalVariableName(param, 'Param');
             content += `\tvar ${localVar} map[string]*string\n`;
             content += `\tfor hh := range ${paramValue} {\n`;
-            const headerPrefix = param.collectionPrefix;
+            const headerPrefix = param.headerName;
             requiredHelpers.getHeaderValue = true;
             content += `\t\tif len(hh) > len("${headerPrefix}") && strings.EqualFold(hh[:len("x-ms-meta-")], "${headerPrefix}") {\n`;
             content += `\t\t\tif ${localVar} == nil {\n\t\t\t\t${localVar} = map[string]*string{}\n\t\t\t}\n`;
@@ -1126,7 +1124,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 if (go.isSliceType(param.type)) {
                     paramNilCheck.push(`len(${getFinalParamValue(clientPkg, param, paramValues)}) > 0`);
                 }
-                else if (go.isBodyParameter(param)) {
+                else if (param.kind === 'bodyParam') {
                     if (param.bodyFormat === 'binary') {
                         imports.add('io');
                         paramNilCheck.push('req.Body != nil');
@@ -1136,7 +1134,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                         paramNilCheck.push('!reflect.ValueOf(body).IsZero()');
                     }
                 }
-                else if (go.isFormBodyParameter(param) || go.isMultipartFormBodyParameter(param)) {
+                else if (go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') {
                     imports.add('reflect');
                     paramNilCheck.push(`!reflect.ValueOf(${param.name}).IsZero()`);
                 }
@@ -1148,7 +1146,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             content += `\t\t${uncapitalize(paramGroup.name)} = &${clientPkg}.${paramGroup.groupName}{\n`;
             for (const param of values(params)) {
                 let byRef = '&';
-                if (param.byValue || (!go.isRequiredParameter(param) && !go.isBodyParameter(param) && !go.isFormBodyParameter(param) && !go.isMultipartFormBodyParameter(param))) {
+                if (param.byValue || (!go.isRequiredParameter(param) && param.kind !== 'bodyParam' && !go.isFormBodyParameter(param) && param.kind !== 'multipartFormBodyParam')) {
                     byRef = '';
                 }
                 content += `\t\t\t${capitalize(param.name)}: ${byRef}${getFinalParamValue(clientPkg, param, paramValues)},\n`;
@@ -1174,10 +1172,10 @@ function populateApiParams(clientPkg, method, paramValues, imports) {
     }
     // now create the API call sig
     for (const param of values(helpers.getMethodParameters(method, consolidateHostParams))) {
-        if (helpers.isParameterGroup(param)) {
+        if (param.kind === 'paramGroup') {
             if (param.groupName === method.optionalParamsGroup.groupName) {
                 // this is the optional params type. in some cases we just pass nil
-                const countParams = values(param.params).where((each) => { return !go.isResumeTokenParameter(each); }).count();
+                const countParams = values(param.params).where((each) => { return each.kind !== 'resumeTokenParam'; }).count();
                 if (countParams === 0) {
                     // if the options param is empty or only contains the resume token param just pass nil
                     params.push('nil');
@@ -1197,43 +1195,42 @@ function populateApiParams(clientPkg, method, paramValues, imports) {
 // getRawParamValue returns the "raw" value for the specified parameter.
 // depending on the type, the value might require parsing before it can be passed to the fake.
 function getRawParamValue(param) {
-    if (go.isFormBodyParameter(param) || go.isMultipartFormBodyParameter(param) || go.isPartialBodyParameter(param)) {
-        // multipart form data values have been read and assigned
-        // to local params with the same name. must check this first
-        // as it's a superset of other cases that follow.
-        return param.name;
-    }
-    else if (go.isPathParameter(param)) {
-        // path params are in the matches slice
-        return `matches[regex.SubexpIndex("${sanitizeRegexpCaptureGroupName(param.pathSegment)}")]`;
-    }
-    else if (go.isQueryParameter(param)) {
-        // use qp
-        if (go.isQueryCollectionParameter(param) && param.collectionFormat === 'multi') {
-            return `qp["${param.queryParameter}"]`;
-        }
-        return `qp.Get("${param.queryParameter}")`;
-    }
-    else if (go.isHeaderParameter(param)) {
-        if (go.isHeaderMapParameter(param)) {
+    switch (param.kind) {
+        case 'bodyParam':
+            if (param.bodyFormat === 'binary') {
+                return 'req.Body.(io.ReadSeekCloser)';
+            }
+            // JSON/XML/text bodies have been deserialized into a local named body
+            return 'body';
+        case 'formBodyCollectionParam':
+        case 'formBodyScalarParam':
+        case 'multipartFormBodyParam':
+        case 'partialBodyParam':
+            // multipart form data values have been read and assigned
+            // to local params with the same name.
+            return param.name;
+        case 'headerCollectionParam':
+        case 'headerScalarParam':
+            // use req
+            requiredHelpers.getHeaderValue = true;
+            return `getHeaderValue(req.Header, "${param.headerName}")`;
+        case 'headerMapParam':
             return 'req.Header';
-        }
-        // use req
-        requiredHelpers.getHeaderValue = true;
-        return `getHeaderValue(req.Header, "${param.headerName}")`;
-    }
-    else if (go.isBodyParameter(param)) {
-        if (param.bodyFormat === 'binary') {
-            return 'req.Body.(io.ReadSeekCloser)';
-        }
-        // JSON/XML/text bodies have been deserialized into a local named body
-        return 'body';
-    }
-    else if (go.isURIParameter(param)) {
-        return 'req.URL.Host';
-    }
-    else {
-        throw new CodegenError('InternalError', `unhandled parameter ${param.name}`);
+        case 'pathCollectionParam':
+        case 'pathScalarParam':
+            // path params are in the matches slice
+            return `matches[regex.SubexpIndex("${sanitizeRegexpCaptureGroupName(param.pathSegment)}")]`;
+        case 'queryCollectionParam':
+        case 'queryScalarParam':
+            // use qp
+            if (param.kind === 'queryCollectionParam' && param.collectionFormat === 'multi') {
+                return `qp["${param.queryParameter}"]`;
+            }
+            return `qp.Get("${param.queryParameter}")`;
+        case 'uriParam':
+            return 'req.URL.Host';
+        default:
+            throw new CodegenError('InternalError', `unhandled parameter ${param.name}`);
     }
 }
 // getFinalParamValue returns the "final" value of param to be passed to the fake.
@@ -1244,13 +1241,13 @@ function getFinalParamValue(clientPkg, param, paramValues) {
         paramValue = getRawParamValue(param);
     }
     // there are a few corner-cases that require some fix-ups
-    if ((go.isBodyParameter(param) || go.isFormBodyParameter(param) || go.isFormBodyCollectionParameter(param) || go.isMultipartFormBodyParameter(param)) && go.isTimeType(param.type)) {
+    if ((param.kind === 'bodyParam' || go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') && go.isTimeType(param.type)) {
         // time types in the body have been unmarshalled into our time helpers thus require a cast to time.Time
         return `time.Time(${paramValue})`;
     }
     else if (go.isRequiredParameter(param)) {
         // optional params are always in their "final" form
-        if (go.isHeaderCollectionParameter(param) || go.isPathCollectionParameter(param) || go.isQueryCollectionParameter(param)) {
+        if (param.kind === 'headerCollectionParam' || param.kind === 'pathCollectionParam' || param.kind === 'queryCollectionParam') {
             // for required params that are collections of strings, we split them inline.
             // not necessary for optional params as they're already in slice format.
             if (param.collectionFormat !== 'multi' && go.isPrimitiveType(param.type.elementType) && param.type.elementType.typeName === 'string') {
@@ -1263,7 +1260,7 @@ function getFinalParamValue(clientPkg, param, paramValues) {
             return `${go.getTypeDeclaration(param.type, clientPkg)}(${paramValue})`;
         }
     }
-    else if (go.isPartialBodyParameter(param)) {
+    else if (param.kind === 'partialBodyParam') {
         // use the value from the unmarshaled, intermediate struct type
         return `body.${capitalize(param.name)}`;
     }
@@ -1275,7 +1272,7 @@ function getFinalParamValue(clientPkg, param, paramValues) {
 // there's no way to reliably split the host back up into its constituent parameters.
 // so we just pass the full value as a single host parameter.
 function consolidateHostParams(params) {
-    if (!values(params).where((each) => { return go.isURIParameter(each); }).any()) {
+    if (!values(params).where((each) => { return each.kind === 'uriParam'; }).any()) {
         // no host params
         return params;
     }
@@ -1283,7 +1280,7 @@ function consolidateHostParams(params) {
     const consolidatedParams = new Array();
     let hostParamAdded = false;
     for (const param of values(params)) {
-        if (!go.isURIParameter(param)) {
+        if (param.kind !== 'uriParam') {
             consolidatedParams.push(param);
         }
         else if (!hostParamAdded) {
@@ -1303,7 +1300,7 @@ function getAPIParametersSig(method, imports, pkgName) {
     }
     for (const methodParam of values(methodParams)) {
         let paramName = uncapitalize(methodParam.name);
-        if (helpers.isParameter(methodParam) && go.isURIParameter(methodParam)) {
+        if (methodParam.kind === 'uriParam') {
             paramName = 'host';
         }
         params.push(`${paramName} ${helpers.formatParameterTypeName(methodParam, pkgName)}`);
@@ -1312,15 +1309,15 @@ function getAPIParametersSig(method, imports, pkgName) {
 }
 // copied from generator/helpers.ts but without the XML-specific stuff
 function getResultFieldName(result) {
-    if (go.isAnyResult(result)) {
-        return result.fieldName;
-    }
-    else if (go.isModelResult(result)) {
-        return result.modelType.name;
-    }
-    else if (go.isPolymorphicResult(result)) {
-        return result.interfaceType.name;
+    switch (result.kind) {
+        case 'anyResult':
+            return result.fieldName;
+        case 'modelResult':
+            return result.modelType.name;
+        case 'polymorphicResult':
+            return result.interfaceType.name;
+        default:
+            return result.fieldName;
     }
-    return result.fieldName;
 }
 //# sourceMappingURL=servers.js.map