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

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

@@ -420,26 +420,30 @@ 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.monomorphicType, "scalar", "string")) {
+                            switch (method.returns.result.monomorphicType.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.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, 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.monomorphicType.kind} for method ${method.receiver.type.name}.${method.name}`);
                         }
                         content += `${indent.get()}resp, err := server.MarshalResponseAsText(respContent, ${contentToMarshal}, req)\n`;
                     }
@@ -450,9 +454,9 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                             respField = "";
                         }
                         let responseField = `server.GetResponse(respr)${respField}`;
-                        if (method.returns.result.monomorphicType.kind === "time") {
+                        if (go.isPtr(method.returns.result.monomorphicType, "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.monomorphicType.ptrType.format})(${responseField})`;
                         }
                         content += `${indent.get()}resp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, ${responseField}, req)\n`;
                     }
@@ -477,7 +481,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 +557,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`;
@@ -735,13 +740,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 +786,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,7 +796,7 @@ 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)})`;
     if (method.kind === "pageableMethod") {
@@ -803,7 +809,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 +825,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;
@@ -1048,6 +1058,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 +1109,9 @@ function parseHeaderPathQueryParams(pkg, method, imports, indent) {
         if (param.kind === "headerCollectionParam" ||
             param.kind === "pathCollectionParam" ||
             param.kind === "queryCollectionParam") {
+            const elementType = go.unwrapPtr(param.type.elementType);
             // 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,19 +1120,19 @@ 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);
                 content += `${indent.get()}${paramVar} := make([]${toType}, len(${paramValue}))\n`;
@@ -1188,7 +1201,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 +1211,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 +1225,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 +1254,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 +1264,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 +1294,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 +1306,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 +1326,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 +1348,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 +1380,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 +1506,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})`;