@azure-tools/typespec-go 0.8.2 → 0.8.3

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

@@ -34,14 +34,11 @@ export function getServerName(client) {
     // for the fake server, we use the suffix Server instead of Client
     return capitalize(client.name.replace(/[C|c]lient$/, 'Server'));
 }
-function isMethodInternal(method) {
-    return !!method.name.match(/^[a-z]{1}/);
-}
 export async function generateServers(codeModel) {
     const operations = new Array();
     const clientPkg = codeModel.packageName;
     for (const client of values(codeModel.clients)) {
-        if (client.clientAccessors.length === 0 && values(client.methods).all(method => { return isMethodInternal(method); })) {
+        if (client.clientAccessors.length === 0 && values(client.methods).all(method => { return helpers.isMethodInternal(method); })) {
             // client has no client accessors and no exported methods, skip it
             continue;
         }
@@ -64,7 +61,7 @@ export async function generateServers(codeModel) {
         // we might remove some clients from the list
         const finalSubClients = new Array();
         for (const clientAccessor of client.clientAccessors) {
-            if (values(clientAccessor.subClient.methods).all(method => { return isMethodInternal(method); })) {
+            if (values(clientAccessor.subClient.methods).all(method => { return helpers.isMethodInternal(method); })) {
                 // client has no exported methods, skip it
                 continue;
             }
@@ -74,7 +71,7 @@ export async function generateServers(codeModel) {
             finalSubClients.push(clientAccessor.subClient);
         }
         for (const method of values(client.methods)) {
-            if (isMethodInternal(method)) {
+            if (helpers.isMethodInternal(method)) {
                 // method isn't exported, don't create a fake for it
                 continue;
             }
@@ -82,25 +79,25 @@ export async function generateServers(codeModel) {
             switch (method.kind) {
                 case 'lroMethod':
                 case 'lroPageableMethod':
-                    let respType = `${clientPkg}.${method.responseEnvelope.name}`;
+                    let respType = `${clientPkg}.${method.returns.name}`;
                     if (method.kind === 'lroPageableMethod') {
-                        respType = `azfake.PagerResponder[${clientPkg}.${method.responseEnvelope.name}]`;
+                        respType = `azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
                     }
                     serverResponse = `resp azfake.PollerResponder[${respType}], errResp azfake.ErrorResponder`;
                     break;
                 case 'method':
-                    serverResponse = `resp azfake.Responder[${clientPkg}.${method.responseEnvelope.name}], errResp azfake.ErrorResponder`;
+                    serverResponse = `resp azfake.Responder[${clientPkg}.${method.returns.name}], errResp azfake.ErrorResponder`;
                     break;
                 case 'pageableMethod':
-                    serverResponse = `resp azfake.PagerResponder[${clientPkg}.${method.responseEnvelope.name}]`;
+                    serverResponse = `resp azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
                     break;
             }
             const operationName = fixUpMethodName(method);
             content += `\t// ${operationName} is the fake for method ${client.name}.${operationName}\n`;
             const successCodes = new Array();
-            if (method.responseEnvelope.result?.kind === 'anyResult') {
+            if (method.returns.result?.kind === 'anyResult') {
                 for (const httpStatus of getMethodStatusCodes(method)) {
-                    const result = method.responseEnvelope.result.httpStatusCodeType[httpStatus];
+                    const result = method.returns.result.httpStatusCodeType[httpStatus];
                     if (!result) {
                         // the operation contains a mix of schemas and non-schema responses
                         successCodes.push(`${helpers.formatStatusCode(httpStatus)} (no return type)`);
@@ -144,12 +141,12 @@ export async function generateServers(codeModel) {
         else {
             content += `\treturn &${serverTransport}{\n\t\tsrv: srv,\n`;
             for (const method of values(finalMethods)) {
-                let respType = `${clientPkg}.${method.responseEnvelope.name}`;
+                let respType = `${clientPkg}.${method.returns.name}`;
                 switch (method.kind) {
                     case 'lroMethod':
                     case 'lroPageableMethod':
                         if (method.kind === 'lroPageableMethod') {
-                            respType = `azfake.PagerResponder[${clientPkg}.${method.responseEnvelope.name}]`;
+                            respType = `azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
                         }
                         requiredHelpers.tracker = true;
                         content += `\t\t${uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PollerResponder[${respType}]](),\n`;
@@ -178,19 +175,19 @@ export async function generateServers(codeModel) {
         }
         for (const method of values(finalMethods)) {
             // create state machines for any pager/poller operations
-            let respType = `${clientPkg}.${method.responseEnvelope.name}`;
+            let respType = `${clientPkg}.${method.returns.name}`;
             switch (method.kind) {
                 case 'lroMethod':
                 case 'lroPageableMethod':
                     if (method.kind === 'lroPageableMethod') {
-                        respType = `azfake.PagerResponder[${clientPkg}.${method.responseEnvelope.name}]`;
+                        respType = `azfake.PagerResponder[${clientPkg}.${method.returns.name}]`;
                     }
                     requiredHelpers.tracker = true;
                     content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PollerResponder[${respType}]]\n`;
                     break;
                 case 'pageableMethod':
                     requiredHelpers.tracker = true;
-                    content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PagerResponder[${clientPkg}.${method.responseEnvelope.name}]]\n`;
+                    content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PagerResponder[${clientPkg}.${method.returns.name}]]\n`;
                     break;
             }
         }
@@ -322,24 +319,24 @@ 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 || method.responseEnvelope.result.kind === 'headAsBooleanResult') {
+                if (!method.returns.result || method.returns.result.kind === 'headAsBooleanResult') {
                     content += '\tresp, err := server.NewResponse(respContent, req, nil)\n';
                 }
-                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 (method.returns.result.kind === 'anyResult') {
+                    content += `\tresp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, server.GetResponse(respr).${getResultFieldName(method.returns.result)}, req)\n`;
                 }
-                else if (method.responseEnvelope.result.kind === 'binaryResult') {
+                else if (method.returns.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\tBody: server.GetResponse(respr).${getResultFieldName(method.returns.result)},\n`;
                     content += '\t\tContentType: req.Header.Get("Content-Type"),\n';
                     content += '\t})\n';
                 }
-                else if (method.responseEnvelope.result.kind === 'monomorphicResult') {
-                    if (method.responseEnvelope.result.monomorphicType.kind === 'encodedBytes') {
-                        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`;
+                else if (method.returns.result.kind === 'monomorphicResult') {
+                    if (method.returns.result.monomorphicType.kind === 'encodedBytes') {
+                        const encoding = method.returns.result.monomorphicType.encoding;
+                        content += `\tresp, err := server.MarshalResponseAsByteArray(respContent, server.GetResponse(respr).${getResultFieldName(method.returns.result)}, runtime.Base64${encoding}Format, req)\n`;
                     }
-                    else if (method.responseEnvelope.result.monomorphicType.kind === 'rawJSON') {
+                    else if (method.returns.result.monomorphicType.kind === 'rawJSON') {
                         imports.add('bytes');
                         imports.add('io');
                         content += '\tresp, err := server.NewResponse(respContent, req, &server.ResponseOptions{\n';
@@ -347,26 +344,26 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
                         content += '\t\tContentType: "application/json",\n\t})\n';
                     }
                     else {
-                        let respField = `.${getResultFieldName(method.responseEnvelope.result)}`;
-                        if (method.responseEnvelope.result.format === 'XML' && method.responseEnvelope.result.monomorphicType.kind === 'slice') {
+                        let respField = `.${getResultFieldName(method.returns.result)}`;
+                        if (method.returns.result.format === 'XML' && method.returns.result.monomorphicType.kind === 'slice') {
                             // for XML array responses we use the response type directly as it has the necessary XML tag for proper marshalling
                             respField = '';
                         }
                         let responseField = `server.GetResponse(respr)${respField}`;
-                        if (method.responseEnvelope.result.monomorphicType.kind === 'time') {
-                            responseField = `(*${method.responseEnvelope.result.monomorphicType.format})(${responseField})`;
+                        if (method.returns.result.monomorphicType.kind === 'time') {
+                            responseField = `(*${method.returns.result.monomorphicType.format})(${responseField})`;
                         }
-                        content += `\tresp, err := server.MarshalResponseAs${method.responseEnvelope.result.format}(respContent, ${responseField}, req)\n`;
+                        content += `\tresp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, ${responseField}, req)\n`;
                     }
                 }
-                else if (method.responseEnvelope.result.kind === 'modelResult' || method.responseEnvelope.result.kind === 'polymorphicResult') {
-                    const respField = `.${getResultFieldName(method.responseEnvelope.result)}`;
+                else if (method.returns.result.kind === 'modelResult' || method.returns.result.kind === 'polymorphicResult') {
+                    const respField = `.${getResultFieldName(method.returns.result)}`;
                     const responseField = `server.GetResponse(respr)${respField}`;
-                    content += `\tresp, err := server.MarshalResponseAs${method.responseEnvelope.result.format}(respContent, ${responseField}, req)\n`;
+                    content += `\tresp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, ${responseField}, req)\n`;
                 }
                 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)) {
+                for (const header of values(method.returns.headers)) {
                     if (header.kind === 'headerMapResponse') {
                         content += `\tfor k, v := range server.GetResponse(respr).${header.fieldName} {\n`;
                         content += '\t\tif v != nil {\n';
@@ -394,7 +391,7 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
 }
 function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
     const methodParamGroups = helpers.getMethodParamGroups(method);
-    const numPathParams = values(methodParamGroups.pathParams).where((each) => { return !go.isLiteralParameter(each); }).count();
+    const numPathParams = values(methodParamGroups.pathParams).where((each) => { return !go.isLiteralParameter(each.style); }).count();
     let content = '';
     if (numPathParams > 0) {
         imports.add('regexp');
@@ -407,7 +404,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         content += '\t\treturn nil, fmt.Errorf("failed to parse path %s", req.URL.Path)\n\t}\n';
     }
     const allQueryParams = methodParamGroups.encodedQueryParams.concat(methodParamGroups.unencodedQueryParams);
-    if (values(allQueryParams).where((each) => { return each.location === 'method' && !go.isLiteralParameter(each); }).any()) {
+    if (values(allQueryParams).where((each) => { return each.location === 'method' && !go.isLiteralParameter(each.style); }).any()) {
         content += '\tqp := req.URL.Query()\n';
     }
     // note that these are mutually exclusive
@@ -419,7 +416,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         switch (bodyParam.bodyFormat) {
             case 'JSON':
             case 'XML':
-                if (bodyParam && !go.isLiteralParameter(bodyParam)) {
+                if (bodyParam && !go.isLiteralParameter(bodyParam.style)) {
                     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
                     switch (bodyParam.type.kind) {
                         case 'encodedBytes':
@@ -451,7 +448,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                 }
                 break;
             case 'Text':
-                if (bodyParam && !go.isLiteralParameter(bodyParam)) {
+                if (bodyParam && !go.isLiteralParameter(bodyParam.style)) {
                     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';
@@ -520,10 +517,6 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
             parsingCode += `\t\t\tif ${parseErr} != nil {\n\t\t\t\treturn nil, ${parseErr}\n\t\t\t}\n`;
             return parsingCode;
         };
-        const isMultipartContentType = function (type) {
-            type = helpers.recursiveUnwrapMapSlice(type);
-            return (type.kind === 'qualifiedType' && type.exportName === 'MultipartContent');
-        };
         const isModelType = function (type) {
             return type.kind === 'model' || type.kind === 'polymorphicModel';
         };
@@ -536,7 +529,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                 imports.add('encoding/json');
                 caseContent += `\t\t\tif err = json.Unmarshal(content, &${paramVar}); err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n`;
             }
-            else if (type.kind === 'qualifiedType' && type.exportName === 'ReadSeekCloser') {
+            else if (type.kind === 'readSeekCloser') {
                 imports.add('bytes');
                 imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
                 assignedValue = 'streaming.NopCloser(bytes.NewReader(content))';
@@ -581,7 +574,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
             else if (type.kind === 'string') {
                 assignedValue = 'string(content)';
             }
-            else if (isMultipartContentType(type)) {
+            else if (helpers.recursiveUnwrapMapSlice(type).kind === 'multipartContent') {
                 imports.add('bytes');
                 imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
                 const bodyContent = 'streaming.NopCloser(bytes.NewReader(content))';
@@ -601,7 +594,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                 }
             }
             else if (type.kind === 'slice') {
-                if (type.elementType.kind === 'qualifiedType' && type.elementType.exportName === 'ReadSeekCloser') {
+                if (type.elementType.kind === 'readSeekCloser') {
                     imports.add('bytes');
                     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
                     assignedValue = `append(${paramVar}, streaming.NopCloser(bytes.NewReader(content)))`;
@@ -665,7 +658,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         // construct the partial body params type and unmarshal it
         content += '\ttype partialBodyParams struct {\n';
         for (const partialBodyParam of partialBodyParams) {
-            content += `\t\t${capitalize(partialBodyParam.name)} ${helpers.star(partialBodyParam)}${go.getTypeDeclaration(partialBodyParam.type)} \`json:"${partialBodyParam.serializedName}"\`\n`;
+            content += `\t\t${capitalize(partialBodyParam.name)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type)} \`json:"${partialBodyParam.serializedName}"\`\n`;
         }
         content += '\t}\n';
         content += `\tbody, err := server.UnmarshalRequestAs${partialBodyParams[0].format}[partialBodyParams](req)\n`;
@@ -675,7 +668,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
     content += result.content;
     // translate each partial body param to its field within the unmarshalled body
     for (const partialBodyParam of partialBodyParams) {
-        result.params.set(partialBodyParam.name, `${helpers.star(partialBodyParam)}body.${capitalize(partialBodyParam.name)}`);
+        result.params.set(partialBodyParam.name, `${helpers.star(partialBodyParam.byValue)}body.${capitalize(partialBodyParam.name)}`);
     }
     const apiCall = `:= ${receiverName}.srv.${fixUpMethodName(method)}(${populateApiParams(clientPkg, method, result.params, imports)})`;
     if (method.kind === 'pageableMethod') {
@@ -697,7 +690,7 @@ function getMethodStatusCodes(method) {
                 // pollers always include 200 as an acceptible status code so we emulate that here
                 statusCodes.unshift(200);
             }
-            if (!method.responseEnvelope.result && !statusCodes.includes(204)) {
+            if (!method.returns.result && !statusCodes.includes(204)) {
                 // also include 204 if the LRO doesn't return a body
                 statusCodes.push(204);
             }
@@ -737,7 +730,7 @@ function dispatchForPagerBody(clientPkg, receiverName, method, imports) {
     content += `\t\t${operationStateMachine}.add(req, ${localVarName})\n`;
     if (method.nextLinkName) {
         imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
-        content += `\t\tserver.PagerResponderInjectNextLinks(${localVarName}, req, func(page *${clientPkg}.${method.responseEnvelope.name}, createLink func() string) {\n`;
+        content += `\t\tserver.PagerResponderInjectNextLinks(${localVarName}, req, func(page *${clientPkg}.${method.returns.name}, createLink func() string) {\n`;
         content += `\t\t\tpage.${method.nextLinkName} = to.Ptr(createLink())\n`;
         content += '\t\t})\n';
     }
@@ -804,7 +797,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
     // we track the params separately as it might be a subset of ParameterGroup.params
     const paramGroups = new Map();
     for (const param of values(consolidateHostParams(method.parameters))) {
-        if (param.location === 'client' || go.isLiteralParameter(param)) {
+        if (param.location === 'client' || go.isLiteralParameter(param.style)) {
             // client params and parameter literals aren't passed to APIs
             continue;
         }
@@ -867,7 +860,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 where = 'Query';
             }
             let paramVar = createLocalVariableName(param, 'Unescaped');
-            if (go.isRequiredParameter(param) && param.type.kind === 'constant' && param.type.type === 'string') {
+            if (go.isRequiredParameter(param.style) && param.type.kind === 'constant' && param.type.type === 'string') {
                 // for string-based enums, we perform the conversion as part of unescaping
                 requiredHelpers.parseWithCast = true;
                 paramVar = createLocalVariableName(param, 'Param');
@@ -877,7 +870,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 content += `\t\treturn ${go.getTypeDeclaration(param.type, clientPkg)}(p), nil\n\t})\n`;
             }
             else {
-                if (go.isRequiredParameter(param) &&
+                if (go.isRequiredParameter(param.style) &&
                     (param.type.kind === 'string' || (param.type.kind === 'slice' && param.type.elementType.kind === 'string'))) {
                     // by convention, if the value is in its "final form" (i.e. no parsing required)
                     // then its var is to have the "Param" suffix. the only case is string, everything
@@ -969,7 +962,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 // TODO: remove cast in some cases
                 content += `\t\t${paramVar}[i] = ${toType}(${fromVar})\n\t}\n`;
             }
-            else if (!go.isRequiredParameter(param) && param.collectionFormat !== 'multi') {
+            else if (!go.isRequiredParameter(param.style) && param.collectionFormat !== 'multi') {
                 // for slices of strings that are required, the call to splitHelper(...) is inlined into
                 // the invocation of the fake e.g. srv.FakeFunc(splitHelper...). but if it's optional, we
                 // need to create a local first which will later be copied into the optional param group.
@@ -980,7 +973,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
         else if (param.type.kind === 'scalar' && param.type.type === 'bool') {
             imports.add('strconv');
             let from = `strconv.ParseBool(${paramValue})`;
-            if (!go.isRequiredParameter(param)) {
+            if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
                 from = `parseOptional(${paramValue}, strconv.ParseBool)`;
             }
@@ -1000,7 +993,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                     format = helpers.timeRFC3339Format;
                 }
                 let from = `time.Parse("${format}", ${paramValue})`;
-                if (!go.isRequiredParameter(param)) {
+                if (!go.isRequiredParameter(param.style)) {
                     requiredHelpers.parseOptional = true;
                     from = `parseOptional(${paramValue}, func(v string) (time.Time, error) { return time.Parse("${format}", v) })`;
                 }
@@ -1014,7 +1007,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                     format = 'time.RFC1123';
                 }
                 let from = `time.Parse(${format}, ${paramValue})`;
-                if (!go.isRequiredParameter(param)) {
+                if (!go.isRequiredParameter(param.style)) {
                     requiredHelpers.parseOptional = true;
                     from = `parseOptional(${paramValue}, func(v string) (time.Time, error) { return time.Parse(${format}, v) })`;
                 }
@@ -1024,7 +1017,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             else {
                 imports.add('strconv');
                 let parser;
-                if (!go.isRequiredParameter(param)) {
+                if (!go.isRequiredParameter(param.style)) {
                     requiredHelpers.parseOptional = true;
                     parser = 'parseOptional';
                 }
@@ -1041,7 +1034,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
         }
         else if (param.type.kind === 'scalar' && (param.type.type === 'float32' || param.type.type === 'float64' || param.type.type === 'int32' || param.type.type === 'int64')) {
             let parser;
-            if (!go.isRequiredParameter(param)) {
+            if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
                 parser = 'parseOptional';
             }
@@ -1049,7 +1042,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 requiredHelpers.parseWithCast = true;
                 parser = 'parseWithCast';
             }
-            if ((param.type.type === 'float32' || param.type.type === 'int32') || !go.isRequiredParameter(param)) {
+            if ((param.type.type === 'float32' || param.type.type === 'int32') || !go.isRequiredParameter(param.style)) {
                 content += `\t${createLocalVariableName(param, 'Param')}, err := ${parser}(${paramValue}, func(v string) (${param.type.type}, error) {\n`;
                 content += `\t\tp, parseErr := ${emitNumericConversion('v', param.type.type)}\n`;
                 content += '\t\tif parseErr != nil {\n\t\t\treturn 0, parseErr\n\t\t}\n';
@@ -1079,7 +1072,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
         }
         else if (param.type.kind === 'constant' && param.type.type !== 'string') {
             let parseHelper;
-            if (!go.isRequiredParameter(param)) {
+            if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
                 parseHelper = 'parseOptional';
             }
@@ -1106,7 +1099,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             content += `\t\treturn ${toConstType}(p), nil\n\t})\n`;
             content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         }
-        else if (!go.isRequiredParameter(param)) {
+        else if (!go.isRequiredParameter(param.style)) {
             // we check this last as it's a superset of the previous conditions
             requiredHelpers.getOptional = true;
             if (param.type.kind === 'constant') {
@@ -1155,7 +1148,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) && param.kind !== 'bodyParam' && !go.isFormBodyParameter(param) && param.kind !== 'multipartFormBodyParam')) {
+                if (param.byValue || (!go.isRequiredParameter(param.style) && param.kind !== 'bodyParam' && !go.isFormBodyParameter(param) && param.kind !== 'multipartFormBodyParam')) {
                     byRef = '';
                 }
                 content += `\t\t\t${capitalize(param.name)}: ${byRef}${getFinalParamValue(clientPkg, param, paramValues)},\n`;
@@ -1254,7 +1247,7 @@ function getFinalParamValue(clientPkg, param, paramValues) {
         // 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)) {
+    else if (go.isRequiredParameter(param.style)) {
         // optional params are always in their "final" form
         if (param.kind === 'headerCollectionParam' || param.kind === 'pathCollectionParam' || param.kind === 'queryCollectionParam') {
             // for required params that are collections of strings, we split them inline.