@azure-tools/typespec-go 0.17.4-dev.6 → 0.17.5-dev.10

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

@@ -97,7 +97,7 @@ export function generateServers(pkg, target) {
                     serverResponse = `resp azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                     break;
             }
-            const operationName = helpers.fixUpMethodName(method);
+            const operationName = method.name;
             content += `${indent.get()}// ${operationName} is the fake for method ${client.name}.${operationName}\n`;
             const successCodes = new Array();
             if (method.returns.result?.kind === "anyResult") {
@@ -157,11 +157,11 @@ export function generateServers(pkg, target) {
                             respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                         }
                         requiredHelpers.tracker = true;
-                        content += `${indent.get()}${naming.uncapitalize(helpers.fixUpMethodName(method))}: newTracker[azfake.PollerResponder[${respType}]](),\n`;
+                        content += `${indent.get()}${naming.uncapitalize(method.name)}: newTracker[azfake.PollerResponder[${respType}]](),\n`;
                         break;
                     case "pageableMethod":
                         requiredHelpers.tracker = true;
-                        content += `${indent.get()}${naming.uncapitalize(helpers.fixUpMethodName(method))}: newTracker[azfake.PagerResponder[${respType}]](),\n`;
+                        content += `${indent.get()}${naming.uncapitalize(method.name)}: newTracker[azfake.PagerResponder[${respType}]](),\n`;
                         break;
                 }
             }
@@ -192,11 +192,11 @@ export function generateServers(pkg, target) {
                         respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                     }
                     requiredHelpers.tracker = true;
-                    content += `${indent.get()}${naming.uncapitalize(helpers.fixUpMethodName(method))} *tracker[azfake.PollerResponder[${respType}]]\n`;
+                    content += `${indent.get()}${naming.uncapitalize(method.name)} *tracker[azfake.PollerResponder[${respType}]]\n`;
                     break;
                 case "pageableMethod":
                     requiredHelpers.tracker = true;
-                    content += `${indent.get()}${naming.uncapitalize(helpers.fixUpMethodName(method))} *tracker[azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]]\n`;
+                    content += `${indent.get()}${naming.uncapitalize(method.name)} *tracker[azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]]\n`;
                     break;
             }
         }
