Add Spector test coverage for CommonPropertiesErrorClient methods

packages/typespec-rust/.scripts/tspcompile.js

@@ -234,6 +234,12 @@ function generate(crate, input, outputDir, additionalArgs) {
       additionalArgs[i] = `--option="@azure-tools/typespec-rust.${additionalArgs[i]}"`;
     }
   }
+
+  const tspConfigPath = `${outputDir}/tspconfig.yaml`;
+  if (fs.existsSync(tspConfigPath)) {
+    additionalArgs.push(`--config=${tspConfigPath}`);
+  }
+
   sem.take(async function() {
     // if a tsp file isn't specified, first check
     // for a client.tsp file. if that doesn't exist

packages/typespec-rust/src/codegen/context.ts

@@ -131,6 +131,33 @@ export class Context {
     return content;
   }
 
+  /**
+   * returns the impl azure_core::Error for the error type.
+   * if no impl is required, the empty string is returned.
+   *
+   * @param model the model for which to implement TryFrom
+   * @param use the use statement builder currently in scope
+   * @returns the impl TryFrom<T> block for type or the empty string
+   */
+  getTryFromForError(model: rust.Model, use: Use): string {
+    if ((model.flags & rust.ModelFlags.Error) === 0) {
+      return '';
+    }
+
+    use.add('azure_core::error', 'ErrorKind');
+    const indent = new helpers.indentation();
+    let content = `impl TryFrom<azure_core::Error> for ${helpers.getTypeDeclaration(model)} {\n`;
+    content += `${indent.get()}type Error = azure_core::Error;\n`;
+    content += `${indent.get()}fn try_from(error: azure_core::Error) -> std::result::Result<Self, Self::Error> {\n`;
+    content += `${indent.push().get()}match error.kind() {`
+    content += `${indent.push().get()}ErrorKind::HttpResponse { raw_response: Some(raw_response), .. } => Ok(serde_json::from_str(raw_response.body().clone().into_string()?.as_ref())?),`;
+    content += `${indent.get()}_ => Err(azure_core::Error::with_message(azure_core::error::ErrorKind::DataConversion, "ErrorKind was not HttpResponse and could not be parsed."))`;
+    content += `${indent.pop().get()}}\n`;
+    content += `${indent.pop().get()}}\n`;
+    content += '}\n\n';
+    return content;
+  }
+
   /**
    * returns the body format for the provided model
    * 

packages/typespec-rust/src/codegen/models.ts

@@ -294,6 +294,13 @@ function emitModelImpls(crate: rust.Crate, context: Context): helpers.Module | u
       entries.push(forReq);
     }
 
+    const forErr = context.getTryFromForError(model, use);
+    if (forErr) {
+      use.addForType(model);
+      entries.push(forErr);
+    }
+
+
     const pageImpl = context.getPageImplForType(model, use);
     if (pageImpl) {
       use.addForType(model);

packages/typespec-rust/src/codemodel/types.ts

@@ -340,6 +340,9 @@ export enum ModelFlags {
 
   /** model is a sub-type in a polymorphic discriminated union */
   PolymorphicSubtype = 4,
+
+  /** model is an error */
+  Error = 8,
 }
 
 /** DateTimeEncoding is the wire format of the date/time */

packages/typespec-rust/src/lib.ts

@@ -19,6 +19,8 @@ export interface RustEmitterOptions {
   'overwrite-lib-rs': boolean;
   /** Whether to omit documentation links in generated code. Defaults to false */
   'temp-omit-doc-links': boolean;
+  /** Whether to emit error types */
+  'emit-error-types': boolean;
 }
 
 const EmitterOptionsSchema: JSONSchemaType<RustEmitterOptions> = {
@@ -59,6 +61,12 @@ const EmitterOptionsSchema: JSONSchemaType<RustEmitterOptions> = {
       default: false,
       description: 'Whether to omit documentation links in generated code. Defaults to false'
     },
+    'emit-error-types': {
+      type: 'boolean',
+      nullable: false,
+      default: false,
+      description: 'Whether to emit error types. Defaults to false'
+    },
   },
   required: [
     'crate-name',

packages/typespec-rust/src/tcgcadapter/adapter.ts

@@ -180,8 +180,36 @@ export class Adapter {
 
     const processedTypes = new Set<string>();
 
+    const getErrorModelNames = function(clients: tcgc.SdkClientType<tcgc.SdkHttpOperation>[], visitedClientNames = new Set<string>()) : Set<string> {
+      const errorModelNames = new Set<string>();
+      for (const client of clients) {
+        if (visitedClientNames.has(client.name)) {
+          continue;
+        }
+        visitedClientNames.add(client.name);
+        for (const errorModelName
+          of client.methods.flatMap(mt => mt.operation.exceptions).filter(
+            e => e.type?.kind === 'model').map(md => (md.type as tcgc.SdkModelType).name)
+        ) {
+          errorModelNames.add(errorModelName);
+        }
+
+        for (const errorModelName of getErrorModelNames(client.children ?? [], visitedClientNames).values()) {
+          errorModelNames.add(errorModelName);
+        }
+      }
+
+      return errorModelNames;
+    }
+
+    const errorModelNames = getErrorModelNames(this.ctx.sdkPackage.clients);
+
     for (const model of this.ctx.sdkPackage.models) {
-      if ((model.usage & tcgc.UsageFlags.Input) === 0 && (model.usage & tcgc.UsageFlags.Output) === 0 && (model.usage & tcgc.UsageFlags.Spread) === 0) {
+      let usageFlags = tcgc.UsageFlags.Input | tcgc.UsageFlags.Output | tcgc.UsageFlags.Spread;
+      if (this.options['emit-error-types']) {
+        usageFlags |= tcgc.UsageFlags.Exception;
+      }
+      if ((model.usage & usageFlags) === 0) {
         // skip types without input and output usage. this will include core
         // types unless they're explicitly referenced (e.g. a model property).
         // we keep the models for spread params as we internally use them.
@@ -210,6 +238,9 @@ export class Adapter {
         this.getExternalType(model.external);
       } else {
         const rustModel = this.getModel(model);
+        if ((model.usage & tcgc.UsageFlags.Exception) !== 0 && errorModelNames.has(model.name)) {
+          rustModel.flags |= rust.ModelFlags.Error;
+        }
         this.crate.models.push(rustModel);
       }
     }
@@ -372,7 +403,6 @@ export class Adapter {
     // include error and LRO polling types as output types
     if (
       <tcgc.UsageFlags>(model.usage & tcgc.UsageFlags.Output) === tcgc.UsageFlags.Output ||
-      <tcgc.UsageFlags>(model.usage & tcgc.UsageFlags.Exception) === tcgc.UsageFlags.Exception ||
       <tcgc.UsageFlags>(model.usage & tcgc.UsageFlags.LroPolling) === tcgc.UsageFlags.LroPolling
     ) {
       modelFlags |= rust.ModelFlags.Output;

packages/typespec-rust/test/spector/azure/resource-manager/common-properties/Cargo.toml

@@ -13,6 +13,7 @@ default = ["azure_core/default"]
 [dependencies]
 azure_core = { workspace = true }
 serde = { workspace = true }
+serde_json = { workspace = true }
 
 [dev-dependencies]
 async-trait = { workspace = true }

packages/typespec-rust/test/spector/azure/resource-manager/common-properties/tests/common/mod.rs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+use azure_core::credentials::{AccessToken, TokenCredential, TokenRequestOptions};
+use azure_core::time::OffsetDateTime;
+use azure_core::Result;
+use spector_armcommon::CommonPropertiesClient;
+use std::sync::Arc;
+
+#[derive(Debug)]
+struct FakeTokenCredential {
+    pub token: String,
+}
+
+impl FakeTokenCredential {
+    pub fn new(token: String) -> Self {
+        FakeTokenCredential { token }
+    }
+}
+
+#[async_trait::async_trait]
+impl TokenCredential for FakeTokenCredential {
+    async fn get_token(
+        &self,
+        _scopes: &[&str],
+        _options: Option<TokenRequestOptions<'_>>,
+    ) -> Result<AccessToken> {
+        Ok(AccessToken::new(
+            self.token.clone(),
+            OffsetDateTime::now_utc(),
+        ))
+    }
+}
+
+pub fn create_client() -> CommonPropertiesClient {
+    CommonPropertiesClient::new(
+        "http://localhost:3000",
+        Arc::new(FakeTokenCredential::new("fake_token".to_string())),
+        "00000000-0000-0000-0000-000000000000".to_string(),
+        None,
+    )
+    .unwrap()
+}