@azure-tools/typespec-go 0.9.0 → 0.9.2

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

@@ -3,9 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as go from '../../../codemodel.go/src/index.js';
-import { ensureNameCase } from '../../../naming.go/src/naming.js';
-import { capitalize, comment, uncapitalize } from '@azure-tools/codegen';
-import { values } from '@azure-tools/linq';
+import * as naming from '../../../naming.go/src/naming.js';
 import * as helpers from './helpers.js';
 import { ImportManager } from './imports.js';
 import { CodegenError } from './errors.js';
@@ -78,13 +76,13 @@ export function generateOperations(pkg, target, options) {
         // now emit any client params (non parameterized host params case)
         if (client.parameters.length > 0) {
             const addedGroups = new Set();
-            for (const clientParam of values(client.parameters)) {
+            for (const clientParam of client.parameters) {
                 if (go.isLiteralParameter(clientParam.style)) {
                     continue;
                 }
                 if (clientParam.group) {
                     if (!addedGroups.has(clientParam.group.groupName)) {
-                        clientText += `\t${uncapitalize(clientParam.group.groupName)} ${!isParamPointer(clientParam) ? '' : '*'}${clientParam.group.groupName}\n`;
+                        clientText += `\t${naming.uncapitalize(clientParam.group.groupName)} ${!isParamPointer(clientParam) ? '' : '*'}${clientParam.group.groupName}\n`;
                         addedGroups.add(clientParam.group.groupName);
                     }
                     continue;
@@ -187,14 +185,14 @@ function generateConstructors(client, type, imports) {
                 // we use azcore.ClientOptions.APIVersion
                 continue;
             }
-            ctorText += helpers.formatDocCommentWithPrefix(ensureNameCase(param.name), param.docs);
+            ctorText += helpers.formatDocCommentWithPrefix(naming.ensureNameCase(param.name), param.docs);
             if (go.isClientSideDefault(param.style)) {
                 if (!param.docs.description && !param.docs.summary) {
                     ctorText += '\n';
                 }
-                ctorText += `\t${comment(`The default value is ${helpers.formatLiteralValue(param.style.defaultValue, false)}`, '// ')}.\n`;
+                ctorText += `\t${helpers.comment(`The default value is ${helpers.formatLiteralValue(param.style.defaultValue, false)}`, '// ')}.\n`;
             }
-            ctorText += `\t${ensureNameCase(param.name)} *${go.getTypeDeclaration(param.type, client.pkg)}\n`;
+            ctorText += `\t${naming.ensureNameCase(param.name)} *${go.getTypeDeclaration(param.type, client.pkg)}\n`;
         }
         ctorText += '}\n\n';
     }
@@ -342,7 +340,7 @@ function generateConstructors(client, type, imports) {
                         name = 'APIVersion';
                     }
                     else {
-                        name = ensureNameCase(param.name);
+                        name = naming.ensureNameCase(param.name);
                     }
                     ctorText += `\t${param.name} := ${helpers.formatLiteralValue(param.style.defaultValue, false)}\n`;
                     ctorText += `\tif options.${name} != ${helpers.zeroValue(param)} {\n\t\t${param.name} = ${helpers.star(param.byValue)}options.${name}\n\t}\n`;
@@ -371,7 +369,7 @@ function generateConstructors(client, type, imports) {
         // ensure clientVar doesn't collide with any params
         for (const param of consolidatedCtorParams) {
             if (param.name === clientVar) {
-                clientVar = ensureNameCase(client.name, true);
+                clientVar = naming.ensureNameCase(client.name, true);
                 break;
             }
         }
@@ -379,7 +377,7 @@ function generateConstructors(client, type, imports) {
         // NOTE: we don't enumerate consolidatedCtorParams here
         // as any supplemental endpoint params are ephemeral and
         // consumed during client construction.
-        for (const parameter of values(client.parameters)) {
+        for (const parameter of client.parameters) {
             if (go.isLiteralParameter(parameter.style)) {
                 continue;
             }
@@ -411,7 +409,7 @@ function formatHeaderResponseValue(headerResp, imports, respObj, zeroResp) {
         return text;
     }
     let text = `\tif val := resp.Header.Get("${headerResp.headerName}"); val != "" {\n`;
-    let name = uncapitalize(headerResp.fieldName);
+    let name = naming.uncapitalize(headerResp.fieldName);
     let byRef = '&';
     switch (headerResp.type.kind) {
         case 'constant':
@@ -459,17 +457,17 @@ function formatHeaderResponseValue(headerResp, imports, respObj, zeroResp) {
         case 'time':
             imports.add('time');
             switch (headerResp.type.format) {
-                case 'dateTimeRFC1123':
-                case 'dateTimeRFC3339':
-                    text += `\t\t${name}, err := time.Parse(${headerResp.type.format === 'dateTimeRFC1123' ? helpers.datetimeRFC1123Format : helpers.datetimeRFC3339Format}, val)\n`;
+                case 'RFC1123':
+                case 'RFC3339':
+                    text += `\t\t${name}, err := time.Parse(${headerResp.type.format === 'RFC1123' ? helpers.RFC1123Format : helpers.RFC3339Format}, val)\n`;
                     break;
-                case 'dateType':
-                    text += `\t\t${name}, err := time.Parse("${helpers.dateFormat}", val)\n`;
+                case 'PlainDate':
+                    text += `\t\t${name}, err := time.Parse(${helpers.plainDateFormat}, val)\n`;
                     break;
-                case 'timeRFC3339':
-                    text += `\t\t${name}, err := time.Parse("${helpers.timeRFC3339Format}", val)\n`;
+                case 'PlainTime':
+                    text += `\t\t${name}, err := time.Parse(${helpers.plainTimeFormat}, val)\n`;
                     break;
-                case 'timeUnix':
+                case 'Unix':
                     imports.add('strconv');
                     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/to');
                     text += '\t\tsec, err := strconv.ParseInt(val, 10, 64)\n';
@@ -558,7 +556,7 @@ function emitPagerDefinition(method, imports, options) {
             text += `\t\t\t\t\treturn client.${method.nextPageMethod.name}(${nextOpParams.join(', ')})\n\t\t\t\t},\n\t\t\t})\n`;
         }
         else if (method.nextLinkVerb !== 'get') {
-            text += `&runtime.FetcherForNextLinkOptions{\n\t\t\t\tHTTPVerb: http.Method${capitalize(method.nextLinkVerb)},\n\t\t\t})\n`;
+            text += `&runtime.FetcherForNextLinkOptions{\n\t\t\t\tHTTPVerb: http.Method${naming.capitalize(method.nextLinkVerb)},\n\t\t\t})\n`;
         }
         else {
             text += 'nil)\n';
@@ -637,7 +635,7 @@ function generateOperation(method, imports, options) {
         methodName = method.naming.internalMethod;
     }
     else {
-        for (const param of values(helpers.getMethodParameters(method))) {
+        for (const param of helpers.getMethodParameters(method)) {
             text += helpers.formatCommentAsBulletItem(param.name, param.docs);
         }
     }
@@ -703,14 +701,14 @@ function createProtocolRequest(azureARM, method, imports) {
     if (method.kind !== 'nextPageMethod') {
         name = method.naming.requestMethod;
     }
-    for (const param of values(method.parameters)) {
+    for (const param of method.parameters) {
         if (param.location !== 'method' || !go.isRequiredParameter(param.style)) {
             continue;
         }
         imports.addForType(param.type);
     }
     const returns = ['*policy.Request', 'error'];
-    let text = `${comment(name, '// ')} creates the ${method.name} request.\n`;
+    let text = `${helpers.comment(name, '// ')} creates the ${method.name} request.\n`;
     text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(${helpers.getCreateRequestParametersSig(method)}) (${returns.join(', ')}) {\n`;
     const hostParams = new Array();
     for (const parameter of method.receiver.type.parameters) {
@@ -731,7 +729,7 @@ function createProtocolRequest(azureARM, method, imports) {
             text += `\thost = strings.ReplaceAll(host, "{${hostParam.uriPathSegment}}", ${helpers.formatValue(`client.${hostParam.name}`, hostParam.type, imports)})\n`;
         }
         // check for any method local host params
-        for (const param of values(method.parameters)) {
+        for (const param of method.parameters) {
             if (param.location === 'method' && param.kind === 'uriParam') {
                 text += `\thost = strings.ReplaceAll(host, "{${param.uriPathSegment}}", ${helpers.formatValue(helpers.getParamName(param), param.type, imports)})\n`;
             }
@@ -768,12 +766,12 @@ function createProtocolRequest(azureARM, method, imports) {
         if (param.location === 'client') {
             client = 'client.';
         }
-        const paramGroupName = uncapitalize(param.group.name);
+        const paramGroupName = naming.uncapitalize(param.group.name);
         let optionalParamGroupCheck = `${client}${paramGroupName} != nil && `;
         if (param.group.required) {
             optionalParamGroupCheck = '';
         }
-        return `\tif ${optionalParamGroupCheck}${client}${paramGroupName}.${capitalize(param.name)} != nil {\n`;
+        return `\tif ${optionalParamGroupCheck}${client}${paramGroupName}.${naming.capitalize(param.name)} != nil {\n`;
     };
     if (hasPathParams) {
         // swagger defines path params, emit path and replace tokens
@@ -816,7 +814,7 @@ function createProtocolRequest(azureARM, method, imports) {
                 // param isn't required, so emit a local var with
                 // the correct default value, then populate it with
                 // the optional value when set.
-                paramValue = `optional${capitalize(pp.name)}`;
+                paramValue = `optional${naming.capitalize(pp.name)}`;
                 text += `\t${paramValue} := ""\n`;
                 text += emitParamGroupCheck(pp);
                 text += `\t${paramValue} = ${helpers.formatParamValue(pp, imports)}\n\t}\n`;
@@ -846,7 +844,7 @@ function createProtocolRequest(azureARM, method, imports) {
             text += `\turlPath = strings.ReplaceAll(urlPath, "{${pp.pathSegment}}", ${paramValue})\n`;
         }
     }
-    text += `\treq, err := runtime.NewRequest(ctx, http.Method${capitalize(method.httpMethod)}, ${hostParam})\n`;
+    text += `\treq, err := runtime.NewRequest(ctx, http.Method${naming.capitalize(method.httpMethod)}, ${hostParam})\n`;
     text += '\tif err != nil {\n';
     text += '\t\treturn nil, err\n';
     text += '\t}\n';
@@ -877,7 +875,7 @@ function createProtocolRequest(azureARM, method, imports) {
     // emit encoded params first
     if (encodedParams.length > 0) {
         text += '\treqQP := req.Raw().URL.Query()\n';
-        for (const qp of values(encodedParams.sort((a, b) => { return helpers.sortAscending(a.queryParameter, b.queryParameter); }))) {
+        for (const qp of encodedParams.sort((a, b) => { return helpers.sortAscending(a.queryParameter, b.queryParameter); })) {
             let setter;
             if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
                 setter = `\tfor _, qv := range ${helpers.getParamName(qp)} {\n`;
@@ -921,7 +919,7 @@ function createProtocolRequest(azureARM, method, imports) {
         else {
             text += '\tunencodedParams := []string{}\n';
         }
-        for (const qp of values(unencodedParams.sort((a, b) => { return helpers.sortAscending(a.queryParameter, b.queryParameter); }))) {
+        for (const qp of unencodedParams.sort((a, b) => { return helpers.sortAscending(a.queryParameter, b.queryParameter); })) {
             let setter;
             if (qp.kind === 'queryCollectionParam' && qp.collectionFormat === 'multi') {
                 setter = `\tfor _, qv := range ${helpers.getParamName(qp)} {\n`;
@@ -1016,7 +1014,7 @@ function createProtocolRequest(azureARM, method, imports) {
                     tagName = bodyParam.xml.name;
                 }
                 text += `\t\tXMLName xml.Name \`xml:"${tagName}"\`\n`;
-                const fieldName = capitalize(bodyParam.name);
+                const fieldName = naming.capitalize(bodyParam.name);
                 let tag = go.getTypeDeclaration(bodyParam.type.elementType, method.receiver.type.pkg);
                 if (bodyParam.type.elementType.kind === 'model' && bodyParam.type.elementType.xml?.name) {
                     tag = bodyParam.type.elementType.xml.name;
@@ -1029,10 +1027,11 @@ function createProtocolRequest(azureARM, method, imports) {
                 }
                 body = `wrapper{${fieldName}: ${addr}${body}}`;
             }
-            else if (bodyParam.type.kind === 'time' && bodyParam.type.format !== 'dateTimeRFC3339') {
+            else if (bodyParam.type.kind === 'time' && bodyParam.type.format !== 'RFC3339') {
                 // wrap the body in the internal time type
-                // no need for dateTimeRFC3339 as the JSON marshaler defaults to that.
-                body = `${bodyParam.type.format}(${body})`;
+                // no need for RFC3339 as the JSON marshaler defaults to that.
+                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                body = `datetime.${bodyParam.type.format}(${body})`;
             }
             else if (isArrayOfDateTimeForMarshalling(bodyParam.type)) {
                 const timeInfo = isArrayOfDateTimeForMarshalling(bodyParam.type);
@@ -1040,17 +1039,19 @@ function createProtocolRequest(azureARM, method, imports) {
                 if (timeInfo?.elemByVal) {
                     elementPtr = '';
                 }
-                text += `\taux := make([]${elementPtr}${timeInfo?.format}, len(${body}))\n`;
+                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                text += `\taux := make([]${elementPtr}datetime.${timeInfo?.format}, len(${body}))\n`;
                 text += `\tfor i := 0; i < len(${body}); i++ {\n`;
-                text += `\t\taux[i] = (${elementPtr}${timeInfo?.format})(${body}[i])\n`;
+                text += `\t\taux[i] = (${elementPtr}datetime.${timeInfo?.format})(${body}[i])\n`;
                 text += '\t}\n';
                 body = 'aux';
             }
             else if (isMapOfDateTime(bodyParam.type)) {
-                const timeType = isMapOfDateTime(bodyParam.type);
-                text += `\taux := map[string]*${timeType}{}\n`;
+                let timeType = isMapOfDateTime(bodyParam.type);
+                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                text += `\taux := map[string]*datetime.${timeType}{}\n`;
                 text += `\tfor k, v := range ${body} {\n`;
-                text += `\t\taux[k] = (*${timeType})(v)\n`;
+                text += `\t\taux[k] = (*datetime.${timeType})(v)\n`;
                 text += '\t}\n';
                 body = 'aux';
             }
@@ -1108,13 +1109,13 @@ function createProtocolRequest(azureARM, method, imports) {
         // define and instantiate an instance of the wire type, using the values from each param.
         text += '\tbody := struct {\n';
         for (const partialBodyParam of partialBodyParams) {
-            text += `\t\t${capitalize(partialBodyParam.serializedName)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, method.receiver.type.pkg)} \`${partialBodyParam.format.toLowerCase()}:"${partialBodyParam.serializedName}"\`\n`;
+            text += `\t\t${naming.capitalize(partialBodyParam.serializedName)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, method.receiver.type.pkg)} \`${partialBodyParam.format.toLowerCase()}:"${partialBodyParam.serializedName}"\`\n`;
         }
         text += '\t}{\n';
         // required params are emitted as initializers in the struct literal
         for (const partialBodyParam of partialBodyParams) {
             if (go.isRequiredParameter(partialBodyParam.style)) {
-                text += `\t\t${capitalize(partialBodyParam.serializedName)}: ${uncapitalize(partialBodyParam.name)},\n`;
+                text += `\t\t${naming.capitalize(partialBodyParam.serializedName)}: ${naming.uncapitalize(partialBodyParam.name)},\n`;
             }
         }
         text += '\t}\n';
@@ -1122,7 +1123,7 @@ function createProtocolRequest(azureARM, method, imports) {
         for (const partialBodyParam of partialBodyParams) {
             if (!go.isRequiredParameter(partialBodyParam.style)) {
                 text += emitParamGroupCheck(partialBodyParam);
-                text += `\t\tbody.${capitalize(partialBodyParam.serializedName)} = options.${capitalize(partialBodyParam.name)}\n\t}\n`;
+                text += `\t\tbody.${naming.capitalize(partialBodyParam.serializedName)} = options.${naming.capitalize(partialBodyParam.name)}\n\t}\n`;
             }
         }
         // TODO: spread params are JSON only https://github.com/Azure/autorest.go/issues/1455
@@ -1184,10 +1185,10 @@ function createProtocolRequest(azureARM, method, imports) {
     return text;
 }
 function emitClientSideDefault(param, csd, setterFormat, imports) {
-    const defaultVar = uncapitalize(param.name) + 'Default';
+    const defaultVar = naming.uncapitalize(param.name) + 'Default';
     let text = `\t${defaultVar} := ${helpers.formatLiteralValue(csd.defaultValue, true)}\n`;
-    text += `\tif options != nil && options.${capitalize(param.name)} != nil {\n`;
-    text += `\t\t${defaultVar} = *options.${capitalize(param.name)}\n`;
+    text += `\tif options != nil && options.${naming.capitalize(param.name)} != nil {\n`;
+    text += `\t\t${defaultVar} = *options.${naming.capitalize(param.name)}\n`;
     text += '}\n';
     let serializedName;
     switch (param.kind) {
@@ -1220,16 +1221,16 @@ function isArrayOfDateTimeForMarshalling(paramType) {
         return undefined;
     }
     switch (paramType.elementType.format) {
-        case 'dateType':
-        case 'dateTimeRFC1123':
-        case 'timeRFC3339':
-        case 'timeUnix':
+        case 'PlainDate':
+        case 'RFC1123':
+        case 'PlainTime':
+        case 'Unix':
             return {
                 format: paramType.elementType.format,
                 elemByVal: paramType.elementTypeByValue
             };
         default:
-            // dateTimeRFC3339 uses the default marshaller
+            // RFC3339 uses the default marshaller
             return undefined;
     }
 }
@@ -1238,12 +1239,13 @@ function isArrayOfDateTimeForMarshalling(paramType) {
 function needsResponseHandler(method) {
     return helpers.hasSchemaResponse(method) || method.returns.headers.length > 0;
 }
-function generateResponseUnmarshaller(method, type, format, unmarshalTarget) {
+function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imports) {
     let unmarshallerText = '';
     const zeroValue = getZeroReturnValue(method, 'handler');
     if (type.kind === 'time') {
         // use the designated time type for unmarshalling
-        unmarshallerText += `\tvar aux *${type.format}\n`;
+        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+        unmarshallerText += `\tvar aux *datetime.${type.format}\n`;
         unmarshallerText += `\tif err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
         unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
         unmarshallerText += '\t}\n';
@@ -1257,7 +1259,8 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget) {
         if (timeInfo?.elemByVal) {
             elementPtr = '';
         }
-        unmarshallerText += `\tvar aux []${elementPtr}${timeInfo?.format}\n`;
+        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+        unmarshallerText += `\tvar aux []${elementPtr}datetime.${timeInfo?.format}\n`;
         unmarshallerText += `\tif err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
         unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
         unmarshallerText += '\t}\n';
@@ -1269,7 +1272,9 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget) {
         return unmarshallerText;
     }
     else if (isMapOfDateTime(type)) {
-        unmarshallerText += `\taux := map[string]*${isMapOfDateTime(type)}{}\n`;
+        let timeType = isMapOfDateTime(type);
+        imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+        unmarshallerText += `\taux := map[string]*datetime.${timeType}{}\n`;
         unmarshallerText += `\tif err := runtime.UnmarshalAs${format}(resp, &aux); err != nil {\n`;
         unmarshallerText += `\t\treturn ${zeroValue}, err\n`;
         unmarshallerText += '\t}\n';
@@ -1313,10 +1318,10 @@ function createProtocolResponse(method, imports) {
         return '';
     }
     const name = method.naming.responseMethod;
-    let text = `${comment(name, '// ')} handles the ${method.name} response.\n`;
+    let text = `${helpers.comment(name, '// ')} handles the ${method.name} response.\n`;
     text += `func ${getClientReceiverDefinition(method.receiver)} ${name}(resp *http.Response) (${generateReturnsInfo(method, 'handler').join(', ')}) {\n`;
     const addHeaders = function (headers) {
-        for (const header of values(headers)) {
+        for (const header of headers) {
             text += formatHeaderResponseValue(header, imports, 'result', `${method.returns.name}{}`);
         }
     };
@@ -1341,7 +1346,7 @@ function createProtocolResponse(method, imports) {
                         continue;
                     }
                     text += `\tvar val ${go.getTypeDeclaration(resultType, method.receiver.type.pkg)}\n`;
-                    text += generateResponseUnmarshaller(method, resultType, result.format, 'val');
+                    text += generateResponseUnmarshaller(method, resultType, result.format, 'val', imports);
                     text += '\tresult.Value = val\n';
                 }
                 text += '\tdefault:\n';
@@ -1359,7 +1364,7 @@ function createProtocolResponse(method, imports) {
             case 'modelResult':
                 text += `\tresult := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
-                text += generateResponseUnmarshaller(method, result.modelType, result.format, `result.${helpers.getResultFieldName(method)}`);
+                text += generateResponseUnmarshaller(method, result.modelType, result.format, `result.${helpers.getResultFieldName(method)}`, imports);
                 break;
             case 'monomorphicResult':
                 text += `\tresult := ${method.returns.name}{}\n`;
@@ -1369,12 +1374,12 @@ function createProtocolResponse(method, imports) {
                 if (result.format === 'XML' && result.monomorphicType.kind === 'slice') {
                     target = 'result';
                 }
-                text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target);
+                text += generateResponseUnmarshaller(method, result.monomorphicType, result.format, target, imports);
                 break;
             case 'polymorphicResult':
                 text += `\tresult := ${method.returns.name}{}\n`;
                 addHeaders(method.returns.headers);
-                text += generateResponseUnmarshaller(method, result.interface, result.format, 'result');
+                text += generateResponseUnmarshaller(method, result.interface, result.format, 'result', imports);
                 break;
             default:
                 result;
@@ -1429,11 +1434,11 @@ function getAPIParametersSig(method, imports) {
             imports.add('context');
             params.push('ctx context.Context');
         }
-        for (const methodParam of values(methodParams)) {
+        for (const methodParam of methodParams) {
             if (methodParam.kind !== 'paramGroup') {
                 imports.addForType(methodParam.type);
             }
-            params.push(`${uncapitalize(methodParam.name)} ${helpers.formatParameterTypeName(method.receiver.type.pkg, methodParam)}`);
+            params.push(`${naming.uncapitalize(methodParam.name)} ${helpers.formatParameterTypeName(method.receiver.type.pkg, methodParam)}`);
         }
     }
     return params.join(', ');
@@ -1492,7 +1497,7 @@ function generateLROBeginMethod(method, imports, options) {
     }
     const zeroResp = getZeroReturnValue(method, 'api');
     const methodParams = helpers.getMethodParameters(method);
-    for (const param of values(methodParams)) {
+    for (const param of methodParams) {
         text += helpers.formatCommentAsBulletItem(param.name, param.docs);
     }
     text += `func ${getClientReceiverDefinition(method.receiver)} ${fixUpMethodName(method)}(${params}) (${returns.join(', ')}) {\n`;