@@ -332,9 +332,8 @@ function generateServerTransportMethodDispatch(serverTransport, client, finalMet
     indent.push();
     content += `${indent.get()}switch method {\n`;
     for (const method of finalMethods) {
-        const operationName = helpers.fixUpMethodName(method);
-        content += `${indent.get()}case "${client.name}.${operationName}":\n`;
-        content += `${indent.push().get()}res.resp, res.err = ${receiverName}.dispatch${operationName}(req)\n`;
+        content += `${indent.get()}case "${client.name}.${method.name}":\n`;
+        content += `${indent.push().get()}res.resp, res.err = ${receiverName}.dispatch${method.name}(req)\n`;
         indent.pop();
     }
     content += `${indent.push().get()}default:\n`;
@@ -372,9 +371,9 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
     const receiverName = serverTransport[0].toLowerCase();
     let content = "";
     for (const method of finalMethods) {
-        content += `func (${receiverName} *${serverTransport}) dispatch${helpers.fixUpMethodName(method)}(req *http.Request) (*http.Response, error) {\n`;
-        content += `${indent.get()}if ${receiverName}.srv.${helpers.fixUpMethodName(method)} == nil {\n`;
-        content += `${indent.push().get()}return nil, &nonRetriableError{errors.New("fake for method ${helpers.fixUpMethodName(method)} not implemented")}\n`;
+        content += `func (${receiverName} *${serverTransport}) dispatch${method.name}(req *http.Request) (*http.Response, error) {\n`;
+        content += `${indent.get()}if ${receiverName}.srv.${method.name} == nil {\n`;
+        content += `${indent.push().get()}return nil, &nonRetriableError{errors.New("fake for method ${method.name} not implemented")}\n`;
         content += `${indent.pop().get()}}\n`;
         switch (method.kind) {
             case "lroMethod":
@@ -403,11 +402,11 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                     content += `${indent.pop().get()}})\n`;
                 }
                 else if (method.returns.result.kind === "monomorphicResult") {
-                    if (method.returns.result.monomorphicType.kind === "encodedBytes") {
-                        const encoding = method.returns.result.monomorphicType.encoding;
+                    if (method.returns.result.type.kind === "encodedBytes") {
+                        const encoding = method.returns.result.type.encoding;
                         content += `${indent.get()}resp, err := server.MarshalResponseAsByteArray(respContent, server.GetResponse(respr).${getResultFieldName(method.returns.result)}, runtime.Base64${encoding}Format, req)\n`;
                     }
-                    else if (method.returns.result.monomorphicType.kind === "rawJSON") {
+                    else if (method.returns.result.type.kind === "rawJSON") {
                         imports.add("bytes");
                         imports.add("io");
                         content += `${indent.get()}resp, err := server.NewResponse(respContent, req, &server.ResponseOptions{\n`;
@@ -420,39 +419,43 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                         let contentToMarshal;
                         const respField = getResultFieldName(method.returns.result);
                         const getResponseField = `server.GetResponse(respr).${respField}`;
-                        switch (method.returns.result.monomorphicType.kind) {
-                            case "scalar": {
-                                imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
-                                // create a local var that will hold the string-formatted scalar
-                                contentToMarshal = `formatted${respField}`;
-                                content += `${indent.get()}var ${contentToMarshal} *string\n`;
-                                const localVar = naming.uncapitalize(respField);
-                                const resultType = method.returns.result.monomorphicType;
-                                // if value := server.GetResponse(respr).Value; value != nil {...format as string...}
-                                content += `${indent.get()}${helpers.buildIfBlock(indent, {
-                                    condition: `${localVar} := ${getResponseField}; ${localVar} != nil`,
-                                    body: (indent) => `${indent.get()}${contentToMarshal} = to.Ptr(${helpers.formatValue(localVar, resultType, imports, true)})\n`,
-                                })}\n`;
-                                break;
+                        if (go.isPtr(method.returns.result.type, "scalar", "string")) {
+                            switch (method.returns.result.type.ptrType.kind) {
+                                case "scalar": {
+                                    imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
+                                    // create a local var that will hold the string-formatted scalar
+                                    contentToMarshal = `formatted${respField}`;
+                                    content += `${indent.get()}var ${contentToMarshal} *string\n`;
+                                    const localVar = naming.uncapitalize(respField);
+                                    // we want the wrapped type so formatValue will deref it
+                                    const monomorphicType = method.returns.result.type;
+                                    // if value := server.GetResponse(respr).Value; value != nil {...format as string...}
+                                    content += `${indent.get()}${helpers.buildIfBlock(indent, {
+                                        condition: `${localVar} := ${getResponseField}; ${localVar} != nil`,
+                                        body: (indent) => `${indent.get()}${contentToMarshal} = to.Ptr(${helpers.formatValue(localVar, monomorphicType, imports)})\n`,
+                                    })}\n`;
+                                    break;
+                                }
+                                case "string":
+                                    contentToMarshal = getResponseField;
+                                    break;
                             }
-                            case "string":
-                                contentToMarshal = getResponseField;
-                                break;
-                            default:
-                                throw new CodegenError("UnsupportedTsp", `unsupported text return kind ${method.returns.result.monomorphicType.kind} for method ${method.receiver.type.name}.${method.name}`);
+                        }
+                        else {
+                            throw new CodegenError("UnsupportedTsp", `unsupported text return kind ${method.returns.result.type.kind} for method ${method.receiver.type.name}.${method.name}`);
                         }
                         content += `${indent.get()}resp, err := server.MarshalResponseAsText(respContent, ${contentToMarshal}, req)\n`;
                     }
                     else {
                         let respField = `.${getResultFieldName(method.returns.result)}`;
                         if (method.returns.result.format === "XML" &&
-                            method.returns.result.monomorphicType.kind === "slice") {
+                            method.returns.result.type.kind === "slice") {
                             respField = "";
                         }
                         let responseField = `server.GetResponse(respr)${respField}`;
-                        if (method.returns.result.monomorphicType.kind === "time") {
+                        if (go.isPtr(method.returns.result.type, "time")) {
                             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
-                            responseField = `(*datetime.${method.returns.result.monomorphicType.format})(${responseField})`;
+                            responseField = `(*datetime.${method.returns.result.type.ptrType.format})(${responseField})`;
                         }
                         content += `${indent.get()}resp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, ${responseField}, req)\n`;
                     }
@@ -477,7 +480,7 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                     }
                     else {
                         content += `${indent.get()}if val := server.GetResponse(respr).${header.fieldName}; val != nil {\n`;
-                        content += `${indent.push().get()}resp.Header.Set("${helpers.canonicalizeHeaderName(header.headerName)}", ${helpers.formatValue("val", header.type, imports, true)})\n`;
+                        content += `${indent.push().get()}resp.Header.Set("${helpers.canonicalizeHeaderName(header.headerName)}", ${helpers.formatValue("val", header.type, imports)})\n`;
                         content += `${indent.pop().get()}}\n`;
                     }
                 }
@@ -553,10 +556,11 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
                             content += `${indent.get()}req.Body.Close()\n`;
                             break;
                         default: {
-                            let bodyTypeName = go.getTypeDeclaration(bodyParam.type, pkg);
-                            if (bodyParam.type.kind === "time") {
+                            const bodyParamType = go.unwrapPtr(bodyParam.type);
+                            let bodyTypeName = go.getTypeDeclaration(bodyParamType, pkg);
+                            if (bodyParamType.kind === "time") {
                                 imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
-                                bodyTypeName = `datetime.${bodyParam.type.format}`;
+                                bodyTypeName = `datetime.${bodyParamType.format}`;
                             }
                             content += `${indent.get()}body, err := server.UnmarshalRequestAs${bodyParam.bodyFormat}[${bodyTypeName}](req)\n`;
                             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
@@ -705,13 +709,13 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
                 }
             }
             else if (type.kind === "slice") {
-                if (type.elementType.kind === "readSeekCloser") {
+                if (type.itemType.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)))`;
                 }
                 else {
-                    throw new CodegenError("InternalError", `unhandled multipart parameter array element kind ${type.elementType.kind}`);
+                    throw new CodegenError("InternalError", `unhandled multipart parameter array element kind ${type.itemType.kind}`);
                 }
             }
             else if (type.kind === "encodedBytes") {
@@ -735,13 +739,14 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
         for (const param of multipartBodyParams) {
             if (isModelType(param.type)) {
                 for (const field of param.type.fields) {
-                    content += emitCase(field.serializedName, `${param.name}.${field.name}`, field.type, field.byValue);
+                    content += emitCase(field.serializedName, `${param.name}.${field.name}`, go.unwrapPtr(field.type), field.type.kind !== "ptr");
                 }
             }
             else {
-                // for this case we've emitted local vars of the underlying
-                // type which is why we pass true for param destIsByValue
-                content += emitCase(param.name, param.name, param.type, true);
+                // optional params are wrapped in a pointer; the local var is declared
+                // as the pointer type, so dispatch on the unwrapped type and let
+                // emitCase wrap the value in to.Ptr when the destination is by-ref.
+                content += emitCase(param.name, param.name, go.unwrapPtr(param.type), !go.isPtr(param.type));
             }
         }
         content += `${indent.get()}default:\n`;
@@ -780,7 +785,7 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
         content += `${indent.get()}type partialBodyParams struct {\n`;
         indent.push();
         for (const partialBodyParam of partialBodyParams) {
-            content += `${indent.get()}${naming.capitalize(partialBodyParam.name)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, pkg)} \`json:"${partialBodyParam.serializedName}"\`\n`;
+            content += `${indent.get()}${naming.capitalize(partialBodyParam.name)} ${go.getTypeDeclaration(partialBodyParam.type, pkg)} \`json:"${partialBodyParam.serializedName}"\`\n`;
         }
         content += `${indent.pop().get()}}\n`;
         content += `${indent.get()}body, err := server.UnmarshalRequestAs${partialBodyParams[0].format}[partialBodyParams](req)\n`;
@@ -790,9 +795,9 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
     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.byValue)}body.${naming.capitalize(partialBodyParam.name)}`);
+        result.params.set(partialBodyParam.name, `${helpers.deref(partialBodyParam.type)}body.${naming.capitalize(partialBodyParam.name)}`);
     }
-    const apiCall = `:= ${receiverName}.srv.${helpers.fixUpMethodName(method)}(${populateApiParams(pkg, method, result.params, imports)})`;
+    const apiCall = `:= ${receiverName}.srv.${method.name}(${populateApiParams(pkg, method, result.params, imports)})`;
     if (method.kind === "pageableMethod") {
         content += `resp ${apiCall}\n`;
         return content;
@@ -803,7 +808,11 @@ function dispatchForOperationBody(pkg, receiverName, method, imports, indent) {
     return content;
 }
 function emitTextBodyUnmarshal(pkg, bodyParam, imports, indent) {
-    const typeName = go.getTypeDeclaration(bodyParam.type, pkg);
+    const bodyParamType = go.unwrapPtr(bodyParam.type);
+    // we pass the unwrapped param type since we'll be declaring
+    // a local of the underlying type and we don't want it to be
+    // pointer-to-type
+    const typeName = go.getTypeDeclaration(bodyParamType, pkg);
     const optional = !go.isRequiredParameter(bodyParam.style);
     let content = "";
     if (optional) {
@@ -815,30 +824,30 @@ function emitTextBodyUnmarshal(pkg, bodyParam, imports, indent) {
     content += `${indent.get()}bodyRaw, err := server.UnmarshalRequestAsText(req)\n`;
     content += `${indent.get()}${helpers.buildErrCheck(indent, "err", "nil")}\n`;
     const assignOrDecl = optional ? "=" : ":=";
-    switch (bodyParam.type.kind) {
+    switch (bodyParamType.kind) {
         case "string":
             content += `${indent.get()}body ${assignOrDecl} bodyRaw\n`;
             break;
         case "constant":
             imports.addForType(bodyParam.type);
-            if (bodyParam.type.type === "string") {
+            if (bodyParamType.type === "string") {
                 content += `${indent.get()}body ${assignOrDecl} ${typeName}(bodyRaw)\n`;
             }
             else {
-                content += helpers.emitScalarParsing(bodyParam.type, "bodyRaw", "bodyParsed", imports, indent);
+                content += helpers.emitScalarParsing(bodyParamType, "bodyRaw", "bodyParsed", imports, indent);
                 content += `${indent.get()}${helpers.buildErrCheck(indent, "err", "nil")}\n`;
                 content += `${indent.get()}body ${assignOrDecl} ${typeName}(bodyParsed)\n`;
             }
             break;
         case "scalar":
-            content += helpers.emitScalarParsing(bodyParam.type, "bodyRaw", optional ? "bodyParsed" : "body", imports, indent);
+            content += helpers.emitScalarParsing(bodyParamType, "bodyRaw", optional ? "bodyParsed" : "body", imports, indent);
             content += `${indent.get()}${helpers.buildErrCheck(indent, "err", "nil")}\n`;
             if (optional) {
                 content += `${indent.get()}body = bodyParsed\n`;
             }
             break;
         case "time":
-            content += helpers.emitTimeParsing("bodyRaw", bodyParam.type, "bodyParsed", imports, indent);
+            content += helpers.emitTimeParsing("bodyRaw", bodyParamType, "bodyParsed", imports, indent);
             content += `${indent.get()}${helpers.buildErrCheck(indent, "err", "nil")}\n`;
             content += `${indent.get()}body ${assignOrDecl} bodyParsed\n`;
             break;
@@ -879,9 +888,8 @@ function getMethodStatusCodes(method) {
  * @returns the text for the LRO dispatch logic
  */
 function dispatchForLROBody(pkg, receiverName, method, imports, indent) {
-    const operationName = helpers.fixUpMethodName(method);
-    const localVarName = naming.uncapitalize(operationName);
-    const operationStateMachine = `${receiverName}.${naming.uncapitalize(operationName)}`;
+    const localVarName = naming.uncapitalize(method.name);
+    const operationStateMachine = `${receiverName}.${naming.uncapitalize(method.name)}`;
     let content = `${indent.get()}${localVarName} := ${operationStateMachine}.get(req)\n`;
     content += `${indent.get()}if ${localVarName} == nil {\n`;
     content += dispatchForOperationBody(pkg, receiverName, method, imports, indent);
@@ -916,9 +924,8 @@ function dispatchForLROBody(pkg, receiverName, method, imports, indent) {
  * @returns the text for the pageable dispatch logic
  */
 function dispatchForPagerBody(pkg, receiverName, method, imports, indent) {
-    const operationName = helpers.fixUpMethodName(method);
-    const localVarName = naming.uncapitalize(operationName);
-    const operationStateMachine = `${receiverName}.${naming.uncapitalize(operationName)}`;
+    const localVarName = naming.uncapitalize(method.name);
+    const operationStateMachine = `${receiverName}.${naming.uncapitalize(method.name)}`;
     let content = `${indent.get()}${localVarName} := ${operationStateMachine}.get(req)\n`;
     content += `${indent.get()}if ${localVarName} == nil {\n`;
     content += dispatchForOperationBody(pkg, receiverName, method, imports, indent);
@@ -1048,6 +1055,8 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
         // of paramValue will be updated with the var name that
         // contains the unescaped value.
         let paramValue = getRawParamValue(param);
+        // optional params are pointer-wrapped; dispatch on the unwrapped type.
+        const paramType = go.unwrapPtr(param.type);
         // encoded path params are escaped, so we need to unescape them first.
         // non-encoded path params are already in their final form (the client
         // skips url.PathEscape for them), so they're passed through verbatim.
@@ -1097,8 +1106,9 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
         if (param.kind === "headerCollectionParam" ||
             param.kind === "pathCollectionParam" ||
             param.kind === "queryCollectionParam") {
+            const elementType = go.unwrapPtr(param.type.itemType);
             // any element type other than string will require some form of conversion/parsing
-            if (param.type.elementType.kind !== "string") {
+            if (elementType.kind !== "string") {
                 if (param.collectionFormat !== "multi") {
                     requiredHelpers.splitHelper = true;
                     const elementsParam = createLocalVariableName(param, "Elements");
@@ -1107,21 +1117,21 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 }
                 const paramVar = createLocalVariableName(param, "Param");
                 let elementFormat;
-                switch (param.type.elementType.kind) {
+                switch (elementType.kind) {
                     case "constant":
                     case "scalar":
-                        elementFormat = param.type.elementType.type;
+                        elementFormat = elementType.type;
                         break;
                     case "encodedBytes":
-                        elementFormat = param.type.elementType.encoding;
+                        elementFormat = elementType.encoding;
                         break;
                     case "time":
-                        elementFormat = param.type.elementType.format;
+                        elementFormat = elementType.format;
                         break;
                     default:
-                        throw new CodegenError("InternalError", `unhandled element kind ${param.type.elementType.kind}`);
+                        throw new CodegenError("InternalError", `unhandled element kind ${elementType.kind}`);
                 }
-                const toType = go.getTypeDeclaration(param.type.elementType, pkg);
+                const toType = go.getTypeDeclaration(param.type.itemType, pkg);
                 content += `${indent.get()}${paramVar} := make([]${toType}, len(${paramValue}))\n`;
                 content += `${indent.get()}for i := 0; i < len(${paramValue}); i++ {\n`;
                 indent.push();
@@ -1188,7 +1198,7 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 content += `${indent.get()}${createLocalVariableName(param, "Param")} := splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")\n`;
             }
         }
-        else if (go.isScalar(param.type, "bool")) {
+        else if (go.isScalar(paramType, "bool")) {
             imports.add("strconv");
             let from = `strconv.ParseBool(${paramValue})`;
             if (!go.isRequiredParameter(param.style)) {
@@ -1198,12 +1208,12 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${from}\n`;
             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
         }
-        else if (param.type.kind === "encodedBytes") {
+        else if (paramType.kind === "encodedBytes") {
             imports.add("encoding/base64");
-            content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := base64.${param.type.encoding}Encoding.DecodeString(${paramValue})\n`;
+            content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := base64.${paramType.encoding}Encoding.DecodeString(${paramValue})\n`;
             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
         }
-        else if (param.type.kind === "time") {
+        else if (paramType.kind === "time") {
             const formatMap = {
                 PlainDate: helpers.plainDateFormat,
                 PlainTime: helpers.plainTimeFormat,
@@ -1212,8 +1222,8 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 RFC7231: helpers.RFC1123Format,
             };
             imports.add("time");
-            if (param.type.format in formatMap) {
-                const format = formatMap[param.type.format];
+            if (paramType.format in formatMap) {
+                const format = formatMap[paramType.format];
                 let from = `time.Parse(${format}, ${paramValue})`;
                 if (!go.isRequiredParameter(param.style)) {
                     requiredHelpers.parseOptional = true;
@@ -1241,7 +1251,7 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
             }
         }
-        else if (go.isScalar(param.type, "float32", "float64", "int32", "int64")) {
+        else if (go.isScalar(paramType, "float32", "float64", "int32", "int64")) {
             let parser;
             if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
@@ -1251,20 +1261,20 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 requiredHelpers.parseWithCast = true;
                 parser = "parseWithCast";
             }
-            if (param.type.type === "float32" ||
-                param.type.type === "int32" ||
+            if (paramType.type === "float32" ||
+                paramType.type === "int32" ||
                 !go.isRequiredParameter(param.style)) {
-                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${parser}(${paramValue}, func(v string) (${param.type.type}, error) {\n`;
-                content += `${indent.push().get()}p, parseErr := ${emitNumericConversion("v", param.type.type)}\n`;
+                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${parser}(${paramValue}, func(v string) (${paramType.type}, error) {\n`;
+                content += `${indent.push().get()}p, parseErr := ${emitNumericConversion("v", paramType.type)}\n`;
                 content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return 0, parseErr\n${indent.pop().get()}}\n`;
                 let result = "p";
-                if (param.type.type === "float32" || param.type.type === "int32") {
-                    result = `${param.type.type}(${result})`;
+                if (paramType.type === "float32" || paramType.type === "int32") {
+                    result = `${paramType.type}(${result})`;
                 }
                 content += `${indent.get()}return ${result}, nil\n${indent.pop().get()}})\n`;
             }
             else {
-                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${emitNumericConversion(paramValue, param.type.type)}\n`;
+                content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${emitNumericConversion(paramValue, paramType.type)}\n`;
             }
             content += `${indent.get()}if err != nil {\n${indent.push().get()}return nil, err\n${indent.pop().get()}}\n`;
         }
@@ -1281,7 +1291,7 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             content += `${indent.get()}${localVar}[hh[len("${headerPrefix}"):]] = to.Ptr(getHeaderValue(req.Header, hh))\n`;
             content += `${indent.pop().get()}}\n${indent.pop().get()}}\n`;
         }
-        else if (go.isConstant(param.type, "bool", "float32", "float64", "int32", "int64")) {
+        else if (go.isConstant(paramType, "bool", "float32", "float64", "int32", "int64")) {
             let parseHelper;
             if (!go.isRequiredParameter(param.style)) {
                 requiredHelpers.parseOptional = true;
@@ -1293,17 +1303,17 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             }
             let parse;
             let zeroValue;
-            if (param.type.type === "bool") {
+            if (paramType.type === "bool") {
                 imports.add("strconv");
                 parse = "strconv.ParseBool(v)";
                 zeroValue = "false";
             }
             else {
                 // emitNumericConversion adds the necessary import of strconv
-                parse = emitNumericConversion("v", param.type.type);
+                parse = emitNumericConversion("v", paramType.type);
                 zeroValue = "0";
             }
-            const toConstType = go.getTypeDeclaration(param.type, pkg);
+            const toConstType = go.getTypeDeclaration(paramType, pkg);
             content += `${indent.get()}${createLocalVariableName(param, "Param")}, err := ${parseHelper}(${paramValue}, func(v string) (${toConstType}, error) {\n`;
             content += `${indent.push().get()}p, parseErr := ${parse}\n`;
             content += `${indent.get()}if parseErr != nil {\n${indent.push().get()}return ${zeroValue}, parseErr\n${indent.pop().get()}}\n`;
@@ -1313,9 +1323,9 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
         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" || param.type.kind === "etag") {
-                imports.addForType(param.type);
-                paramValue = `${go.getTypeDeclaration(param.type, pkg)}(${paramValue})`;
+            if (paramType.kind === "constant" || paramType.kind === "etag") {
+                imports.addForType(paramType);
+                paramValue = `${go.getTypeDeclaration(paramType, pkg)}(${paramValue})`;
             }
             content += `${indent.get()}${createLocalVariableName(param, "Param")} := getOptional(${paramValue})\n`;
         }
@@ -1335,7 +1345,7 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
             content += `${indent.get()}}\n`;
         }
         else {
-            content += `${indent.get()}var ${naming.uncapitalize(paramGroup.name)} *${go.getTypeDeclaration(paramGroup, pkg)}\n`;
+            content += `${indent.get()}var ${naming.uncapitalize(paramGroup.name)} ${go.getTypeDeclaration(paramGroup, pkg)}\n`;
             const params = paramGroups.get(paramGroup);
             const paramNilCheck = new Array();
             if (params) {
@@ -1367,12 +1377,12 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
                 }
             }
             content += `${indent.get()}if ${paramNilCheck.join(" || ")} {\n`;
-            content += `${indent.push().get()}${naming.uncapitalize(paramGroup.name)} = &${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
+            content += `${indent.push().get()}${naming.uncapitalize(paramGroup.name)} = ${go.getTypeDeclaration(paramGroup, pkg, true)}{\n`;
             if (params) {
                 indent.push();
                 for (const param of params) {
                     let byRef = "&";
-                    if (param.byValue ||
+                    if (param.type.kind !== "ptr" ||
                         (!go.isRequiredParameter(param.style) &&
                             param.kind !== "bodyParam" &&
                             !go.isFormBodyParameter(param) &&
@@ -1493,7 +1503,7 @@ function getFinalParamValue(pkg, param, paramValues) {
     if ((param.kind === "bodyParam" ||
         go.isFormBodyParameter(param) ||
         param.kind === "multipartFormBodyParam") &&
-        param.type.kind === "time" &&
+        go.unwrapPtr(param.type).kind === "time" &&
         (param.kind !== "bodyParam" || param.bodyFormat !== "Text")) {
         // time types in the body have been unmarshalled into our time helpers thus require a cast to time.Time
         return `time.Time(${paramValue})`;
@@ -1505,7 +1515,7 @@ function getFinalParamValue(pkg, param, paramValues) {
             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" && param.type.elementType.kind === "string") {
+            if (param.collectionFormat !== "multi" && param.type.itemType.kind === "string") {
                 requiredHelpers.splitHelper = true;
                 return `splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")`;
             }
@@ -1573,12 +1583,9 @@ function getAPIParametersSig(pkg, method, imports) {
 // copied from generator/helpers.ts but without the XML-specific stuff
 function getResultFieldName(result) {
     switch (result.kind) {
-        case "anyResult":
-            return result.fieldName;
         case "modelResult":
-            return result.modelType.name;
         case "polymorphicResult":
-            return result.interface.name;
+            return result.type.name;
         default:
             return result.fieldName;
     }