@azure-tools/typespec-rust 0.37.0 → 0.38.1

package/dist/src/tcgcadapter/adapter.js

@@ -222,7 +222,6 @@ export class Adapter {
             };
             terminalErrorModelNames = getTerminalErrorModelNames(this.ctx.sdkPackage.clients);
         }
-        const processedTypes = new Set();
         for (const model of this.ctx.sdkPackage.models) {
             if ((model.usage & (tcgc.UsageFlags.Input | tcgc.UsageFlags.Output | tcgc.UsageFlags.Spread | tcgc.UsageFlags.Exception)) === 0) {
                 // skip types without input and output usage. this will include core
@@ -236,15 +235,7 @@ export class Adapter {
                 continue;
             }
             needsCoreAndSerde = true;
-            // TODO: workaround for https://github.com/Azure/typespec-azure/issues/3614
-            if (processedTypes.has(model.name)) {
-                continue;
-            }
-            else {
-                processedTypes.add(model.name);
-            }
-            // END workaround
-            if (model.discriminatedSubtypes) {
+            if (isPolymorphicRoot(model)) {
                 const rustUnion = this.getDiscriminatedUnion(model);
                 this.adaptNamespace(model.namespace).unions.push(rustUnion);
                 // we don't want to add the base type to the array
@@ -426,7 +417,7 @@ export class Adapter {
         // 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) {
+            if (prop.discriminator && !isPolymorphicRoot(model)) {
                 rustModel.flags |= rust.ModelFlags.PolymorphicSubtype;
             }
             allProps.push(prop);
@@ -492,7 +483,7 @@ export class Adapter {
      * @returns a Rust union
      */
     getDiscriminatedUnion(src) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         if (src.name.length === 0) {
             throw new AdapterError('InternalError', 'unnamed union', (_a = src.__raw) === null || _a === void 0 ? void 0 : _a.node);
         }
@@ -504,7 +495,7 @@ export class Adapter {
         }
         switch (src.kind) {
             case 'model': {
-                if (!src.discriminatedSubtypes) {
+                if (!isPolymorphicRoot(src)) {
                     // we should have verified this earlier.
                     // having this check means the compiler won't bark
                     // at us when accessing src.discriminatedSubtypes
@@ -528,13 +519,37 @@ export class Adapter {
                     rustUnion.unionKind = new rust.DiscriminatedUnionSealed();
                 }
                 else {
-                    rustUnion.unionKind = new rust.DiscriminatedUnionBase(this.getModel(src));
+                    const typeName = `Unknown${utils.capitalize(src.name).replace(/\W/g, '')}${utils.capitalize(rustUnion.discriminant)}`;
+                    const baseModel = this.getModel(src, undefined, typeName);
+                    const module = this.adaptNamespace(src.namespace);
+                    if (!module.models.includes(baseModel)) {
+                        // we only fix up the base model if it's not
+                        // in the collection of models for this module
+                        baseModel.flags = rust.ModelFlags.PolymorphicBase;
+                        // internal serde helper only
+                        baseModel.visibility = 'pubCrate';
+                        const lifetime = new rust.Lifetime('a');
+                        baseModel.lifetime = lifetime;
+                        for (const field of baseModel.fields) {
+                            if (field.kind === 'modelField') {
+                                // strip off the discriminator flag
+                                field.flags &= ~rust.ModelFieldFlags.Discriminator;
+                            }
+                            if (!typeToRefType(field.type)) {
+                                throw new AdapterError('InternalError', `unsupported field kind ${field.type.kind} in polymorphic base model ${baseModel.name}`, (_d = src.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                            }
+                            field.type = this.getRefType(field.type, lifetime);
+                        }
+                        module.models.push(baseModel);
+                    }
+                    rustUnion.unionKind = new rust.DiscriminatedUnionBase(baseModel);
                 }
-                for (const subType of Object.values(src.discriminatedSubtypes)) {
+                // we need to handle the case where src is a root with no child types
+                for (const subType of Object.values((_e = src.discriminatedSubtypes) !== null && _e !== void 0 ? _e : {})) {
                     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);
+                        throw new AdapterError('InternalError', `model ${subType.name} has no discriminator value`, (_f = subType.__raw) === null || _f === void 0 ? void 0 : _f.node);
                     }
-                    const unionMemberType = this.getModel(subType);
+                    const unionMemberType = subType.discriminatedSubtypes ? this.getDiscriminatedUnion(subType) : this.getModel(subType);
                     const rustUnionMember = new rust.DiscriminatedUnionMember(unionMemberType, subType.discriminatorValue);
                     rustUnion.members.push(rustUnionMember);
                 }
@@ -545,7 +560,7 @@ export class Adapter {
                     // 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);
+                    throw new AdapterError('InternalError', 'getDiscriminatedUnion called for non-discriminated union', (_g = src.__raw) === null || _g === void 0 ? void 0 : _g.node);
                 }
                 rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), src.discriminatedOptions.discriminatorPropertyName, this.adaptNamespace(src.namespace));
                 if (src.discriminatedOptions.envelopePropertyName) {
@@ -568,12 +583,12 @@ export class Adapter {
                 // 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);
+                        throw new AdapterError('UnsupportedTsp', `non-model union member kind ${unionMember.kind}`, (_h = unionMember.__raw) === null || _h === void 0 ? void 0 : _h.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);
+                        throw new AdapterError('InternalError', `didn't find discriminant value for type ${unionMember.name}`, (_j = unionMember.__raw) === null || _j === void 0 ? void 0 : _j.node);
                     }
                     const unionMemberType = this.getModel(unionMember);
                     const rustUnionMember = new rust.DiscriminatedUnionMember(unionMemberType, discriminatorValue);
@@ -831,6 +846,9 @@ export class Adapter {
             }
             modelField.docs.description += `Operational visibility: ${visibilityStr}`;
         }
+        if (property.visibility && property.visibility.length === 1 && property.visibility[0] === http.Visibility.Read) {
+            modelField.flags |= rust.ModelFieldFlags.ReadOnly;
+        }
         // if this is a literal, add a doc comment explaining its behavior
         const unwrappedType = utils.unwrapOption(fieldType);
         if (unwrappedType.kind === 'enumValue' || unwrappedType.kind === 'literal') {
@@ -985,7 +1003,7 @@ export class Adapter {
                 if (type.external) {
                     return this.getExternalType(type.external);
                 }
-                else if (type.discriminatedSubtypes) {
+                else if (isPolymorphicRoot(type)) {
                     return this.getDiscriminatedUnion(type);
                 }
                 else if (tcgc.isAzureCoreModel(type)) {
@@ -1305,7 +1323,7 @@ export class Adapter {
      * @returns a Rust client
      */
     recursiveAdaptClient(client, parent) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         let clientName = client.name;
         // NOTE: if the client has the @clientName decorator applied then use that verbatim
         if (parent && !hasClientNameDecorator(client.decorators)) {
@@ -1465,10 +1483,16 @@ export class Adapter {
                         break;
                     }
                     case 'method': {
-                        // https://github.com/Azure/typespec-rust/issues/849
-                        // Azure doesn't use optional (with no explicit default value) API versions anyway.
                         if (param.isApiVersionParam && param.optional && !param.clientDefaultValue) {
-                            param.optional = false;
+                            if (!parent && client.children && client.methods.length === 0) {
+                                // this is the top-level client for a multi-client scenario.
+                                // each sub-client will have its own api-version parameter.
+                                // we omit this "merged" api-version param as it's useless.
+                                continue;
+                            }
+                            else {
+                                throw new AdapterError('UnsupportedTsp', 'found optional apiVersion parameter with no default value', (_c = param.__raw) === null || _c === void 0 ? void 0 : _c.node);
+                            }
                         }
                         const clientParam = this.adaptClientParameter(param, rustClient.constructable);
                         rustClient.fields.push(new rust.StructField(clientParam.name, 'pubCrate', clientParam.type));
@@ -1506,6 +1530,33 @@ export class Adapter {
                     // as these are handled in the parent client.
                     continue;
                 }
+                else if (prop.isApiVersionParam) {
+                    // we didn't find the api-version param in the parent which means
+                    // this is a multi-client child with its own api-version param.
+                    // we need to find the instantiable parent client.
+                    let constructable;
+                    let cur = parent;
+                    while (cur) {
+                        constructable = cur.constructable;
+                        if (constructable) {
+                            break;
+                        }
+                        cur = cur.parent;
+                    }
+                    if (!constructable || !cur) {
+                        throw new AdapterError('InternalError', `didn't find constructable client for apiVersion in client ${rustClient.name}`, (_d = prop.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                    }
+                    rustClient.fields.push(new rust.StructField(utils.snakeCaseName(prop.name), 'pubCrate', this.getStringType()));
+                    // we use the client name as a prefix to disambiguate the params in the parent
+                    const clientParam = this.adaptClientParameter(prop, constructable, utils.deduplicateClientFieldName(rustClient, name));
+                    const field = new rust.StructField(clientParam.name, 'pubCrate', clientParam.type);
+                    cur.fields.push(field);
+                    // propagate this param to all client constructors
+                    for (const constructor of constructable.constructors) {
+                        constructor.params.push(clientParam);
+                    }
+                    continue;
+                }
                 // unique field for this client
                 rustClient.fields.push(new rust.StructField(name, 'pubCrate', this.getType(prop.type)));
             }
@@ -1513,7 +1564,7 @@ export class Adapter {
         else {
             throw new AdapterError('InternalError', `uninstantiatable client ${client.name} has no parent`);
         }
-        for (const child of (_c = client.children) !== null && _c !== void 0 ? _c : []) {
+        for (const child of (_e = client.children) !== null && _e !== void 0 ? _e : []) {
             const subClient = this.recursiveAdaptClient(child, rustClient);
             this.adaptClientAccessor(client, child, rustClient, subClient);
         }
@@ -1525,7 +1576,7 @@ export class Adapter {
                     code: 'LroPagingNotSupported',
                     severity: 'warning',
                     message: `skip emitting Paging LRO ${method.name}`,
-                    target: (_e = (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node) !== null && _e !== void 0 ? _e : tsp.NoTarget,
+                    target: (_g = (_f = method.__raw) === null || _f === void 0 ? void 0 : _f.node) !== null && _g !== void 0 ? _g : tsp.NoTarget,
                 });
                 continue;
             }
@@ -1566,11 +1617,12 @@ export class Adapter {
      *
      * @param param the tcgc client parameter to convert
      * @param constructable contains client construction info. if the param is optional, it will go in the options type
+     * @param name optional custom name for the parameter
      * @returns the Rust client parameter
      */
-    adaptClientParameter(param, constructable) {
+    adaptClientParameter(param, constructable, name) {
         let paramType = param.isApiVersionParam ? this.getStringType() : this.getType(param.type);
-        const paramName = utils.snakeCaseName(param.name);
+        const paramName = name !== null && name !== void 0 ? name : utils.snakeCaseName(param.name);
         let optional = false;
         // client-side default value makes the param optional
         if (param.optional || param.clientDefaultValue) {
@@ -1637,7 +1689,7 @@ export class Adapter {
      * @param rustClient the client to which the method belongs
      */
     adaptMethod(method, rustClient) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = utils.deconstruct(srcMethodName);
@@ -1715,8 +1767,21 @@ export class Adapter {
                                 // https://github.com/microsoft/typespec/blob/f3d792b252c6f40be0e174496d9f34d453676026/packages/http-client-csharp/emitter/src/type/operation-final-state-via.ts#L23-L27
                                 lroFinalResultStrategy = new rust.LroFinalResultStrategyHeader('operation-location');
                                 break;
+                            case FinalStateValue.customLink:
+                                if (((_d = method.lroMetadata.statusMonitorStep) === null || _d === void 0 ? void 0 : _d.kind) === "nextOperationLink") {
+                                    const customHeaderName = method.lroMetadata.statusMonitorStep.target.property.name;
+                                    if (customHeaderName.trim() === '') {
+                                        throw new AdapterError('UnsupportedTsp', `lroMetadata.finalStateVia === customLink && customHeaderName === "${customHeaderName}"`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                                    }
+                                    lroFinalResultStrategy = new rust.LroFinalResultStrategyHeader(customHeaderName);
+                                }
+                                else {
+                                    throw new AdapterError('UnsupportedTsp', `lroMetadata.finalStateVia === customLink && lroMetadata.statusMonitorStep?.kind === "${(_f = method.lroMetadata.statusMonitorStep) === null || _f === void 0 ? void 0 : _f.kind}"`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                                }
+                                break;
                             default:
-                                throw new AdapterError('UnsupportedTsp', `lroMetadata.finalStateVia ${method.lroMetadata.finalStateVia} NYI`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                                /* eslint-disable-next-line @typescript-eslint/restrict-template-expressions */
+                                throw new AdapterError('UnsupportedTsp', `lroMetadata.finalStateVia ${method.lroMetadata.finalStateVia} NYI`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
                         }
                         lroFinalResultStrategy.propertyName = method.lroMetadata.finalResultPath;
                     }
@@ -1724,7 +1789,7 @@ export class Adapter {
                 }
                 break;
             default:
-                throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
         }
         rustMethod.docs = this.adaptDocs(method.summary, method.doc);
         rustClient.methods.push(rustMethod);
@@ -1845,7 +1910,7 @@ export class Adapter {
                     if (!fieldOptional) {
                         if (!paramGroup) {
                             if (param.type.kind !== 'model') {
-                                throw new AdapterError('InternalError', `expected model type for parameter group but got ${param.type.kind}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                                throw new AdapterError('InternalError', `expected model type for parameter group but got ${param.type.kind}`, (_k = param.__raw) === null || _k === void 0 ? void 0 : _k.node);
                             }
                             const groupName = utils.capitalize(param.type.name).replace(/\W/g, '');
                             const paramName = naming.getEscapedReservedName(utils.snakeCaseName(param.name), 'param', reservedParams);
@@ -1890,7 +1955,7 @@ export class Adapter {
                 }
             }
             else {
-                throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_g = param.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_l = param.__raw) === null || _l === void 0 ? void 0 : _l.node);
             }
         }
         // client params aren't included in method.parameters so
@@ -1973,16 +2038,16 @@ export class Adapter {
         const responseFormat = getResponseFormat();
         if (method.kind === 'paging') {
             if (responseFormat !== 'JsonFormat' && responseFormat !== 'XmlFormat') {
-                throw new AdapterError('InternalError', `paged method ${method.name} unexpected response format ${responseFormat}`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} unexpected response format ${responseFormat}`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
             }
             // 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 AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_o = method.__raw) === null || _o === void 0 ? void 0 : _o.node);
             }
             else if (synthesizedType.kind !== 'model') {
-                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
+                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_p = method.__raw) === null || _p === void 0 ? void 0 : _p.node);
             }
             const synthesizedModel = this.getModel(synthesizedType, new Array());
             const modelNs = this.adaptNamespace(synthesizedType.namespace);
@@ -1991,7 +2056,7 @@ export class Adapter {
             }
             // for the pager response type, remove the Option<T> around the Vec<T> for the page items
             if (!method.pagingMetadata.pageItemsSegments) {
-                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_q = method.__raw) === null || _q === void 0 ? void 0 : _q.node);
             }
             // unwrap all of the segments for the paged response
             let unwrappedCount = 0;
@@ -2002,13 +2067,13 @@ export class Adapter {
                 switch (responseFormat) {
                     case 'JsonFormat':
                         if (segment.kind !== 'property' || !segment.serializationOptions.json) {
-                            throw new AdapterError('InternalError', `paged method ${method.name} is missing JSON serialization data`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
+                            throw new AdapterError('InternalError', `paged method ${method.name} is missing JSON serialization data`, (_r = method.__raw) === null || _r === void 0 ? void 0 : _r.node);
                         }
                         serde = segment.serializationOptions.json.name;
                         break;
                     case 'XmlFormat':
                         if (segment.kind !== 'property' || !segment.serializationOptions.xml) {
-                            throw new AdapterError('InternalError', `paged method ${method.name} is missing XML serialization data`, (_o = method.__raw) === null || _o === void 0 ? void 0 : _o.node);
+                            throw new AdapterError('InternalError', `paged method ${method.name} is missing XML serialization data`, (_s = method.__raw) === null || _s === void 0 ? void 0 : _s.node);
                         }
                         serde = segment.serializationOptions.xml.name;
                         break;
@@ -2034,7 +2099,7 @@ export class Adapter {
                 }
             }
             if (unwrappedCount !== method.pagingMetadata.pageItemsSegments.length) {
-                throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_p = method.__raw) === null || _p === void 0 ? void 0 : _p.node);
+                throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_t = method.__raw) === null || _t === void 0 ? void 0 : _t.node);
             }
             this.crate.addDependency(new rust.CrateDependency('async-trait'));
             // default to nextLink. will update it as required when we have that info
@@ -2067,7 +2132,7 @@ export class Adapter {
             const statusModel = this.getModel(method.lroMetadata.pollingInfo.responseModel, undefined, `${rustClient.name}${utils.pascalCase(rustMethod.name, false)}OperationStatus`);
             const statusType = this.typeToWireType(statusModel);
             if (statusType.kind !== 'model') {
-                throw new AdapterError('InternalError', `status type for an LRO method '${method.name}' is not a model`, (_q = method.__raw) === null || _q === void 0 ? void 0 : _q.node);
+                throw new AdapterError('InternalError', `status type for an LRO method '${method.name}' is not a model`, (_u = method.__raw) === null || _u === void 0 ? void 0 : _u.node);
             }
             // the adapted type likely comes from core which means
             // it will be in the root namespace.  since we emit these
@@ -2124,10 +2189,10 @@ export class Adapter {
             // can't do this until the method has been completely adapted
             const pageableMethod = rustMethod;
             pageableMethod.strategy = this.adaptPageableMethodStrategy(method, paramsMap, responseHeadersMap);
-            if (((_r = pageableMethod.strategy) === null || _r === void 0 ? void 0 : _r.kind) === 'nextLink') {
+            if (((_v = pageableMethod.strategy) === null || _v === void 0 ? void 0 : _v.kind) === 'nextLink') {
                 pageableMethod.strategy.reinjectedParams = this.adaptPageableMethodReinjectionParams(method, paramsMap);
             }
-            else if (((_s = pageableMethod.strategy) === null || _s === void 0 ? void 0 : _s.kind) === 'continuationToken') {
+            else if (((_w = pageableMethod.strategy) === null || _w === void 0 ? void 0 : _w.kind) === 'continuationToken') {
                 // set the continuation type to token on the Pager and the PagerOptions field in the method options
                 pageableMethod.returns.type.continuation = 'token';
                 for (const field of pageableMethod.options.type.type.fields) {
@@ -2195,6 +2260,8 @@ export class Adapter {
                     return type.name;
                 case 'hashmap':
                     return `${type.name}${recursiveTypeName(type.type)}`;
+                case 'option':
+                    return `Option${recursiveTypeName(type.type)}`;
                 case 'ref':
                     return `Ref${recursiveTypeName(type.type)}`;
                 case 'scalar':
@@ -2369,7 +2436,7 @@ export class Adapter {
      * @returns a Rust method parameter
      */
     adaptMethodParameter(opParam, methodParam, lifetime) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         /**
          * used to create keys for this.clientMethodParams
          * @param param the param for which to create a key
@@ -2498,6 +2565,12 @@ export class Adapter {
                                 throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar path ${opParam.serializedName}`, (_g = opParam.__raw) === null || _g === void 0 ? void 0 : _g.node);
                         }
                         adaptedParam = new rust.PathScalarParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, opParam.allowReserved, style);
+                        const allowEmpty = ((_h = opParam.decorators.find(d => d.name === 'Azure.ClientGenerator.Core.@clientOption'
+                            && d.arguments['name'] === 'allowEmpty'
+                            && d.arguments['scope'] === 'rust')) === null || _h === void 0 ? void 0 : _h.arguments['value']) === true;
+                        if (allowEmpty) {
+                            adaptedParam.minLength = 0;
+                        }
                     }
                 }
                 break;
@@ -2521,7 +2594,7 @@ export class Adapter {
                         case 'model':
                         case 'slice':
                         case 'str':
-                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar query ${opParam.serializedName}`, (_h = opParam.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar query ${opParam.serializedName}`, (_j = opParam.__raw) === null || _j === void 0 ? void 0 : _j.node);
                     }
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
                     adaptedParam = new rust.QueryScalarParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, true);
@@ -2730,6 +2803,7 @@ function recursiveKeyName(root, type) {
     switch (type.kind) {
         case 'Vec':
         case 'box':
+        case 'option':
             return recursiveKeyName(`${root}-${type.kind}`, type.type);
         case 'encodedBytes':
             return `${root}-${type.kind}-${type.encoding}${type.slice ? '-slice' : ''}`;
@@ -2904,4 +2978,55 @@ function isLibNamespace(namespace) {
     const ns = namespace.toLowerCase();
     return LIB_NAMESPACE.some((lib) => ns === lib || ns.startsWith(lib + '.'));
 }
+/**
+ * narrows type to a RefType within the conditional block.
+ * this function throws if the narrowing is not possible.
+ */
+function typeToRefType(type) {
+    switch (type.kind) {
+        case 'bytes':
+        case 'decimal':
+        case 'discriminatedUnion':
+        case 'encodedBytes':
+        case 'enum':
+        case 'enumValue':
+        case 'Etag':
+        case 'external':
+        case 'hashmap':
+        case 'jsonValue':
+        case 'model':
+        case 'offsetDateTime':
+        case 'option':
+        case 'safeint':
+        case 'scalar':
+        case 'slice':
+        case 'str':
+        case 'String':
+        case 'untaggedUnion':
+        case 'Url':
+        case 'Vec':
+            return true;
+        default:
+            throw new AdapterError('InternalError', `cannot convert ${type.kind} to a ref type`);
+    }
+}
+/**
+ * returns true if model is a polymorphic root type.
+ *
+ * @param model the model to inspect
+ * @returns true if the model is a polymorphic root
+ */
+function isPolymorphicRoot(model) {
+    if (model.discriminatedSubtypes) {
+        // when there are sub-types we know for sure it's a polymorphic root
+        return true;
+    }
+    else if (model.discriminatorProperty && !model.discriminatorValue) {
+        // we can land here if it's a root but has no child types
+        return true;
+    }
+    else {
+        return false;
+    }
+}
 //# sourceMappingURL=adapter.js.map