@azure-tools/typespec-rust 0.33.0 → 0.34.0

package/dist/src/tcgcadapter/adapter.js

@@ -3,12 +3,10 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 // cspell: ignore addl responseheader subclients lropaging
-import * as codegen from '@azure-tools/codegen';
-import { values } from '@azure-tools/linq';
 import * as tsp from '@typespec/compiler';
 import * as helpers from './helpers.js';
 import * as naming from './naming.js';
-import * as shared from '../shared/shared.js';
+import * as utils from '../utils/utils.js';
 import * as tcgc from '@azure-tools/typespec-client-generator-core';
 import * as rust from '../codemodel/index.js';
 import { FinalStateValue } from "@azure-tools/typespec-azure-core";
@@ -75,7 +73,7 @@ export class Adapter {
         this.adaptTypes();
         this.adaptClients();
         // marker models don't require serde so exclude them from the check
-        if (this.crate.enums.length > 0 || values(this.crate.models).where(e => e.kind === 'model').any()) {
+        if (this.crate.enums.length > 0 || this.crate.models.some(e => e.kind === 'model')) {
             this.crate.addDependency(new rust.CrateDependency('serde'));
         }
         if (this.crate.clients.length > 0 || this.crate.enums.length > 0 || this.crate.models.length > 0 || this.crate.unions.length > 0) {
@@ -137,6 +135,14 @@ export class Adapter {
                 processedTypes.add(model.name);
             }
             // END workaround
+            if (model.discriminatedSubtypes) {
+                const rustUnion = this.getDiscriminatedUnion(model);
+                this.crate.unions.push(rustUnion);
+                // we don't want to add the base type to the array
+                // of models to emit as we hijack its name to be used
+                // for the associated tagged enum type.
+                continue;
+            }
             if (model.external) {
                 this.getExternalType(model.external);
             }
@@ -154,7 +160,7 @@ export class Adapter {
      */
     getEnum(sdkEnum) {
         var _a, _b, _c;
-        const enumName = codegen.deconstruct(sdkEnum.name).map((each) => codegen.capitalize(each)).join('');
+        const enumName = utils.deconstruct(sdkEnum.name).map((each) => utils.capitalize(each)).join('');
         let rustEnum = this.types.get(enumName);
         if (rustEnum) {
             return rustEnum;
@@ -277,7 +283,7 @@ export class Adapter {
         }
         // remove any non-word characters from the name.
         // the most common case is something like Foo.Bar.Baz
-        modelName = codegen.capitalize(modelName).replace(/\W/g, '');
+        modelName = utils.capitalize(modelName).replace(/\W/g, '');
         let rustModel = this.types.get(modelName);
         if (rustModel) {
             return rustModel;
@@ -287,33 +293,43 @@ export class Adapter {
         if (!stack) {
             stack = new Array();
         }
-        stack.push(modelName);
         let modelFlags = rust.ModelFlags.Unspecified;
         if ((model.usage & tcgc.UsageFlags.Input) === tcgc.UsageFlags.Input) {
             modelFlags |= rust.ModelFlags.Input;
         }
-        if ((model.usage & tcgc.UsageFlags.Output) === tcgc.UsageFlags.Output) {
+        // include error and LRO polling types as output types
+        if ((model.usage & tcgc.UsageFlags.Output) === tcgc.UsageFlags.Output ||
+            (model.usage & tcgc.UsageFlags.Exception) === tcgc.UsageFlags.Exception ||
+            (model.usage & tcgc.UsageFlags.LroPolling) === tcgc.UsageFlags.LroPolling) {
             modelFlags |= rust.ModelFlags.Output;
         }
         rustModel = new rust.Model(modelName, model.access === 'internal' ? 'pubCrate' : 'pub', modelFlags);
         rustModel.docs = this.adaptDocs(model.summary, model.doc);
         rustModel.xmlName = getXMLName(model.decorators);
         this.types.set(modelName, rustModel);
+        stack.push(rustModel);
         // aggregate the properties from the provided type and its parent types
         const allProps = new Array();
         for (const prop of model.properties) {
+            if (prop.discriminator && !model.discriminatedSubtypes) {
+                rustModel.flags |= rust.ModelFlags.PolymorphicSubtype;
+            }
             allProps.push(prop);
         }
         let addlProps = model.additionalProperties;
         let parent = model.baseModel;
         while (parent) {
             for (const parentProp of parent.properties) {
-                const exists = values(allProps).where(p => { return p.name === parentProp.name; }).first();
-                if (exists) {
+                if (allProps.find(p => p.name === parentProp.name)) {
                     // don't add the duplicate. the TS compiler has better enforcement than OpenAPI
                     // to ensure that duplicate fields with different types aren't added.
                     continue;
                 }
+                else if (parentProp.discriminator) {
+                    // we don't propagate the discriminator to the child
+                    // types as it's not useful (or necessary)
+                    continue;
+                }
                 allProps.push(parentProp);
             }
             // propagate parent's additional properties if we don't yet have any.
@@ -342,13 +358,13 @@ export class Adapter {
                     throw new AdapterError('UnsupportedTsp', `model property kind ${(_c = property.__raw) === null || _c === void 0 ? void 0 : _c.kind} NYI`, (_d = property.__raw) === null || _d === void 0 ? void 0 : _d.node);
                 }
             }
-            const structField = this.getModelField(property, rustModel.visibility, stack);
+            const structField = this.getModelField(model.usage, property, rustModel.visibility, stack);
             rustModel.fields.push(structField);
         }
         if (addlProps) {
             const addlPropsType = this.getHashMap(this.typeToWireType(this.getType(addlProps)));
             const addlPropsField = new rust.ModelAdditionalProperties('additional_properties', 'pub', this.getOptionType(addlPropsType));
-            addlPropsField.docs.summary = 'contains unnamed additional properties';
+            addlPropsField.docs.summary = 'Contains unnamed additional properties.';
             rustModel.fields.push(addlPropsField);
         }
         stack.pop();
@@ -360,55 +376,100 @@ export class Adapter {
      * @param union the tcgc union to convert
      * @returns a Rust union
      */
-    getDiscriminatedUnion(union) {
-        var _a, _b, _c, _d;
-        if (union.name.length === 0) {
-            throw new AdapterError('InternalError', 'unnamed union', (_a = union.__raw) === null || _a === void 0 ? void 0 : _a.node);
-        }
-        const unionName = codegen.capitalize(union.name);
-        let rustUnion = this.types.get(unionName);
+    getDiscriminatedUnion(src) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (src.name.length === 0) {
+            throw new AdapterError('InternalError', 'unnamed union', (_a = src.__raw) === null || _a === void 0 ? void 0 : _a.node);
+        }
+        const unionName = utils.deconstruct(src.name).map((each) => utils.capitalize(each)).join('');
+        const keyName = `discriminated-union-${unionName}`;
+        let rustUnion = this.types.get(keyName);
         if (rustUnion) {
             return rustUnion;
         }
-        if (!union.discriminatedOptions) {
-            // we should have verified this earlier.
-            // having this check means the compiler won't bark
-            // at us when accessing union.discriminatedOptions
-            throw new AdapterError('InternalError', 'getDiscriminatedUnion called for non-discriminated union', (_b = union.__raw) === null || _b === void 0 ? void 0 : _b.node);
-        }
-        rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(union.access), union.discriminatedOptions.discriminatorPropertyName);
-        rustUnion.envelopeName = union.discriminatedOptions.envelopePropertyName;
-        rustUnion.docs = this.adaptDocs(union.summary, union.doc);
-        this.types.set(unionName, rustUnion);
-        // TODO: remove when https://github.com/microsoft/typespec/issues/8455 is complete
-        const discriminatorValues = new Map();
-        const rawUnion = union.__raw;
-        if (rawUnion) {
-            for (const [variantKey, variant] of rawUnion.variants) {
-                const discriminatorValue = typeof variantKey === 'string' ? variantKey : variantKey.toString();
-                if (variant.type.kind === 'Model') {
-                    discriminatorValues.set(variant.type.name, discriminatorValue);
+        switch (src.kind) {
+            case 'model': {
+                if (!src.discriminatedSubtypes) {
+                    // we should have verified this earlier.
+                    // having this check means the compiler won't bark
+                    // at us when accessing src.discriminatedSubtypes
+                    throw new AdapterError('InternalError', 'getDiscriminatedUnion called for non-polymorphic model', (_b = src.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                }
+                // find the discriminator field
+                let discriminatorProperty;
+                for (const prop of src.properties) {
+                    if (prop.kind === 'property' && prop.discriminator) {
+                        discriminatorProperty = prop;
+                        break;
+                    }
+                }
+                if (!discriminatorProperty) {
+                    throw new AdapterError('InternalError', `failed to find discriminator field for type ${src.name}`, (_c = src.__raw) === null || _c === void 0 ? void 0 : _c.node);
+                }
+                rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), discriminatorProperty.name);
+                if (discriminatorProperty.type.kind === 'enum' && discriminatorProperty.type.isFixed) {
+                    // when the DU is a fixed enum, it means we don't fall back to the
+                    // base type when the discriminator value is unknown or missing.
+                    rustUnion.unionKind = new rust.DiscriminatedUnionSealed();
                 }
                 else {
-                    throw new AdapterError('InternalError', `unexpected kind ${variant.type.kind} for discriminated union member`, rawUnion);
+                    rustUnion.unionKind = new rust.DiscriminatedUnionBase(this.getModel(src));
                 }
+                for (const subType of Object.values(src.discriminatedSubtypes)) {
+                    if (!subType.discriminatorValue) {
+                        throw new AdapterError('InternalError', `model ${subType.name} has no discriminator value`, (_d = subType.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                    }
+                    const unionMemberType = this.getModel(subType);
+                    const rustUnionMember = new rust.DiscriminatedUnionMember(unionMemberType, subType.discriminatorValue);
+                    rustUnion.members.push(rustUnionMember);
+                }
+                break;
             }
-        }
-        // END WORKAROUND
-        for (const unionMember of union.variantTypes) {
-            if (unionMember.kind !== 'model') {
-                throw new AdapterError('UnsupportedTsp', `non-model union member kind ${unionMember.kind}`, (_c = unionMember.__raw) === null || _c === void 0 ? void 0 : _c.node);
-            }
-            // TODO: use unionMember.discriminatorValue
-            const discriminatorValue = discriminatorValues.get(unionMember.name);
-            if (!discriminatorValue) {
-                throw new AdapterError('InternalError', `didn't find discriminant value for type ${unionMember.name}`, (_d = unionMember.__raw) === null || _d === void 0 ? void 0 : _d.node);
+            case 'union': {
+                if (!src.discriminatedOptions) {
+                    // we should have verified this earlier.
+                    // having this check means the compiler won't bark
+                    // at us when accessing src.discriminatedOptions
+                    throw new AdapterError('InternalError', 'getDiscriminatedUnion called for non-discriminated union', (_e = src.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                }
+                rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), src.discriminatedOptions.discriminatorPropertyName);
+                if (src.discriminatedOptions.envelopePropertyName) {
+                    rustUnion.unionKind = new rust.DiscriminatedUnionEnvelope(src.discriminatedOptions.envelopePropertyName);
+                }
+                // TODO: remove when https://github.com/microsoft/typespec/issues/8455 is complete
+                const discriminatorValues = new Map();
+                const rawUnion = src.__raw;
+                if (rawUnion) {
+                    for (const [variantKey, variant] of rawUnion.variants) {
+                        const discriminatorValue = typeof variantKey === 'string' ? variantKey : variantKey.toString();
+                        if (variant.type.kind === 'Model') {
+                            discriminatorValues.set(variant.type.name, discriminatorValue);
+                        }
+                        else {
+                            throw new AdapterError('InternalError', `unexpected kind ${variant.type.kind} for discriminated union member`, rawUnion);
+                        }
+                    }
+                }
+                // END WORKAROUND
+                for (const unionMember of src.variantTypes) {
+                    if (unionMember.kind !== 'model') {
+                        throw new AdapterError('UnsupportedTsp', `non-model union member kind ${unionMember.kind}`, (_f = unionMember.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                    }
+                    // TODO: use unionMember.discriminatorValue
+                    const discriminatorValue = discriminatorValues.get(unionMember.name);
+                    if (!discriminatorValue) {
+                        throw new AdapterError('InternalError', `didn't find discriminant value for type ${unionMember.name}`, (_g = unionMember.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                    }
+                    const unionMemberType = this.getModel(unionMember);
+                    const rustUnionMember = new rust.DiscriminatedUnionMember(unionMemberType, discriminatorValue);
+                    rustUnionMember.docs = this.adaptDocs(unionMember.summary, unionMember.doc);
+                    rustUnion.members.push(rustUnionMember);
+                }
+                break;
             }
-            const unionMemberType = this.getModel(unionMember);
-            const rustUnionMember = new rust.DiscriminatedUnionMember(unionMemberType, discriminatorValue);
-            rustUnionMember.docs = this.adaptDocs(unionMember.summary, unionMember.doc);
-            rustUnion.members.push(rustUnionMember);
         }
+        rustUnion.docs = this.adaptDocs(src.summary, src.doc);
+        this.types.set(keyName, rustUnion);
         return rustUnion;
     }
     getSerializedPropertyName(property) {
@@ -418,30 +479,58 @@ export class Adapter {
     /**
      * converts a tcgc model property to a model field
      *
+     * @param modelFlags the flags for the model to which the field belongs
      * @param property the tcgc model property to convert
      * @param modelVisibility the visibility of the model that contains the property
-     * @param stack is a stack of model type names used to detect recursive type definitions
+     * @param stack is a stack of types used to detect recursive type definitions
      * @returns a Rust model field
      */
-    getModelField(property, modelVisibility, stack) {
+    getModelField(modelFlags, property, modelVisibility, stack) {
         var _a;
+        const fieldNeedsBoxing = function (fieldType) {
+            if (fieldType.kind === 'model' && stack.includes(fieldType)) {
+                // if the field's type is a model and it's in the type stack then
+                // box it. this is to avoid infinitely recursive type definitions.
+                return true;
+            }
+            else if (fieldType.kind === 'discriminatedUnion') {
+                // if the field is a discriminated union whose type
+                // is part of the same union then box it.
+                for (const member of fieldType.members) {
+                    if (stack.includes(member.type)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
         let fieldType = this.getType(property.type, stack);
-        // if the field's type is a model and it's in the type stack then
-        // box it. this is to avoid infinitely recursive type definitions.
-        if (fieldType.kind === 'model' && stack.includes(fieldType.name)) {
+        if (fieldNeedsBoxing(fieldType)) {
             fieldType = this.getBoxType(fieldType);
         }
-        // for public models each field is always an Option<T>.
-        if (modelVisibility === 'pub' || property.optional) {
+        // for non-spread models each field is always an Option<T>.
+        // NOTE: models can be used for both spread and I/O, so when
+        // restricting for spread it must be ONLY used for spread.
+        const notSpreadOnly = (modelFlags & tcgc.UsageFlags.Spread) === 0 || (modelFlags & tcgc.UsageFlags.Input) || (modelFlags & tcgc.UsageFlags.Output);
+        if (notSpreadOnly || property.optional) {
             fieldType = this.getOptionType(fieldType.kind === 'box' ? fieldType : this.typeToWireType(fieldType));
         }
         const serializedName = (_a = this.getSerializedPropertyName(property)) !== null && _a !== void 0 ? _a : property.name;
-        const modelField = new rust.ModelField(naming.getEscapedReservedName(snakeCaseName(property.name), 'prop'), serializedName, modelVisibility, fieldType, property.optional);
+        const modelField = new rust.ModelField(naming.getEscapedReservedName(utils.snakeCaseName(property.name), 'prop'), serializedName, modelVisibility, fieldType, property.optional);
         modelField.docs = this.adaptDocs(property.summary, property.doc);
         // if this is a literal, add a doc comment explaining its behavior
-        const unwrappedType = shared.unwrapOption(fieldType);
-        if (unwrappedType.kind === 'literal') {
-            const literalDoc = `${modelField.optional ? 'When Some, field' : 'Field'} has constant value ${unwrappedType.value}. Any specified value will be ignored.`;
+        const unwrappedType = utils.unwrapOption(fieldType);
+        if (unwrappedType.kind === 'enumValue' || unwrappedType.kind === 'literal') {
+            let constValue;
+            switch (unwrappedType.kind) {
+                case 'enumValue':
+                    constValue = `${unwrappedType.type.name}::${unwrappedType.name}`;
+                    break;
+                case 'literal':
+                    constValue = unwrappedType.value;
+                    break;
+            }
+            const literalDoc = `${modelField.optional ? 'When Some, field' : 'Field'} has constant value ${constValue}. Any specified value will be ignored.`;
             if (!modelField.docs.description) {
                 modelField.docs.description = '';
             }
@@ -463,17 +552,23 @@ export class Adapter {
         if (property.decorators.find((decorator) => decorator.name === 'Azure.ClientGenerator.Core.@deserializeEmptyStringAsNull') !== undefined) {
             modelField.flags |= rust.ModelFieldFlags.DeserializeEmptyStringAsNone;
         }
+        else if (property.kind === 'property' && property.discriminator) {
+            modelField.flags |= rust.ModelFieldFlags.Discriminator;
+        }
         return modelField;
     }
     /**
      * converts a tcgc type to a Rust type
      *
      * @param type the tcgc type to convert
-     * @param stack is a stack of model type names used to detect recursive type definitions
+     * @param stack is a stack of types used to detect recursive type definitions
      * @returns the adapted Rust type
      */
     getType(type, stack) {
         var _a, _b, _c;
+        if (type.external) {
+            return this.getExternalType(type.external);
+        }
         const getDateTimeEncoding = (encoding) => {
             var _a;
             switch (encoding) {
@@ -549,6 +644,9 @@ export class Adapter {
                 if (type.external) {
                     return this.getExternalType(type.external);
                 }
+                else if (type.discriminatedSubtypes) {
+                    return this.getDiscriminatedUnion(type);
+                }
                 return this.getModel(type, stack);
             case 'endpoint':
             case 'plainDate':
@@ -595,16 +693,8 @@ export class Adapter {
                 }
                 return safeint;
             }
-            case 'unknown': {
-                const keyName = 'jsonValue';
-                let anyType = this.types.get(keyName);
-                if (anyType) {
-                    return anyType;
-                }
-                anyType = new rust.JsonValue(this.crate);
-                this.types.set(keyName, anyType);
-                return anyType;
-            }
+            case 'unknown':
+                return this.getUnknownValue();
             case 'utcDateTime': {
                 const encoding = getDateTimeEncoding(type.encode);
                 const keyName = `offsetDateTime-${encoding}-utc`;
@@ -658,6 +748,17 @@ export class Adapter {
         this.types.set(keyName, hashmapType);
         return hashmapType;
     }
+    /** returns an azure_core::Value */
+    getUnknownValue() {
+        const keyName = 'jsonValue';
+        let anyType = this.types.get(keyName);
+        if (anyType) {
+            return anyType;
+        }
+        anyType = new rust.JsonValue(this.crate);
+        this.types.set(keyName, anyType);
+        return anyType;
+    }
     /** returns an Option<T> where T is specified in type */
     getOptionType(type) {
         const typeKey = recursiveKeyName('option', type);
@@ -853,7 +954,7 @@ export class Adapter {
      * @returns a Rust client
      */
     recursiveAdaptClient(client, parent) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         let clientName = client.name;
         // NOTE: if the client has the @clientName decorator applied then use that verbatim
         if (parent && !hasClientNameDecorator(client.decorators)) {
@@ -977,7 +1078,7 @@ export class Adapter {
                                 // note that the types of the param and the field are different.
                                 // we default to "endpoint" and will use the defined name IFF
                                 // it has the @clientName decorator applied
-                                const endpointName = hasClientNameDecorator(templateArg.decorators) ? snakeCaseName(templateArg.name) : 'endpoint';
+                                const endpointName = hasClientNameDecorator(templateArg.decorators) ? utils.snakeCaseName(templateArg.name) : 'endpoint';
                                 const adaptedParam = new rust.ClientEndpointParameter(endpointName);
                                 adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
                                 ctorParams.push(adaptedParam);
@@ -1032,7 +1133,7 @@ export class Adapter {
             // to create a child client that will need to inherit our client params.
             rustClient.endpoint = parent.endpoint;
             for (const prop of client.clientInitialization.parameters) {
-                const name = snakeCaseName(prop.name);
+                const name = utils.snakeCaseName(prop.name);
                 const parentField = parent.fields.find((v) => v.name === name);
                 if (parentField) {
                     rustClient.fields.push(parentField);
@@ -1050,7 +1151,7 @@ export class Adapter {
         else {
             throw new AdapterError('InternalError', `uninstantiatable client ${client.name} has no parent`);
         }
-        for (const child of values(client.children)) {
+        for (const child of (_c = client.children) !== null && _c !== void 0 ? _c : []) {
             const subClient = this.recursiveAdaptClient(child, rustClient);
             this.adaptClientAccessor(client, child, rustClient, subClient);
         }
@@ -1062,7 +1163,7 @@ export class Adapter {
                     code: 'LroPagingNotSupported',
                     severity: 'warning',
                     message: `skip emitting Paging LRO ${method.name}`,
-                    target: (_d = (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node) !== null && _d !== void 0 ? _d : tsp.NoTarget,
+                    target: (_e = (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node) !== null && _e !== void 0 ? _e : tsp.NoTarget,
                 });
                 continue;
             }
@@ -1106,22 +1207,8 @@ export class Adapter {
      * @returns the Rust client parameter
      */
     adaptClientParameter(param, constructable) {
-        let paramType;
-        // the second clause is a workaround for https://github.com/Azure/typespec-azure/issues/2745
-        if (param.isApiVersionParam || (param.type.kind === 'enum' && (param.type.usage & tcgc.UsageFlags.ApiVersionEnum) === tcgc.UsageFlags.ApiVersionEnum)) {
-            if (param.clientDefaultValue) {
-                // this is optional so it goes into the client options type as a String
-                paramType = this.getStringType();
-            }
-            else {
-                // this is a required param so its type is a &str
-                paramType = this.getRefType(this.getStringSlice());
-            }
-        }
-        else {
-            paramType = this.getType(param.type);
-        }
-        const paramName = snakeCaseName(param.name);
+        let paramType = param.isApiVersionParam ? this.getStringType() : this.getType(param.type);
+        const paramName = utils.snakeCaseName(param.name);
         let optional = false;
         // client-side default value makes the param optional
         if (param.optional || param.clientDefaultValue) {
@@ -1157,7 +1244,7 @@ export class Adapter {
      * @param subClient the sub-client type that the method returns
      */
     adaptClientAccessor(parentClient, childClient, rustClient, subClient) {
-        const clientAccessor = new rust.ClientAccessor(`get_${snakeCaseName(subClient.name)}`, rustClient, subClient);
+        const clientAccessor = new rust.ClientAccessor(`get_${utils.snakeCaseName(subClient.name)}`, rustClient, subClient);
         clientAccessor.docs.summary = `Returns a new instance of ${subClient.name}.`;
         for (const param of childClient.clientInitialization.parameters) {
             // check if the client's initializer already has this parameter.
@@ -1173,7 +1260,7 @@ export class Adapter {
             if (existsOnParent) {
                 continue;
             }
-            const adaptedParam = new rust.Parameter(snakeCaseName(param.name), this.getType(param.type));
+            const adaptedParam = new rust.Parameter(utils.snakeCaseName(param.name), this.getType(param.type));
             adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
             clientAccessor.params.push(adaptedParam);
         }
@@ -1189,14 +1276,14 @@ export class Adapter {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
-            const chunks = codegen.deconstruct(srcMethodName);
+            const chunks = utils.deconstruct(srcMethodName);
             if (chunks[0] === 'get') {
                 chunks[0] = 'list';
             }
             else {
                 chunks.unshift('list');
             }
-            srcMethodName = codegen.camelCase(chunks);
+            srcMethodName = utils.camelCase(chunks);
             this.ctx.program.reportDiagnostic({
                 code: 'PagingMethodRename',
                 severity: 'warning',
@@ -1205,7 +1292,8 @@ export class Adapter {
             });
         }
         const languageIndependentName = method.crossLanguageDefinitionId;
-        const methodName = naming.getEscapedReservedName(snakeCaseName(srcMethodName), 'fn');
+        const methodName = naming.getEscapedReservedName(utils.snakeCaseName(srcMethodName), 'fn');
+        const pub = adaptAccessFlags(method.access);
         if (srcMethodName !== method.name) {
             // if the method was renamed then ensure it doesn't collide
             for (const existingMethod of rustClient.methods) {
@@ -1215,7 +1303,7 @@ export class Adapter {
             }
         }
         const optionsLifetime = new rust.Lifetime('a');
-        const methodOptionsStruct = new rust.Struct(`${rustClient.name}${codegen.pascalCase(srcMethodName, false)}Options`, 'pub');
+        const methodOptionsStruct = new rust.Struct(`${rustClient.name}${utils.pascalCase(srcMethodName, false)}Options`, pub);
         methodOptionsStruct.lifetime = optionsLifetime;
         methodOptionsStruct.docs.summary = `Options to be passed to ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
         let clientMethodOptions;
@@ -1230,10 +1318,9 @@ export class Adapter {
             default:
                 clientMethodOptions = new rust.ClientMethodOptions(this.crate, optionsLifetime);
         }
-        const methodOptionsField = new rust.StructField('method_options', 'pub', clientMethodOptions);
+        const methodOptionsField = new rust.StructField('method_options', pub, clientMethodOptions);
         methodOptionsField.docs.summary = 'Allows customization of the method call.';
         methodOptionsStruct.fields.push(methodOptionsField);
-        const pub = adaptAccessFlags(method.access);
         const methodOptions = new rust.MethodOptions(methodOptionsStruct);
         const httpMethod = method.operation.verb;
         let rustMethod;
@@ -1290,12 +1377,11 @@ export class Adapter {
             // most params have a one-to-one mapping. however, for spread params, there will
             // be a many-to-one mapping. i.e. multiple params will map to the same underlying
             // operation param. each param corresponds to a field within the operation param.
-            const opParam = values(allOpParams).where((opParam) => {
-                return values(opParam.methodParameterSegments.map((segment) => segment[segment.length - 1]))
-                    .where((methodParam) => {
+            const opParam = allOpParams.find((opParam) => {
+                return opParam.methodParameterSegments.map((segment) => segment[segment.length - 1]).some((methodParam) => {
                     return methodParam.name === param.name;
-                }).any();
-            }).first();
+                });
+            });
             if (!opParam) {
                 throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
             }
@@ -1344,7 +1430,7 @@ export class Adapter {
                 else {
                     fieldType = this.getOptionType(adaptedParam.type);
                 }
-                const optionsField = new rust.StructField(adaptedParam.name, 'pub', fieldType);
+                const optionsField = new rust.StructField(adaptedParam.name, pub, fieldType);
                 optionsField.docs = adaptedParam.docs;
                 rustMethod.options.type.fields.push(optionsField);
             }
@@ -1495,7 +1581,7 @@ export class Adapter {
         }
         else if (method.kind === 'lro') {
             const format = responseFormat === 'NoFormat' ? 'JsonFormat' : responseFormat;
-            const statusType = this.typeToWireType(this.getModel(method.lroMetadata.pollingInfo.responseModel, undefined, `${rustClient.name}${codegen.pascalCase(rustMethod.name, false)}OperationStatus`));
+            const statusType = this.typeToWireType(this.getModel(method.lroMetadata.pollingInfo.responseModel, undefined, `${rustClient.name}${utils.pascalCase(rustMethod.name, false)}OperationStatus`));
             if (statusType.kind !== 'model') {
                 throw new AdapterError('InternalError', `status type for an LRO method '${method.name}' is not a model`, (_p = method.__raw) === null || _p === void 0 ? void 0 : _p.node);
             }
@@ -1532,7 +1618,7 @@ export class Adapter {
         else if (responseHeaders.length > 0) {
             // for methods that don't return a modeled type but return headers,
             // we need to return a marker type
-            const markerType = new rust.MarkerType(`${rustClient.name}${codegen.pascalCase(method.name, false)}Result`, rustMethod.visibility);
+            const markerType = new rust.MarkerType(`${rustClient.name}${utils.pascalCase(method.name, false)}Result`, rustMethod.visibility);
             markerType.docs.summary = `Contains results for ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
             this.crate.models.push(markerType);
             let resultType;
@@ -1599,10 +1685,10 @@ export class Adapter {
                 if (header.serializedName !== 'x-ms-meta' && header.serializedName !== 'x-ms-or') {
                     throw new AdapterError('InternalError', `unexpected response header collection ${header.serializedName}`, header.__raw.node);
                 }
-                responseHeader = new rust.ResponseHeaderHashMap(snakeCaseName(header.name), lowerCasedHeader);
+                responseHeader = new rust.ResponseHeaderHashMap(utils.snakeCaseName(header.name), lowerCasedHeader);
             }
             else {
-                responseHeader = new rust.ResponseHeaderScalar(snakeCaseName(header.name), fixETagName(lowerCasedHeader), this.typeToWireType(this.getType(header.type)));
+                responseHeader = new rust.ResponseHeaderScalar(utils.snakeCaseName(header.name), utils.fixETagName(lowerCasedHeader), this.typeToWireType(this.getType(header.type)));
             }
             responseHeader.docs = this.adaptDocs(header.summary, header.doc);
             responseHeadersMap.set(header, responseHeader);
@@ -1640,13 +1726,13 @@ export class Adapter {
                 case 'ref':
                     return `Ref${recursiveTypeName(type.type)}`;
                 case 'scalar':
-                    return codegen.capitalize(type.type);
+                    return utils.capitalize(type.type);
                 case 'slice':
                     return `Slice${recursiveTypeName(type.type)}`;
                 case 'Vec':
                     return `${type.kind}${recursiveTypeName(type.type)}`;
                 default:
-                    return codegen.capitalize(type.kind);
+                    return utils.capitalize(type.kind);
             }
         };
         const throwOnUnitType = function (type) {
@@ -1832,7 +1918,7 @@ export class Adapter {
             }
             return param.name;
         };
-        const paramName = naming.getEscapedReservedName(snakeCaseName(getCorrespondingClientParamName(param)), 'param', reservedParams);
+        const paramName = naming.getEscapedReservedName(utils.snakeCaseName(getCorrespondingClientParamName(param)), 'param', reservedParams);
         let paramType = this.getType(param.type);
         // for required header/path/query method string params, we might emit them as borrowed types
         if (!param.optional && !param.onClient && (param.kind === 'header' || param.kind === 'path' || param.kind === 'query')) {
@@ -2087,9 +2173,9 @@ export class Adapter {
         if (payloadType.kind !== 'model') {
             throw new AdapterError('InternalError', `unexpected kind ${payloadType.kind} for spread body param`, (_b = opParamType.__raw) === null || _b === void 0 ? void 0 : _b.node);
         }
-        const paramName = naming.getEscapedReservedName(snakeCaseName(param.name), 'param');
+        const paramName = naming.getEscapedReservedName(utils.snakeCaseName(param.name), 'param');
         const paramLoc = 'method';
-        const formatType = shared.getPayloadFormatType(format);
+        const formatType = utils.getPayloadFormatType(format);
         const adaptedParam = new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, this.getType(param.type), new rust.RequestContent(this.crate, new rust.Payload(payloadType, format), formatType));
         return adaptedParam;
     }
@@ -2140,45 +2226,11 @@ export class Adapter {
 }
 /** type guard to determine if type is a Ref<HashMap> */
 function isRefHashMap(type) {
-    return shared.asTypeOf(type, 'hashmap', 'ref') !== undefined;
+    return utils.asTypeOf(type, 'hashmap', 'ref') !== undefined;
 }
 /** type guard to determine if type is a Ref<Slice> */
 function isRefSlice(type) {
-    return shared.asTypeOf(type, 'slice', 'ref') !== undefined;
-}
-/**
- * transforms Etag etc to all lower case.
- * this is to prevent inadvertently snake-casing
- * Etag to e_tag.
- *
- * if name isn't some variant of Etag the
- * original value is returned.
- *
- * @param name the name to transform
- * @returns etag or the original value
- */
-function fixETagName(name) {
-    return name.match(/^etag$/i) ? 'etag' : name;
-}
-/**
- * removes any illegal characters from the provided name.
- * note that characters _ and - are preserved so that the
- * proper snake-casing can be performed.
- *
- * @param name the name to transform
- * @returns the transformed name or the original value
- */
-function removeIllegalChars(name) {
-    return name.replace(/[!@#$%^&*()+=]/g, '');
-}
-/**
- * snake-cases the provided name
- *
- * @param name the name to snake-case
- * @returns name in snake-case format
- */
-function snakeCaseName(name) {
-    return codegen.deconstruct(fixETagName(removeIllegalChars(name))).join('_');
+    return utils.asTypeOf(type, 'slice', 'ref') !== undefined;
 }
 /**
  * recursively creates a map key from the specified type.
@@ -2208,6 +2260,7 @@ function recursiveKeyName(root, type) {
             return recursiveKeyName(`${root}-${type.kind}`, type.type);
         case 'offsetDateTime':
             return `${root}-${type.kind}-${type.encoding}${type.utc ? '-utc' : ''}`;
+        case 'discriminatedUnion':
         case 'model':
         case 'struct':
             return `${root}-${type.kind}-${type.name}`;
@@ -2269,7 +2322,7 @@ function getXMLKind(decorators, field) {
             case 'TypeSpec.Xml.@attribute':
                 return 'attribute';
             case 'TypeSpec.Xml.@unwrapped': {
-                const fieldType = shared.unwrapOption(field.type);
+                const fieldType = utils.unwrapOption(field.type);
                 switch (fieldType.kind) {
                     case 'Vec':
                         return 'unwrappedList';