Compilation error: codegen emits the code for optional api version, when it is not

[antkmsft]

This affects specification/purview/data-plane/datamap:

error[E0277]: the trait bound `std::string::String: AsRef<std::option::Option<_>>` is not satisfied
  --> spec\datamap\src\generated\clients\data_map_discovery_client.rs:47:53
   |
47 |         if let Some(api_version) = self.api_version.as_ref() {
   |                                                     ^^^^^^ the trait `AsRef<std::option::Option<_>>` is not implemented for `std::string::String`
   |
   = help: the following other types implement trait `AsRef<T>`:
             `std::string::String` implements `AsRef<OsStr>`
             `std::string::String` implements `AsRef<Path>`
             `std::string::String` implements `AsRef<[u8]>`
             `std::string::String` implements `AsRef<str>`

when

...
#[tracing::client]
pub struct DataMapDiscoveryClient {
    pub(crate) api_version: String, // <-- declared here
    pub(crate) endpoint: Url,
    pub(crate) pipeline: Pipeline,
}

impl DataMapDiscoveryClient {
    ...
    #[tracing::function("Customizations.Discovery.autoComplete")]
    pub async fn auto_complete(
        &self,
        body: RequestContent<AutoCompleteOptions>,
        options: Option<DataMapDiscoveryClientAutoCompleteOptions<'_>>,
    ) -> Result<Response<AutoCompleteResult>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        url.append_path("/search/autocomplete");
        let mut query_builder = url.query_builder();
        if let Some(api_version) = self.api_version.as_ref() { // <--fails here
            query_builder.set_pair("api-version", api_version);
        }
        ...

[RickWinter]

Analysis: Emitter generates optional api-version code for a required parameter

Problem

The emitter generates if let Some(api_version) = self.api_version.as_ref() { ... } for the api-version query parameter, even when the client struct declares api_version as a non-optional String field. This causes:

error[E0277]: the trait bound `String: AsRef<Option<_>>` is not satisfied

Affected spec: specification/purview/data-plane/datamap.

Root Cause

This is not a special-cased api-version bug — it follows the generic optional parameter code path in clients.ts (lines ~876-891). The emitter checks param.optional and, when true, wraps the parameter access in if let Some(...).

The issue is upstream in how the parameter is modeled:

• In packages/typespec-rust/src/tcgcadapter/adapter.ts (lines ~1790-1805), parameter optionality is determined from TCGC: param.optional || param.clientDefaultValue maps to optional.
• If the TypeSpec api-version parameter has a clientDefaultValue set, the adapter marks it as optional even though it''s a required field on the client struct.
• The client struct field is emitted as api_version: String (not Option<String>), but the method body treats it as optional.

The mismatch: the struct field is String (required), but the method body code treats it as Option<String> because the parameter model says optional: true.

Plan to Fix

1. In adapter.ts: Distinguish between "has a default value" and "is truly optional". A parameter with clientDefaultValue should be required on the struct (with the default applied at construction) but should NOT be wrapped in if let Some(...) in method bodies.
2. In clients.ts: When emitting query parameter code for client-owned parameters, check whether the actual struct field is String vs Option<String> rather than relying solely on param.optional. If the field is String, emit direct access: query_builder.set_pair("api-version", &self.api_version).
3. Alternative: Add a separate flag like hasDefaultValue distinct from optional so codegen can differentiate the two cases.

Plan to Test

1. Unit test: Add a TypeSpec test with a client that has a required api-version parameter (with a default value). Regenerate and verify the generated code uses direct access, not if let Some(...).
2. Targeted spec compilation: Generate the Purview DataMap spec and verify cargo check passes.
3. Regression: Regenerate all test crates and verify no existing tests break — many specs use api-version, so this is a wide-impact change.