Use Azure.Core ResponseError type for errors (Azure#49817)

* Use Azure.Core ResponseError type for errors

* PR fb

Author: JoshLove-msft

eng/packages/http-client-csharp/generator/Azure.Generator/src/AzureTypeFactory.cs

@@ -16,6 +16,7 @@
 using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.Text.Json;
+using Microsoft.TypeSpec.Generator.Providers;
 
 namespace Azure.Generator
 {
@@ -65,6 +66,14 @@ public class AzureTypeFactory : ScmTypeFactory
                     return result;
                 }
             }
+            else if (inputType is InputModelType inputModelType)
+            {
+                if (KnownAzureTypes.TryGetKnownType(inputModelType.CrossLanguageDefinitionId, out var knownType))
+                {
+                    return knownType;
+                }
+            }
+
             return base.CreateCSharpTypeCore(inputType);
         }
 
@@ -73,7 +82,7 @@ public class AzureTypeFactory : ScmTypeFactory
             InputPrimitiveType? primitiveType = inputType;
             while (primitiveType != null)
             {
-                if (KnownAzureTypes.TryGetPrimitiveType(primitiveType.CrossLanguageDefinitionId, out var knownType))
+                if (KnownAzureTypes.TryGetKnownType(primitiveType.CrossLanguageDefinitionId, out var knownType))
                 {
                     return knownType;
                 }
@@ -84,6 +93,17 @@ public class AzureTypeFactory : ScmTypeFactory
             return null;
         }
 
+        /// <inheritdoc/>
+        protected override IReadOnlyList<TypeProvider> CreateSerializationsCore(InputType inputType, TypeProvider typeProvider)
+        {
+            if (KnownAzureTypes.IsModelTypeWithoutSerialization(typeProvider.Type))
+            {
+                return [];
+            }
+
+            return base.CreateSerializationsCore(inputType, typeProvider);
+        }
+
         /// <inheritdoc/>
 #pragma warning disable AZC0014 // Avoid using banned types in public API
         public override ValueExpression DeserializeJsonValue(Type valueType, ScopedApi<JsonElement> element, SerializationFormat format)

eng/packages/http-client-csharp/generator/Azure.Generator/src/Primitives/KnownAzureTypes.cs

@@ -29,6 +29,7 @@ internal static class KnownAzureTypes
         private const string ETagId = "Azure.Core.eTag";
         private const string AzureLocationId = "Azure.Core.azureLocation";
         private const string ArmIdId = "Azure.Core.armResourceIdentifier";
+        private const string AzureError = "Azure.Core.Foundations.Error";
 
         private static MethodBodyStatement SerializeTypeWithImplicitOperatorToString(ValueExpression value, ScopedApi<Utf8JsonWriter> writer, ScopedApi<ModelReaderWriterOptions> options, SerializationFormat format)
             => writer.WriteStringValue(value);
