@azure-tools/typespec-rust 0.1.0 → 0.2.0

package/dist/src/tcgcadapter/adapter.js

@@ -8,10 +8,21 @@ import * as helpers from './helpers.js';
 import * as naming from './naming.js';
 import * as tcgc from '@azure-tools/typespec-client-generator-core';
 import * as rust from '../codemodel/index.js';
-// Adapter converts the tcgc code model to a Rust Crate
+/** Adapter converts the tcgc code model to a Rust Crate */
 export class Adapter {
+    /**
+     * Creates an Adapter for the specified EmitContext.
+     *
+     * @param context the compiler context from which to create the Adapter
+     * @returns
+     */
     static async create(context) {
-        const ctx = await tcgc.createSdkContext(context);
+        // @encodedName can be used in XML scenarios, it is effectively the
+        // same as TypeSpec.Xml.@name. however, it's filtered out by default
+        // so we need to add it to the allow list of decorators
+        const ctx = await tcgc.createSdkContext(context, '@azure-tools/typespec-rust', {
+            additionalDecorators: ['TypeSpec\\.@encodedName'],
+        });
         return new Adapter(ctx, context.options);
     }
     constructor(ctx, options) {
@@ -24,20 +35,38 @@ export class Adapter {
         }
         this.crate = new rust.Crate(options['crate-name'], options['crate-version'], serviceType);
     }
-    // performs all the steps to convert tcgc to a crate
+    /** performs all the steps to convert tcgc to a crate */
     tcgcToCrate() {
         this.adaptTypes();
         this.adaptClients();
         if (this.crate.enums.length > 0 || this.crate.models.length > 0) {
             this.crate.addDependency(new rust.CrateDependency('serde'));
         }
+        if (this.crate.enums.length > 0 || this.crate.models.length > 0) {
+            this.crate.addDependency(new rust.CrateDependency('typespec_client_core'));
+        }
         if (this.crate.clients.length > 0) {
             this.crate.addDependency(new rust.CrateDependency('async-std'));
         }
+        // TODO: remove once https://github.com/Azure/typespec-rust/issues/22 is fixed
+        for (const client of this.crate.clients) {
+            let done = false;
+            for (const method of client.methods) {
+                if (method.kind === 'pageable') {
+                    this.crate.addDependency(new rust.CrateDependency('futures'));
+                    done = true;
+                    break;
+                }
+            }
+            if (done) {
+                break;
+            }
+        }
+        // end TODO
         this.crate.sortContent();
         return this.crate;
     }
-    // converts all tcgc types to their Rust type equivalent
+    /** converts all tcgc types to their Rust type equivalent */
     adaptTypes() {
         for (const sdkEnum of this.ctx.sdkPackage.enums) {
             if ((sdkEnum.usage & tcgc.UsageFlags.ApiVersionEnum) === tcgc.UsageFlags.ApiVersionEnum) {
@@ -49,16 +78,20 @@ export class Adapter {
             this.crate.enums.push(rustEnum);
         }
         for (const model of this.ctx.sdkPackage.models) {
-            if (model.usage === tcgc.UsageFlags.Error) {
-                // if the model is purely used for errors then
-                // skip it as we use azure_core::Error.
+            if ((model.usage & tcgc.UsageFlags.Error) === tcgc.UsageFlags.Error || tcgc.isAzureCoreModel(model)) {
+                // skip error and core types as we use their azure_core equivalents
                 continue;
             }
             const rustModel = this.getModel(model);
             this.crate.models.push(rustModel);
         }
     }
-    // converts a tcgc enum to a Rust enum
+    /**
+     * converts a tcgc enum to a Rust enum
+     *
+     * @param sdkEnum the tcgc enum to convert
+     * @returns a Rust enum
+     */
     getEnum(sdkEnum) {
         const enumName = codegen.capitalize(sdkEnum.name);
         let rustEnum = this.types.get(enumName);
@@ -71,11 +104,16 @@ export class Adapter {
             const rustEnumValue = new rust.EnumValue(helpers.fixUpEnumValueName(value.name), value.value);
             values.push(rustEnumValue);
         }
-        rustEnum = new rust.Enum(enumName, isPub(sdkEnum.access), values, !sdkEnum.isFixed);
+        rustEnum = new rust.Enum(enumName, sdkEnum.access === 'public', values, !sdkEnum.isFixed);
         this.types.set(enumName, rustEnum);
         return rustEnum;
     }
-    // converts a tcgc model to a Rust model
+    /**
+     * converts a tcgc model to a Rust model
+     *
+     * @param model the tcgc model to convert
+     * @returns a Rust model
+     */
     getModel(model) {
         if (model.name.length === 0) {
             throw new Error('unnamed model'); // TODO: this might no longer be an issue
@@ -85,29 +123,51 @@ export class Adapter {
         if (rustModel) {
             return rustModel;
         }
-        rustModel = new rust.Model(modelName, isPub(model.access));
+        rustModel = new rust.Model(modelName, model.access === 'internal');
         rustModel.docs.summary = model.summary;
         rustModel.docs.description = model.doc;
+        rustModel.xmlName = getXMLName(model.decorators);
         this.types.set(modelName, rustModel);
         for (const property of model.properties) {
             if (property.kind !== 'property') {
+                if (property.type.kind === 'constant') {
+                    // typical case is content-type header.
+                    // we don't need to emit this as a field so skip it.
+                    continue;
+                }
                 // TODO: https://github.com/Azure/typespec-rust/issues/96
                 throw new Error(`model property kind ${property.kind} NYI`);
             }
-            const structField = this.getModelField(property);
+            const structField = this.getModelField(property, !rustModel.internal);
             rustModel.fields.push(structField);
         }
         return rustModel;
     }
-    // converts a tcgc model property to a model field
-    getModelField(property) {
-        const fieldType = new rust.Option(this.getType(property.type), false);
+    /**
+     * converts a tcgc model property to a model field
+     *
+     * @param property the tcgc model property to convert
+     * @param isPubMod indicates if the model is public
+     * @returns a Rust model field
+     */
+    getModelField(property, isPubMod) {
+        let fieldType = this.getType(property.type);
+        // for public models each field is always an Option<T>
+        if (isPubMod || property.optional) {
+            fieldType = new rust.Option(fieldType);
+        }
         const modelField = new rust.ModelField(naming.getEscapedReservedName(snakeCaseName(property.name), 'prop'), property.serializedName, true, fieldType);
         modelField.docs.summary = property.summary;
         modelField.docs.description = property.doc;
+        const xmlName = getXMLName(property.decorators);
+        if (xmlName) {
+            // use the XML name when specified
+            modelField.serde = xmlName;
+        }
+        modelField.xmlKind = getXMLKind(property.decorators, modelField);
         return modelField;
     }
-    // converts a tcgc type to a Rust type
+    /** converts a tcgc type to a Rust type */
     getType(type) {
         const getScalar = (kind) => {
             let scalar = this.types.get(kind);
@@ -233,6 +293,7 @@ export class Adapter {
                 throw new Error(`unhandled tcgc type ${type.kind}`);
         }
     }
+    /** returns the Rust unit type */
     getUnitType() {
         const typeKey = 'rust-unit';
         let unitType = this.types.get(typeKey);
@@ -243,6 +304,12 @@ export class Adapter {
         this.types.set(typeKey, unitType);
         return unitType;
     }
+    /**
+     * converts a tcgc constant to a Rust literal
+     *
+     * @param constType the constant to convert
+     * @returns a Rust literal
+     */
     getLiteral(constType) {
         const literalKey = `literal-${constType.value}`;
         let literalType = this.types.get(literalKey);
@@ -253,7 +320,7 @@ export class Adapter {
         this.types.set(literalKey, literalType);
         return literalType;
     }
-    // converts all tcgc clients and their methods into Rust clients/methods
+    /** converts all tcgc clients and their methods into Rust clients/methods */
     adaptClients() {
         for (const client of this.ctx.sdkPackage.clients) {
             if (client.methods.length === 0) {
@@ -266,8 +333,14 @@ export class Adapter {
             }
         }
     }
-    // recursively adapts a client and its methods.
-    // this simplifies the case for hierarchical clients.
+    /**
+     * recursively converts a client and its methods.
+     * this simplifies the case for hierarchical clients.
+     *
+     * @param client the tcgc client to recursively convert
+     * @param parent contains the parent Rust client when converting a child client
+     * @returns a Rust client
+     */
     recursiveAdaptClient(client, parent) {
         let clientName = client.name;
         if (parent) {
@@ -287,8 +360,7 @@ export class Adapter {
             // strip off the Client suffix from the parent client name
             clientName = parent.name.substring(0, parent.name.length - 6) + clientName;
         }
-        // only add the Client suffix to instantiable clients
-        if (!clientName.match(/Client$/) && !parent) {
+        if (!clientName.match(/Client$/)) {
             clientName += 'Client';
         }
         const rustClient = new rust.Client(clientName);
@@ -298,7 +370,7 @@ export class Adapter {
         // anything other than public means non-instantiable client
         if (client.initialization.access === 'public') {
             const clientOptionsStruct = new rust.Struct(`${rustClient.name}Options`, true);
-            const clientOptionsField = new rust.StructField('client_options', false, new rust.ExternalType(this.crate, 'azure_core', 'ClientOptions'));
+            const clientOptionsField = new rust.StructField('client_options', true, new rust.ExternalType(this.crate, 'azure_core', 'ClientOptions'));
             clientOptionsField.defaultValue = 'ClientOptions::default()';
             clientOptionsStruct.fields.push(clientOptionsField);
             rustClient.constructable = new rust.ClientConstruction(new rust.ClientOptions(clientOptionsStruct));
@@ -346,14 +418,14 @@ export class Adapter {
                                 break;
                             case 'union':
                                 // TODO: https://github.com/Azure/typespec-rust/issues/57
-                                throw new Error('credential unions NYI');
+                                continue;
                         }
                         break;
                     case 'endpoint':
                         // for Rust, we always require a complete endpoint param, templated
                         // endpoints, e.g. https://{something}.contoso.com isn't supported.
                         // note that the types of the param and the field are slightly different
-                        ctorParams.push(new rust.ClientParameter(param.name, new rust.ImplTrait('AsRef', new rust.StringSlice())));
+                        ctorParams.push(new rust.ClientParameter(param.name, new rust.StringSlice(), true));
                         rustClient.fields.push(new rust.ClientParameter(param.name, new rust.Url(this.crate)));
                         break;
                     case 'method': {
@@ -370,7 +442,7 @@ export class Adapter {
                         const paramName = snakeCaseName(param.name);
                         rustClient.fields.push(new rust.ClientParameter(paramName, new rust.StringType()));
                         // client-side default value makes the param optional
-                        const apiVersionField = new rust.StructField(paramName, false, new rust.StringType());
+                        const apiVersionField = new rust.StructField(paramName, true, new rust.StringType());
                         apiVersionField.defaultValue = `String::from("${param.clientDefaultValue}")`;
                         clientOptionsStruct.fields.push(apiVersionField);
                         break;
@@ -400,7 +472,7 @@ export class Adapter {
         for (const method of client.methods) {
             if (method.kind === 'clientaccessor') {
                 const subClient = this.recursiveAdaptClient(method.response, rustClient);
-                rustClient.methods.push(new rust.ClientAccessor(`get_${snakeCaseName(subClient.name)}_client`, rustClient, subClient));
+                rustClient.methods.push(new rust.ClientAccessor(`get_${snakeCaseName(subClient.name)}`, rustClient, subClient));
             }
             else {
                 this.adaptMethod(method, rustClient);
@@ -409,7 +481,12 @@ export class Adapter {
         this.crate.clients.push(rustClient);
         return rustClient;
     }
-    // converts method into a rust.Method for the specified rust.Client
+    /**
+     * converts a tcgc method to a Rust method for the specified client
+     *
+     * @param method the tcgc method to convert
+     * @param rustClient the client to which the method belongs
+     */
     adaptMethod(method, rustClient) {
         let rustMethod;
         const optionsLifetime = new rust.Lifetime('a');
@@ -417,16 +494,31 @@ export class Adapter {
         methodOptionsStruct.lifetime = optionsLifetime;
         const clientMethodOptions = new rust.ExternalType(this.crate, 'azure_core', 'ClientMethodOptions');
         clientMethodOptions.lifetime = optionsLifetime;
-        methodOptionsStruct.fields.push(new rust.StructField('method_options', false, clientMethodOptions));
+        methodOptionsStruct.fields.push(new rust.StructField('method_options', true, clientMethodOptions));
+        const methodName = naming.getEscapedReservedName(snakeCaseName(method.name), 'fn');
+        const pub = method.access === 'public';
+        const methodOptions = new rust.MethodOptions(methodOptionsStruct);
         const httpMethod = method.operation.verb;
         const httpPath = method.operation.path;
         switch (method.kind) {
             case 'basic':
-                rustMethod = new rust.AsyncMethod(naming.getEscapedReservedName(snakeCaseName(method.name), 'fn'), rustClient, isPub(method.access), new rust.MethodOptions(methodOptionsStruct, false), httpMethod, httpPath);
+                rustMethod = new rust.AsyncMethod(methodName, rustClient, pub, methodOptions, httpMethod, httpPath);
                 break;
             case 'paging':
-                // TODO: https://github.com/Azure/typespec-rust/issues/60
-                return;
+                rustMethod = new rust.PageableMethod(methodName, rustClient, pub, methodOptions, httpMethod, httpPath);
+                if (method.nextLinkOperation) {
+                    // TODO: https://github.com/Azure/autorest.rust/issues/103
+                    throw new Error('next page operation NYI');
+                }
+                else if (method.nextLinkPath) {
+                    // this is the name of the field in the response type that contains the next link URL
+                    if (method.nextLinkPath.indexOf('.') > 0) {
+                        // TODO: https://github.com/Azure/autorest.rust/issues/102
+                        throw new Error('nested next link path NYI');
+                    }
+                    rustMethod.strategy = new rust.PageableStrategyNextLink(naming.getEscapedReservedName(snakeCaseName(method.nextLinkPath), 'prop'));
+                }
+                break;
             default:
                 throw new Error(`method kind ${method.kind} NYI`);
         }
@@ -434,7 +526,7 @@ export class Adapter {
         rustMethod.docs.description = method.doc;
         rustClient.methods.push(rustMethod);
         // stuff all of the operation parameters into one array for easy traversal
-        let allOpParams = new Array();
+        const allOpParams = new Array();
         allOpParams.push(...method.operation.parameters);
         if (method.operation.bodyParam) {
             allOpParams.push(method.operation.bodyParam);
@@ -453,8 +545,13 @@ export class Adapter {
                 throw new Error(`didn't find operation parameter for method ${method.name} parameter ${param.name}`);
             }
             let adaptedParam;
-            if (opParam.kind === 'body' && opParam.type.kind === 'model' && opParam.type.kind !== param.type.kind) {
-                throw new Error('spread params NYI');
+            // for spread params there are two cases we need to consider.
+            // if the method param's type doesn't match the op param's type then it's a spread param
+            // - e.g. method param's type is string/int/etc which is a field in the op param's body type
+            // if the method param's type DOES match the op param's type and the op param has multiple corresponding method params, it's a spread param
+            // - e.g. op param is an intersection of multiple model types, and each model type is exposed as a discrete param
+            if (opParam.kind === 'body' && opParam.type.kind === 'model' && (opParam.type.kind !== param.type.kind || opParam.correspondingMethodParams.length > 1)) {
+                adaptedParam = this.adaptMethodSpreadParameter(param, this.adaptBodyFormat(opParam.defaultContentType), opParam.type);
             }
             else {
                 adaptedParam = this.adaptMethodParameter(opParam);
@@ -462,10 +559,24 @@ export class Adapter {
             adaptedParam.docs.summary = param.summary;
             adaptedParam.docs.description = param.doc;
             rustMethod.params.push(adaptedParam);
-            // remove the opParam we just processed
-            allOpParams = allOpParams.filter((v) => {
-                return v !== opParam;
-            });
+            if (adaptedParam.optional) {
+                let fieldType;
+                if (adaptedParam.kind === 'partialBody') {
+                    // for partial body params, adaptedParam.type is the model type that's
+                    // sent in the request. we want the field within the model for this param.
+                    // NOTE: if the param is optional then the field is optional, thus it's
+                    // already wrapped in an Option<T> type.
+                    const field = adaptedParam.type.type.fields.find(f => { return f.name === adaptedParam.name; });
+                    if (!field) {
+                        throw new Error(`didn't find spread param field ${adaptedParam.name} in type ${adaptedParam.type.type.name}`);
+                    }
+                    fieldType = field.type;
+                }
+                else {
+                    fieldType = new rust.Option(adaptedParam.type);
+                }
+                rustMethod.options.type.fields.push(new rust.StructField(adaptedParam.name, true, fieldType));
+            }
         }
         // client params aren't included in method.parameters so
         // look for them in the remaining operation parameters.
@@ -477,27 +588,65 @@ export class Adapter {
                 rustMethod.params.push(adaptedParam);
             }
         }
-        let returnType;
-        if (method.response.type) {
-            // search the HTTP responses for the corresponding type so we can determine the wire format
-            let format;
-            for (const httpResp of method.operation.responses.values()) {
-                if (!httpResp.type || !httpResp.defaultContentType || httpResp.type.kind !== method.response.type.kind) {
-                    continue;
+        const getBodyFormat = () => {
+            // fetch the body format from the HTTP responses.
+            // they should all have the same type so no need to match responses to type.
+            let defaultContentType;
+            for (const httpResp of method.operation.responses) {
+                if (defaultContentType && httpResp.defaultContentType && defaultContentType !== httpResp.defaultContentType) {
+                    throw new Error(`method ${method.name} has conflicting content types`);
                 }
-                format = this.adaptSerdeFormat(httpResp.defaultContentType);
-                break;
+                defaultContentType = httpResp.defaultContentType;
+            }
+            if (!defaultContentType) {
+                throw new Error(`unable to determine content type for method ${method.name}`);
+            }
+            return this.adaptBodyFormat(defaultContentType);
+        };
+        let returnType;
+        if (method.kind === 'paging') {
+            // for paged methods, tcgc models method.response.type as an Array<T>.
+            // however, we want the synthesized paged response envelope type instead.
+            const synthesizedType = method.operation.responses[0].type;
+            if (!synthesizedType) {
+                throw new Error(`paged method ${method.name} has no synthesized response type`);
+            }
+            else if (synthesizedType.kind !== 'model') {
+                throw new Error(`paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`);
+            }
+            const format = getBodyFormat();
+            const synthesizedModel = this.getModel(synthesizedType);
+            if (!this.crate.models.includes(synthesizedModel)) {
+                this.crate.models.push(synthesizedModel);
             }
-            if (!format) {
-                throw new Error(`didn't find HTTP response for kind ${method.response.type.kind} in method ${method.name}`);
+            returnType = new rust.Pager(this.crate, synthesizedModel, format);
+        }
+        else if (method.response.type) {
+            const format = getBodyFormat();
+            // until https://github.com/Azure/typespec-azure/issues/614 is resolved
+            // we have to look at the format to determine if the response is a streaming
+            // binary response. at present, it's represented as a base-64 encoded byte
+            // array which is clearly wrong.
+            let respType;
+            if (format === 'binary') {
+                respType = this.getUnitType();
+            }
+            else {
+                respType = this.getType(method.response.type);
             }
-            returnType = new rust.Response(this.crate, this.getType(method.response.type), format);
+            returnType = new rust.Response(this.crate, respType, format);
         }
         else {
             returnType = new rust.Response(this.crate, this.getUnitType());
         }
         rustMethod.returns = new rust.Result(this.crate, returnType);
     }
+    /**
+     * converts a tcgc operation parameter into a Rust method parameter
+     *
+     * @param param the tcgc operation parameter to convert
+     * @returns a Rust method parameter
+     */
     adaptMethodParameter(param) {
         const paramLoc = param.onClient ? 'client' : 'method';
         // if this is a client method param, check if we've already adapted it
@@ -508,15 +657,11 @@ export class Adapter {
             }
         }
         const paramName = naming.getEscapedReservedName(snakeCaseName(param.name), 'param');
-        let paramType = this.getType(param.type);
-        if (paramLoc === 'method' && paramType.kind === 'String') {
-            // for Strings, we define these as "impl Into<String>" so that passing a str will just work
-            paramType = new rust.ImplTrait('Into', paramType);
-        }
+        const paramType = this.getType(param.type);
         let adaptedParam;
         switch (param.kind) {
             case 'body': {
-                adaptedParam = new rust.BodyParameter(paramName, paramLoc, new rust.RequestContent(this.crate, paramType, this.adaptSerdeFormat(param.defaultContentType)));
+                adaptedParam = new rust.BodyParameter(paramName, paramLoc, param.optional, new rust.RequestContent(this.crate, paramType, this.adaptBodyFormat(param.defaultContentType)));
                 break;
             }
             case 'header':
@@ -538,14 +683,20 @@ export class Adapter {
                         default:
                             throw new Error(`unexpected format ${param.collectionFormat} for HeaderCollectionParameter`);
                     }
-                    adaptedParam = new rust.HeaderCollectionParameter(paramName, param.serializedName, paramLoc, paramType, format);
+                    adaptedParam = new rust.HeaderCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, format);
+                }
+                else if (param.serializedName === 'x-ms-meta') {
+                    if (paramType.kind !== 'hashmap') {
+                        throw new Error(`unexpected kind ${paramType.kind} for header ${param.serializedName}`);
+                    }
+                    adaptedParam = new rust.HeaderHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
                 }
                 else {
-                    adaptedParam = new rust.HeaderParameter(paramName, param.serializedName, paramLoc, paramType);
+                    adaptedParam = new rust.HeaderParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
                 }
                 break;
             case 'path':
-                adaptedParam = new rust.PathParameter(paramName, param.serializedName, paramLoc, paramType, param.urlEncode);
+                adaptedParam = new rust.PathParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.urlEncode);
                 break;
             case 'query':
                 if (param.collectionFormat) {
@@ -554,11 +705,11 @@ export class Adapter {
                         throw new Error(`unexpected kind ${paramType.kind} for QueryCollectionParameter`);
                     }
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
-                    adaptedParam = new rust.QueryCollectionParameter(paramName, param.serializedName, paramLoc, paramType, true, format);
+                    adaptedParam = new rust.QueryCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true, format);
                 }
                 else {
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
-                    adaptedParam = new rust.QueryParameter(paramName, param.serializedName, paramLoc, paramType, true);
+                    adaptedParam = new rust.QueryParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true);
                 }
                 break;
         }
@@ -569,22 +720,86 @@ export class Adapter {
         }
         return adaptedParam;
     }
-    adaptSerdeFormat(contentType) {
-        switch (contentType) {
-            case 'application/json':
-                this.crate.addDependency(new rust.CrateDependency('serde_json'));
-                return 'json';
-            default:
-                throw new Error(`unhandled contentType ${contentType}`);
+    /**
+     * converts a tcgc spread parameter into a Rust partial body parameter.
+     *
+     * @param param the tcgc method parameter to convert
+     * @param format the wire format for the underlying body type
+     * @param opParamType the tcgc model to which the spread parameter belongs
+     * @returns a Rust partial body parameter
+     */
+    adaptMethodSpreadParameter(param, format, opParamType) {
+        switch (format) {
+            case 'binary':
+                throw new Error('binary spread NYI');
+            case 'json':
+            case 'xml': {
+                // find the corresponding field within the model so we can get its index
+                let serializedName;
+                for (const property of opParamType.properties) {
+                    if (property.name === param.name) {
+                        serializedName = property.serializedName;
+                        break;
+                    }
+                }
+                if (serializedName === undefined) {
+                    throw new Error(`didn't find body model property for spread parameter ${param.name}`);
+                }
+                const paramLoc = 'method';
+                const paramType = this.getType(opParamType);
+                if (paramType.kind !== 'model') {
+                    throw new Error(`unexpected kind ${paramType.kind} for spread body param`);
+                }
+                const paramName = naming.getEscapedReservedName(snakeCaseName(param.name), 'param');
+                return new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, new rust.RequestContent(this.crate, paramType, format));
+            }
         }
     }
+    /**
+     * converts a Content-Type header value into a Rust body format
+     *
+     * @param contentType the value of the Content-Type header
+     * @returns a Rust body format
+     */
+    adaptBodyFormat(contentType) {
+        // we only recognize/support JSON, text, and XML content types, so assume anything else is binary
+        // NOTE: we check XML before text in order to support text/xml
+        let bodyFormat = 'binary';
+        if (contentType.match(/json/i)) {
+            this.crate.addDependency(new rust.CrateDependency('serde_json'));
+            bodyFormat = 'json';
+        }
+        else if (contentType.match(/xml/i)) {
+            bodyFormat = 'xml';
+        }
+        else if (contentType.match(/text/i)) {
+            throw new Error(`unhandled contentType ${contentType}`);
+        }
+        return bodyFormat;
+    }
 }
-function isPub(access) {
-    return access !== 'internal';
-}
+/**
+ * snake-cases the provided name
+ *
+ * @param name the name to snake-case
+ * @returns name in snake-case format
+ */
 function snakeCaseName(name) {
     return codegen.deconstruct(name).join('_');
 }
+/**
+ * recursively creates a map key from the specified type.
+ * this is idempotent so providing the same type will create
+ * the same key.
+ *
+ * obj is recursively unwrapped, and each layer is used to construct
+ * the key. e.g. if obj is a HashMap<String, Vec<i32>> this would
+ * unwrap to dict-array-int32.
+ *
+ * @param root the starting value for the key
+ * @param obj the type for which to create the key
+ * @returns a string containing the complete map key
+ */
 function recursiveKeyName(root, obj) {
     switch (obj.kind) {
         case 'array':
@@ -614,4 +829,56 @@ function recursiveKeyName(root, obj) {
             return `${root}-${obj.kind}`;
     }
 }
+/**
+ * returns the XML-specific name based on the provided decorators
+ *
+ * @param decorators the decorators to enumerate
+ * @returns the XML-specific name or undefined if there isn't one
+ */
+function getXMLName(decorators) {
+    if (decorators.length === 0) {
+        return undefined;
+    }
+    for (const decorator of decorators) {
+        switch (decorator.name) {
+            case 'TypeSpec.@encodedName':
+                if (decorator.arguments['mimeType'] === 'application/xml') {
+                    return decorator.arguments['name'];
+                }
+                break;
+            case 'TypeSpec.Xml.@name':
+                return decorator.arguments['name'];
+        }
+    }
+    return undefined;
+}
+/**
+ * returns the XML-specific kind for field based on the provided decorators
+ *
+ * @param decorators the decorators to enumerate
+ * @param field the Rust model field to which the kind will apply
+ * @returns the XML-specific field kind or undefined if there isn't one
+ */
+function getXMLKind(decorators, field) {
+    if (decorators.length === 0) {
+        return undefined;
+    }
+    for (const decorator of decorators) {
+        switch (decorator.name) {
+            case 'TypeSpec.Xml.@attribute':
+                return 'attribute';
+            case 'TypeSpec.Xml.@unwrapped': {
+                const fieldType = helpers.unwrapOption(field.type);
+                switch (fieldType.kind) {
+                    case 'vector':
+                        return 'unwrappedList';
+                    case 'String':
+                        // an unwrapped string means it's text
+                        return 'text';
+                }
+            }
+        }
+    }
+    return undefined;
+}
 //# sourceMappingURL=adapter.js.map