@azure-tools/typespec-go 0.5.1 → 0.6.0

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

@@ -335,11 +335,11 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
                     content += '\t})\n';
                 }
                 else if (method.responseEnvelope.result.kind === 'monomorphicResult') {
-                    if (go.isBytesType(method.responseEnvelope.result.monomorphicType)) {
+                    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 (go.isSliceType(method.responseEnvelope.result.monomorphicType) && method.responseEnvelope.result.monomorphicType.rawJSONAsBytes) {
+                    else if (method.responseEnvelope.result.monomorphicType.kind === 'rawJSON') {
                         imports.add('bytes');
                         imports.add('io');
                         content += '\tresp, err := server.NewResponse(respContent, req, &server.ResponseOptions{\n';
@@ -348,13 +348,13 @@ function generateServerTransportMethods(codeModel, serverTransport, finalMethods
                     }
                     else {
                         let respField = `.${getResultFieldName(method.responseEnvelope.result)}`;
-                        if (method.responseEnvelope.result.format === 'XML' && go.isSliceType(method.responseEnvelope.result.monomorphicType)) {
+                        if (method.responseEnvelope.result.format === 'XML' && method.responseEnvelope.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 (go.isTimeType(method.responseEnvelope.result.monomorphicType)) {
-                            responseField = `(*${method.responseEnvelope.result.monomorphicType.dateTimeFormat})(${responseField})`;
+                        if (method.responseEnvelope.result.monomorphicType.kind === 'time') {
+                            responseField = `(*${method.responseEnvelope.result.monomorphicType.format})(${responseField})`;
                         }
                         content += `\tresp, err := server.MarshalResponseAs${method.responseEnvelope.result.format}(respContent, ${responseField}, req)\n`;
                     }
@@ -421,29 +421,31 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
             case 'XML':
                 if (bodyParam && !go.isLiteralParameter(bodyParam)) {
                     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake', 'azfake');
-                    if (go.isBytesType(bodyParam.type)) {
-                        content += `\tbody, err := server.UnmarshalRequestAsByteArray(req, runtime.Base64${bodyParam.type.encoding}Format)\n`;
-                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-                    }
-                    else if (go.isSliceType(bodyParam.type) && bodyParam.type.rawJSONAsBytes) {
-                        content += '\tbody, err := io.ReadAll(req.Body)\n';
-                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-                        content += '\treq.Body.Close()\n';
-                    }
-                    else if (go.isInterfaceType(bodyParam.type)) {
-                        requiredHelpers.readRequestBody = true;
-                        content += '\traw, err := readRequestBody(req)\n';
-                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-                        content += `\tbody, err := unmarshal${bodyParam.type.name}(raw)\n`;
-                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-                    }
-                    else {
-                        let bodyTypeName = go.getTypeDeclaration(bodyParam.type, clientPkg);
-                        if (go.isTimeType(bodyParam.type)) {
-                            bodyTypeName = bodyParam.type.dateTimeFormat;
+                    switch (bodyParam.type.kind) {
+                        case 'encodedBytes':
+                            content += `\tbody, err := server.UnmarshalRequestAsByteArray(req, runtime.Base64${bodyParam.type.encoding}Format)\n`;
+                            content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                            break;
+                        case 'interface':
+                            requiredHelpers.readRequestBody = true;
+                            content += '\traw, err := readRequestBody(req)\n';
+                            content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                            content += `\tbody, err := unmarshal${bodyParam.type.name}(raw)\n`;
+                            content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                            break;
+                        case 'rawJSON':
+                            content += '\tbody, err := io.ReadAll(req.Body)\n';
+                            content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
+                            content += '\treq.Body.Close()\n';
+                            break;
+                        default: {
+                            let bodyTypeName = go.getTypeDeclaration(bodyParam.type, clientPkg);
+                            if (bodyParam.type.kind === 'time') {
+                                bodyTypeName = bodyParam.type.format;
+                            }
+                            content += `\tbody, err := server.UnmarshalRequestAs${bodyParam.bodyFormat}[${bodyTypeName}](req)\n`;
+                            content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
                         }
-                        content += `\tbody, err := server.UnmarshalRequestAs${bodyParam.bodyFormat}[${bodyTypeName}](req)\n`;
-                        content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
                     }
                 }
                 break;
@@ -466,8 +468,12 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         content += '\treader := multipart.NewReader(req.Body, params["boundary"])\n';
         for (const param of multipartBodyParams) {
             let pkgPrefix = '';
-            if (go.isConstantType(param.type) || go.isModelType(param.type)) {
-                pkgPrefix = clientPkg + '.';
+            switch (param.type.kind) {
+                case 'constant':
+                case 'model':
+                case 'polymorphicModel':
+                    pkgPrefix = clientPkg + '.';
+                    break;
             }
             content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
         }
@@ -515,23 +521,26 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         };
         const isMultipartContentType = function (type) {
             type = helpers.recursiveUnwrapMapSlice(type);
-            return (go.isQualifiedType(type) && type.exportName === 'MultipartContent');
+            return (type.kind === 'qualifiedType' && type.exportName === 'MultipartContent');
+        };
+        const isModelType = function (type) {
+            return type.kind === 'model' || type.kind === 'polymorphicModel';
         };
         const emitCase = function (caseValue, paramVar, type) {
             let caseContent = `\t\tcase "${caseValue}":\n`;
             caseContent += '\t\t\tcontent, err = io.ReadAll(part)\n';
             caseContent += '\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n';
             let assignedValue;
-            if (go.isModelType(helpers.recursiveUnwrapMapSlice(type))) {
+            if (isModelType(helpers.recursiveUnwrapMapSlice(type))) {
                 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 (go.isQualifiedType(type) && type.exportName === 'ReadSeekCloser') {
+            else if (type.kind === 'qualifiedType' && type.exportName === 'ReadSeekCloser') {
                 imports.add('bytes');
                 imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
                 assignedValue = 'streaming.NopCloser(bytes.NewReader(content))';
             }
-            else if (go.isConstantType(type)) {
+            else if (type.kind === 'constant') {
                 let from;
                 switch (type.type) {
                     case 'bool':
@@ -548,12 +557,12 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                 }
                 assignedValue = `${clientPkg}.${type.name}(${from})`;
             }
-            else if (go.isPrimitiveType(type)) {
-                switch (type.typeName) {
+            else if (type.kind === 'scalar') {
+                switch (type.type) {
                     case 'bool':
                         imports.add('strconv');
                         // ParseBool happens in place, so no need to set assignedValue
-                        caseContent += parsePrimitiveType(type.typeName, paramVar);
+                        caseContent += parsePrimitiveType(type.type, paramVar);
                         break;
                     case 'float32':
                     case 'float64':
@@ -561,23 +570,23 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                     case 'int16':
                     case 'int32':
                     case 'int64':
-                        caseContent += parsePrimitiveType(type.typeName);
-                        assignedValue = `${type.typeName}(parsed)`;
-                        break;
-                    case 'string':
-                        assignedValue = 'string(content)';
+                        caseContent += parsePrimitiveType(type.type);
+                        assignedValue = `${type.type}(parsed)`;
                         break;
                     default:
-                        throw new CodegenError('InternalError', `unhandled multipart parameter primitive type ${type.typeName}`);
+                        throw new CodegenError('InternalError', `unhandled multipart parameter primitive type ${type.type}`);
                 }
             }
+            else if (type.kind === 'string') {
+                assignedValue = 'string(content)';
+            }
             else if (isMultipartContentType(type)) {
                 imports.add('bytes');
                 imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
                 const bodyContent = 'streaming.NopCloser(bytes.NewReader(content))';
                 const contentType = 'part.Header.Get("Content-Type")';
                 const filename = 'part.FileName()';
-                if (go.isSliceType(type)) {
+                if (type.kind === 'slice') {
                     caseContent += `\t\t\t${paramVar} = append(${paramVar}, streaming.MultipartContent{\n`;
                     caseContent += `\t\t\t\tBody: ${bodyContent},\n`;
                     caseContent += `\t\t\t\tContentType: ${contentType},\n`;
@@ -590,18 +599,18 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
                     caseContent += `\t\t\t${paramVar}.Filename = ${filename}\n`;
                 }
             }
-            else if (go.isSliceType(type)) {
-                if (go.isQualifiedType(type.elementType) && type.elementType.exportName === 'ReadSeekCloser') {
+            else if (type.kind === 'slice') {
+                if (type.elementType.kind === 'qualifiedType' && type.elementType.exportName === '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', `uhandled multipart parameter array element type ${go.getTypeDeclaration(type.elementType)}`);
+                    throw new CodegenError('InternalError', `uhandled multipart parameter array element kind ${type.elementType.kind}`);
                 }
             }
             else {
-                throw new CodegenError('InternalError', `uhandled multipart parameter type ${go.getTypeDeclaration(type)}`);
+                throw new CodegenError('InternalError', `uhandled multipart parameter kind ${type.kind}`);
             }
             if (assignedValue) {
                 caseContent += `\t\t\t${paramVar} = ${assignedValue}\n`;
@@ -609,7 +618,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
             return caseContent;
         };
         for (const param of multipartBodyParams) {
-            if (go.isModelType(param.type)) {
+            if (isModelType(param.type)) {
                 for (const field of param.type.fields) {
                     content += emitCase(field.serializedName, `${param.name}.${field.name}`, field.type);
                 }
@@ -625,7 +634,7 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
     else if (formBodyParams.length > 0) {
         for (const param of formBodyParams) {
             let pkgPrefix = '';
-            if (go.isConstantType(param.type)) {
+            if (param.type.kind === 'constant') {
                 pkgPrefix = clientPkg + '.';
             }
             content += `\tvar ${param.name} ${pkgPrefix}${go.getTypeDeclaration(param.type)}\n`;
@@ -636,14 +645,15 @@ function dispatchForOperationBody(clientPkg, receiverName, method, imports) {
         for (const param of formBodyParams) {
             content += `\t\tcase "${param.formDataName}":\n`;
             let assignedValue;
-            if (go.isConstantType(param.type)) {
-                assignedValue = `${go.getTypeDeclaration(param.type, clientPkg)}(req.FormValue(key))`;
-            }
-            else if (go.isPrimitiveType(param.type) && param.type.typeName === 'string') {
-                assignedValue = 'req.FormValue(key)';
-            }
-            else {
-                throw new CodegenError('InternalError', `uhandled form parameter type ${go.getTypeDeclaration(param.type)}`);
+            switch (param.type.kind) {
+                case 'constant':
+                    assignedValue = `${go.getTypeDeclaration(param.type, clientPkg)}(req.FormValue(key))`;
+                    break;
+                case 'string':
+                    assignedValue = 'req.FormValue(key)';
+                    break;
+                default:
+                    throw new CodegenError('InternalError', `uhandled form parameter kind ${param.type.kind}`);
             }
             content += `\t\t\t${param.name} = ${assignedValue}\n`;
         }
@@ -833,7 +843,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             const escapedParam = createLocalVariableName(param, 'Escaped');
             content += `\t${escapedParam} := ${paramValue}\n`;
             let paramVar = createLocalVariableName(param, 'Unescaped');
-            if (go.isPrimitiveType(param.type.elementType) && param.type.elementType.typeName === 'string') {
+            if (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
                 // else requires some amount of parsing/conversion.
@@ -856,7 +866,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 where = 'Query';
             }
             let paramVar = createLocalVariableName(param, 'Unescaped');
-            if (go.isRequiredParameter(param) && go.isConstantType(param.type) && param.type.type === 'string') {
+            if (go.isRequiredParameter(param) && 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');
@@ -867,8 +877,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             }
             else {
                 if (go.isRequiredParameter(param) &&
-                    ((go.isPrimitiveType(param.type) && param.type.typeName === 'string') ||
-                        (go.isSliceType(param.type) && go.isPrimitiveType(param.type.elementType) && param.type.elementType.typeName === 'string'))) {
+                    (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
                     // else requires some amount of parsing/conversion.
@@ -882,7 +891,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
         // parse params as required
         if (param.kind === 'headerCollectionParam' || param.kind === 'pathCollectionParam' || param.kind === 'queryCollectionParam') {
             // any element type other than string will require some form of conversion/parsing
-            if (!(go.isPrimitiveType(param.type.elementType) && param.type.elementType.typeName === 'string')) {
+            if (param.type.elementType.kind !== 'string') {
                 if (param.collectionFormat !== 'multi') {
                     requiredHelpers.splitHelper = true;
                     const elementsParam = createLocalVariableName(param, 'Elements');
@@ -891,23 +900,22 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 }
                 const paramVar = createLocalVariableName(param, 'Param');
                 let elementFormat;
-                if (go.isConstantType(param.type.elementType)) {
-                    elementFormat = param.type.elementType.type;
-                }
-                else if (go.isPrimitiveType(param.type.elementType)) {
-                    elementFormat = param.type.elementType.typeName;
-                }
-                else if (go.isBytesType(param.type.elementType)) {
-                    elementFormat = param.type.elementType.encoding;
-                }
-                else if (go.isTimeType(param.type.elementType)) {
-                    elementFormat = param.type.elementType.dateTimeFormat;
-                }
-                else {
-                    throw new CodegenError('InternalError', `unhandled element type ${go.getTypeDeclaration(param.type.elementType)}`);
+                switch (param.type.elementType.kind) {
+                    case 'constant':
+                    case 'scalar':
+                        elementFormat = param.type.elementType.type;
+                        break;
+                    case 'encodedBytes':
+                        elementFormat = param.type.elementType.encoding;
+                        break;
+                    case 'time':
+                        elementFormat = param.type.elementType.format;
+                        break;
+                    default:
+                        throw new CodegenError('InternalError', `unhandled element kind ${param.type.elementType.kind}`);
                 }
                 let toType = go.getTypeDeclaration(param.type.elementType);
-                if (go.isConstantType(param.type.elementType)) {
+                if (param.type.elementType.kind === 'constant') {
                     toType = `${clientPkg}.${toType}`;
                 }
                 content += `\t${paramVar} := make([]${toType}, len(${paramValue}))\n`;
@@ -968,7 +976,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 content += `\t${createLocalVariableName(param, 'Param')} := splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")\n`;
             }
         }
-        else if (go.isPrimitiveType(param.type) && param.type.typeName === 'bool') {
+        else if (param.type.kind === 'scalar' && param.type.type === 'bool') {
             imports.add('strconv');
             let from = `strconv.ParseBool(${paramValue})`;
             if (!go.isRequiredParameter(param)) {
@@ -978,16 +986,16 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             content += `\t${createLocalVariableName(param, 'Param')}, err := ${from}\n`;
             content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         }
-        else if (go.isBytesType(param.type)) {
+        else if (param.type.kind === 'encodedBytes') {
             imports.add('encoding/base64');
             content += `\t${createLocalVariableName(param, 'Param')}, err := base64.${param.type.encoding}Encoding.DecodeString(${paramValue})\n`;
             content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         }
-        else if (go.isTimeType(param.type)) {
-            if (param.type.dateTimeFormat === 'dateType' || param.type.dateTimeFormat === 'timeRFC3339') {
+        else if (param.type.kind === 'time') {
+            if (param.type.format === 'dateType' || param.type.format === 'timeRFC3339') {
                 imports.add('time');
                 let format = helpers.dateFormat;
-                if (param.type.dateTimeFormat === 'timeRFC3339') {
+                if (param.type.format === 'timeRFC3339') {
                     format = helpers.timeRFC3339Format;
                 }
                 let from = `time.Parse("${format}", ${paramValue})`;
@@ -998,10 +1006,10 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 content += `\t${createLocalVariableName(param, 'Param')}, err := ${from}\n`;
                 content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
             }
-            else if (param.type.dateTimeFormat === 'dateTimeRFC1123' || param.type.dateTimeFormat === 'dateTimeRFC3339') {
+            else if (param.type.format === 'dateTimeRFC1123' || param.type.format === 'dateTimeRFC3339') {
                 imports.add('time');
                 let format = 'time.RFC3339Nano';
-                if (param.type.dateTimeFormat === 'dateTimeRFC1123') {
+                if (param.type.format === 'dateTimeRFC1123') {
                     format = 'time.RFC1123';
                 }
                 let from = `time.Parse(${format}, ${paramValue})`;
@@ -1030,7 +1038,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
             }
         }
-        else if (go.isPrimitiveType(param.type) && (param.type.typeName === 'float32' || param.type.typeName === 'float64' || param.type.typeName === 'int32' || param.type.typeName === 'int64')) {
+        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)) {
                 requiredHelpers.parseOptional = true;
@@ -1040,18 +1048,18 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
                 requiredHelpers.parseWithCast = true;
                 parser = 'parseWithCast';
             }
-            if ((param.type.typeName === 'float32' || param.type.typeName === 'int32') || !go.isRequiredParameter(param)) {
-                content += `\t${createLocalVariableName(param, 'Param')}, err := ${parser}(${paramValue}, func(v string) (${param.type.typeName}, error) {\n`;
-                content += `\t\tp, parseErr := ${emitNumericConversion('v', param.type.typeName)}\n`;
+            if ((param.type.type === 'float32' || param.type.type === 'int32') || !go.isRequiredParameter(param)) {
+                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';
                 let result = 'p';
-                if (param.type.typeName === 'float32' || param.type.typeName === 'int32') {
-                    result = `${param.type.typeName}(${result})`;
+                if (param.type.type === 'float32' || param.type.type === 'int32') {
+                    result = `${param.type.type}(${result})`;
                 }
                 content += `\t\treturn ${result}, nil\n\t})\n`;
             }
             else {
-                content += `\t${createLocalVariableName(param, 'Param')}, err := ${emitNumericConversion(paramValue, param.type.typeName)}\n`;
+                content += `\t${createLocalVariableName(param, 'Param')}, err := ${emitNumericConversion(paramValue, param.type.type)}\n`;
             }
             content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         }
@@ -1068,7 +1076,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             content += `\t\t\t${localVar}[hh[len("${headerPrefix}"):]] = to.Ptr(getHeaderValue(req.Header, hh))\n`;
             content += '\t\t}\n\t}\n';
         }
-        else if (go.isConstantType(param.type) && param.type.type !== 'string') {
+        else if (param.type.kind === 'constant' && param.type.type !== 'string') {
             let parseHelper;
             if (!go.isRequiredParameter(param)) {
                 requiredHelpers.parseOptional = true;
@@ -1100,7 +1108,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
         else if (!go.isRequiredParameter(param)) {
             // we check this last as it's a superset of the previous conditions
             requiredHelpers.getOptional = true;
-            if (go.isConstantType(param.type)) {
+            if (param.type.kind === 'constant') {
                 paramValue = `${go.getTypeDeclaration(param.type, clientPkg)}(${paramValue})`;
             }
             content += `\t${createLocalVariableName(param, 'Param')} := getOptional(${paramValue})\n`;
@@ -1121,7 +1129,7 @@ function parseHeaderPathQueryParams(clientPkg, method, imports) {
             const paramNilCheck = new Array();
             for (const param of values(params)) {
                 // check array before body in case the body is just an array
-                if (go.isSliceType(param.type)) {
+                if (param.type.kind === 'slice') {
                     paramNilCheck.push(`len(${getFinalParamValue(clientPkg, param, paramValues)}) > 0`);
                 }
                 else if (param.kind === 'bodyParam') {
@@ -1241,7 +1249,7 @@ function getFinalParamValue(clientPkg, param, paramValues) {
         paramValue = getRawParamValue(param);
     }
     // there are a few corner-cases that require some fix-ups
-    if ((param.kind === 'bodyParam' || go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') && go.isTimeType(param.type)) {
+    if ((param.kind === 'bodyParam' || go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') && param.type.kind === 'time') {
         // time types in the body have been unmarshalled into our time helpers thus require a cast to time.Time
         return `time.Time(${paramValue})`;
     }
@@ -1250,12 +1258,12 @@ function getFinalParamValue(clientPkg, param, paramValues) {
         if (param.kind === 'headerCollectionParam' || param.kind === 'pathCollectionParam' || param.kind === 'queryCollectionParam') {
             // for required params that are collections of strings, we split them inline.
             // not necessary for optional params as they're already in slice format.
-            if (param.collectionFormat !== 'multi' && go.isPrimitiveType(param.type.elementType) && param.type.elementType.typeName === 'string') {
+            if (param.collectionFormat !== 'multi' && param.type.elementType.kind === 'string') {
                 requiredHelpers.splitHelper = true;
                 return `splitHelper(${paramValue}, "${helpers.getDelimiterForCollectionFormat(param.collectionFormat)}")`;
             }
         }
-        else if (go.isHeaderParameter(param) && go.isConstantType(param.type) && param.type.type === 'string') {
+        else if (go.isHeaderParameter(param) && param.type.kind === 'constant' && param.type.type === 'string') {
             // since headers aren't escaped, we cast required, string-based enums inline
             return `${go.getTypeDeclaration(param.type, clientPkg)}(${paramValue})`;
         }
@@ -1315,7 +1323,7 @@ function getResultFieldName(result) {
         case 'modelResult':
             return result.modelType.name;
         case 'polymorphicResult':
-            return result.interfaceType.name;
+            return result.interface.name;
         default:
             return result.fieldName;
     }