@@ -42,6 +43,14 @@ private static MethodBodyStatement SerializeTypeWithToString(ValueExpression val
         private static ValueExpression DeserializeParsableStringLikeType(CSharpType valueType, ScopedApi<JsonElement> element, SerializationFormat format)
             => Static(valueType).Invoke("Parse", element.GetString());
 
+        private static MethodBodyStatement SerializeResponseError(ValueExpression value, ScopedApi<Utf8JsonWriter> writer, ScopedApi<ModelReaderWriterOptions> options, SerializationFormat format)
+            => Static(typeof(JsonSerializer)).Invoke(nameof(JsonSerializer.Serialize), writer, value).Terminate();
+
+        private static ValueExpression DeserializeResponseError(CSharpType valueType,
+            ScopedApi<JsonElement> element,
+            SerializationFormat format)
+            => Static(typeof(JsonSerializer)).Invoke(nameof(JsonSerializer.Deserialize), arguments: [element.GetRawText()], typeArguments: [valueType], callAsAsync: false);
+
         private static readonly IReadOnlyDictionary<string, CSharpType> _idToTypes = new Dictionary<string, CSharpType>
         {
             [UuidId] = typeof(Guid),
@@ -50,6 +59,7 @@ private static ValueExpression DeserializeParsableStringLikeType(CSharpType valu
             [ETagId] = typeof(ETag),
             [AzureLocationId] = typeof(AzureLocation),
             [ArmIdId] = typeof(ResourceIdentifier),
+            [AzureError] = typeof(ResponseError),
         };
 
         private static readonly IReadOnlyDictionary<Type, SerializationExpression> _typeToSerializationExpression = new Dictionary<Type, SerializationExpression>
@@ -59,6 +69,7 @@ private static ValueExpression DeserializeParsableStringLikeType(CSharpType valu
             [typeof(ETag)] = SerializeTypeWithToString,
             [typeof(AzureLocation)] = SerializeTypeWithImplicitOperatorToString,
             [typeof(ResourceIdentifier)] = SerializeTypeWithImplicitOperatorToString,
+            [typeof(ResponseError)] = SerializeResponseError,
         };
 
         private static readonly IReadOnlyDictionary<Type, DeserializationExpression> _typeToDeserializationExpression = new Dictionary<Type, DeserializationExpression>
@@ -68,9 +79,20 @@ private static ValueExpression DeserializeParsableStringLikeType(CSharpType valu
             [typeof(ETag)] = DeserializeNewInstanceStringLikeType,
             [typeof(AzureLocation)] = DeserializeNewInstanceStringLikeType,
             [typeof(ResourceIdentifier)] = DeserializeNewInstanceStringLikeType,
+            [typeof(ResponseError)] = DeserializeResponseError,
         };
 
-        public static bool TryGetPrimitiveType(string id, [MaybeNullWhen(false)] out CSharpType type) => _idToTypes.TryGetValue(id, out type);
+        public static bool IsModelTypeWithoutSerialization(CSharpType type)
+        {
+            if (type.Equals(typeof(ResponseError)))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool TryGetKnownType(string id, [MaybeNullWhen(false)] out CSharpType type) => _idToTypes.TryGetValue(id, out type);
 
         public static bool TryGetJsonSerializationExpression(Type type, [MaybeNullWhen(false)] out SerializationExpression expression) => _typeToSerializationExpression.TryGetValue(type, out expression);
 

eng/packages/http-client-csharp/generator/Azure.Generator/test/AzureTypeFactoryTests.cs

@@ -28,6 +28,7 @@ public void SetUp()
         [TestCase(typeof(ETag), ExpectedResult = "writer.WriteStringValue(value.ToString());\n")]
         [TestCase(typeof(AzureLocation), ExpectedResult = "writer.WriteStringValue(value);\n")]
         [TestCase(typeof(ResourceIdentifier), ExpectedResult = "writer.WriteStringValue(value);\n")]
+        [TestCase(typeof(ResponseError), ExpectedResult = "global::System.Text.Json.JsonSerializer.Serialize(writer, value);\n")]
         public string ValidateSerializationStatement(Type type)
         {
             var value = new ParameterProvider("value", $"", type).AsExpression().As(type);
@@ -45,6 +46,7 @@ public string ValidateSerializationStatement(Type type)
         [TestCase(typeof(ETag), ExpectedResult = "new global::Azure.ETag(element.GetString())")]
         [TestCase(typeof(AzureLocation), ExpectedResult = "new global::Azure.Core.AzureLocation(element.GetString())")]
         [TestCase(typeof(ResourceIdentifier), ExpectedResult = "new global::Azure.Core.ResourceIdentifier(element.GetString())")]
+        [TestCase(typeof(ResponseError), ExpectedResult = "global::System.Text.Json.JsonSerializer.Deserialize<global::Azure.ResponseError>(element.GetRawText())")]
         public string ValidateDeserializationExpression(Type type)
         {
             var element = new ParameterProvider("element", $"", typeof(JsonElement)).AsExpression().As<JsonElement>();
@@ -126,5 +128,17 @@ public void ResourceIdentifier()
             Assert.IsTrue(actual?.IsFrameworkType);
             Assert.AreEqual(typeof(ResourceIdentifier), actual?.FrameworkType);
         }
+
+        [Test]
+        public void ResponseError()
+        {
+            var input = InputFactory.Primitive.String("responseError", "Azure.Core.Foundations.Error");
+
+            var actual = AzureClientGenerator.Instance.TypeFactory.CreateCSharpType(input);
+
+            Assert.IsNotNull(actual);
+            Assert.IsTrue(actual?.IsFrameworkType);
+            Assert.AreEqual(typeof(ResponseError), actual?.FrameworkType);
+        }
     }
 }