Serialize configuration and tspCodeModel from swagger

src/AutoRest.CSharp/Common/AutoRest/Plugins/CSharpGen.cs

@@ -50,7 +50,7 @@ public async Task<GeneratedCodeWorkspace> ExecuteAsync(CodeModel codeModel)
             {
                 CodeModelTransformer.TransformForMgmt(codeModel);
                 var inputNamespace = new CodeModelConverter(codeModel, schemaUsageProvider).CreateNamespace();
-                await AzurePluginTarget.ExecuteAsync(project, inputNamespace);
+                await MicrosoftTypeSpecGeneratorTarget.ExecuteAsync(project, inputNamespace);
             }
             else
             {
@@ -142,7 +142,8 @@ public async Task<bool> Execute(IPluginCommunication autoRest)
                 }
 
                 // generate csproj if necessary
-                if (!Configuration.SkipCSProj)
+                // when we generate via azure plugin, the csproj should be handled by the azure plugin, therefore here we skip it
+                if (!Configuration.SkipCSProj && !Configuration.UseAzurePlugin)
                 {
                     bool needAzureKeyAuth = codeModel.Security.Schemes.Any(scheme => scheme is KeySecurityScheme);
                     bool includeDfe = codeModelYaml.Contains("x-ms-format: dfe-", StringComparison.Ordinal);

src/AutoRest.CSharp/Common/Input/CodeModelConverter.cs

@@ -809,6 +809,11 @@ private InputEnumType CreateEnumType(Schema schema, PrimitiveSchema choiceType,
         {
             var usage = _schemaUsageProvider.GetUsage(schema);
             var valueType = (InputPrimitiveType)CreateType(choiceType, schema.Extensions?.Format, false);
+            // the enum in typespec model only supports string int32 float32 and boolean
+            if (valueType.Kind != InputPrimitiveTypeKind.String && valueType.Kind != InputPrimitiveTypeKind.Int32 && valueType.Kind != InputPrimitiveTypeKind.Float32 && valueType.Kind != InputPrimitiveTypeKind.Boolean)
+            {
+                throw new NotSupportedException($"Enum type {valueType} is not supported");
+            }
             var inputEnumType = new InputEnumType(
                 Name: schema.Name,
                 CrossLanguageDefinitionId: GetCrossLanguageDefinitionId(schema),
@@ -842,12 +847,40 @@ private static string GetCrossLanguageDefinitionId(Schema schema)
         private static InputEnumTypeValue CreateEnumValue(ChoiceValue choiceValue, InputPrimitiveType valueType)
         {
             // in code model, the value of choices are defined to be strings. We need to convert them back to their real values
-            var value = ConvertRawValue(valueType, choiceValue.Value);
-            return new(
-                Name: choiceValue.Language.Default.Name,
-                Summary: string.Empty,
-                Doc: choiceValue.Language.Default.Description,
-                Value: value!);
+            var value = ConvertRawEnumValue(valueType, choiceValue.Value);
+            var name = choiceValue.Language.Default.Name;
+            var doc = choiceValue.Language.Default.Description;
+            switch (valueType.Kind)
+            {
+                case InputPrimitiveTypeKind.String:
+                    return new InputEnumTypeStringValue(name, (string)value, string.Empty, doc);
+                case InputPrimitiveTypeKind.Int32:
+                    return new InputEnumTypeIntegerValue(name, (int)value, string.Empty, doc);
+                case InputPrimitiveTypeKind.Float32:
+                    return new InputEnumTypeFloatValue(name, (float)value, string.Empty, doc);
+                default:
+                    return new InputEnumTypeStringValue(name, value.ToString()!, string.Empty, doc);
+            }
+
+            static object ConvertRawEnumValue(InputPrimitiveType inputType, object originalValue)
+            {
+                if (originalValue is string strValue)
+                {
+                    switch (inputType)
+                    {
+                        case InputPrimitiveType { Kind: InputPrimitiveTypeKind.Int32 }:
+                            return int.TryParse(strValue, out var intValue) ? intValue : default(int);
+                        case InputPrimitiveType { Kind: InputPrimitiveTypeKind.Float32 }:
+                            return float.TryParse(strValue, out var floatValue) ? floatValue : default(float);
+                        case InputPrimitiveType { Kind: InputPrimitiveTypeKind.Boolean }:
+                            return bool.TryParse(strValue, out var boolValue) ? boolValue : default(bool);
+                        default:
+                            return strValue;
+                    }
+                }
+
+                return originalValue;
+            }
         }
 
         private static RequestLocation GetRequestLocation(RequestParameter requestParameter) => requestParameter.In switch

src/AutoRest.CSharp/Common/Input/InputTypes/InputDecoratorInfo.cs

@@ -8,12 +8,12 @@ namespace AutoRest.CSharp.Common.Input
 {
     public class InputDecoratorInfo
     {
-        public InputDecoratorInfo(string name, IReadOnlyDictionary<string, BinaryData>? arguments)
+        public InputDecoratorInfo(string name, IReadOnlyDictionary<string, BinaryData> arguments)
         {
             Name = name;
             Arguments = arguments;
         }
         public string Name { get; }
-        public IReadOnlyDictionary<string, BinaryData>? Arguments { get; }
+        public IReadOnlyDictionary<string, BinaryData> Arguments { get; }
     }
 }

src/AutoRest.CSharp/Common/Input/InputTypes/InputEnumTypeValue.cs

@@ -5,7 +5,7 @@
 
 namespace AutoRest.CSharp.Common.Input;
 
-internal record InputEnumTypeValue(string Name, object Value, string? Summary, string? Doc)
+internal abstract record InputEnumTypeValue(string Name, object Value, string? Summary, string? Doc)
 {
     public virtual string GetJsonValueString() => GetValueString();
     public string GetValueString() => (Value.ToString() ?? string.Empty);

src/AutoRest.CSharp/Common/Input/InputTypes/InputType.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-using System;
 using System.Collections.Generic;
 using AutoRest.CSharp.Common.Input.InputTypes;
 

src/AutoRest.CSharp/Common/Input/InputTypes/Serialization/TypeSpecInputDateTimeTypeConverter.cs

@@ -5,11 +5,15 @@
 using System.Collections.Generic;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using AutoRest.CSharp.Utilities;
 
 namespace AutoRest.CSharp.Common.Input
 {
     internal class TypeSpecInputDateTimeTypeConverter : JsonConverter<InputDateTimeType>
     {
+        internal const string UtcDateTimeKind = "utcDateTime";
+        internal const string OffsetDateTimeKind = "offsetDateTime";
+
         private readonly TypeSpecReferenceHandler _referenceHandler;
         public TypeSpecInputDateTimeTypeConverter(TypeSpecReferenceHandler referenceHandler)
         {
@@ -19,9 +23,6 @@ public TypeSpecInputDateTimeTypeConverter(TypeSpecReferenceHandler referenceHand
         public override InputDateTimeType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
            => reader.ReadReferenceAndResolve<InputDateTimeType>(_referenceHandler.CurrentResolver) ?? CreateDateTimeType(ref reader, null, null, options, _referenceHandler.CurrentResolver);
 
-        public override void Write(Utf8JsonWriter writer, InputDateTimeType value, JsonSerializerOptions options)
-            => throw new NotSupportedException("Writing not supported");
-
         public static InputDateTimeType CreateDateTimeType(ref Utf8JsonReader reader, string? id, string? name, JsonSerializerOptions options, ReferenceResolver resolver)
         {
             var isFirstProperty = id == null;
@@ -65,5 +66,26 @@ public static InputDateTimeType CreateDateTimeType(ref Utf8JsonReader reader, st
             }
             return dateTimeType;
         }
+
+        public override void Write(Utf8JsonWriter writer, InputDateTimeType value, JsonSerializerOptions options)
+            => writer.WriteObjectOrReference<InputDateTimeType>(value, options, _referenceHandler.CurrentResolver, WriteInputDateTimeType);
+
+        private static void WriteInputDateTimeType(Utf8JsonWriter writer, InputDateTimeType value, JsonSerializerOptions options)
+        {
+            // kind
+            writer.WriteString("kind", UtcDateTimeKind); // TODO -- currently the two different kinds have exactly the same properties, therefore here we no longer have the ability to distinguish
+            // name
+            writer.WriteString("name", value.Name);
+            // encode
+            writer.WriteString("encode", value.Encode.ToString().FirstCharToLowerCase());
+            // wireType
+            writer.WriteObject("wireType", value.WireType, options);
+            // crossLanguageDefinitionId
+            writer.WriteString("crossLanguageDefinitionId", value.CrossLanguageDefinitionId);
+            // baseType
+            writer.WriteObjectIfPresent("baseType", value.BaseType, options);
+            // decorators
+            writer.WriteArray("decorators", value.Decorators, options);
+        }
     }
 }

src/AutoRest.CSharp/Common/Input/InputTypes/Serialization/TypeSpecInputDecoratorInfoConverter.cs

@@ -20,9 +20,6 @@ public TypeSpecInputDecoratorInfoConverter(TypeSpecReferenceHandler referenceHan
         public override InputDecoratorInfo? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
             => reader.ReadReferenceAndResolve<InputDecoratorInfo>(_referenceHandler.CurrentResolver) ?? CreateDecoratorInfo(ref reader, null, options, _referenceHandler.CurrentResolver);
 
-        public override void Write(Utf8JsonWriter writer, InputDecoratorInfo value, JsonSerializerOptions options)
-            => throw new NotSupportedException("Writing not supported");
-
         private static InputDecoratorInfo? CreateDecoratorInfo(ref Utf8JsonReader reader, string? id, JsonSerializerOptions options, ReferenceResolver resolver)
         {
             var isFirstProperty = id == null;
@@ -40,13 +37,24 @@ public override void Write(Utf8JsonWriter writer, InputDecoratorInfo value, Json
                 }
             }
             reader.Read();
-            var decoratorInfo = new InputDecoratorInfo(name ?? throw new JsonException("InputDecoratorInfo must have name"), arguments);
+            var decoratorInfo = new InputDecoratorInfo(name ?? throw new JsonException("InputDecoratorInfo must have name"), arguments ?? new Dictionary<string, BinaryData>());
 
             if (id != null)
             {
                 resolver.AddReference(id, decoratorInfo);
             }
             return decoratorInfo;
         }
+
+        public override void Write(Utf8JsonWriter writer, InputDecoratorInfo value, JsonSerializerOptions options)
+        {
+            // the decorators do not need an id
+            writer.WriteStartObject();
+
+            writer.WriteString("name", value.Name);
+            writer.WriteDictionary("arguments", value.Arguments);
+
+            writer.WriteEndObject();
+        }
     }
 }

src/AutoRest.CSharp/Common/Input/InputTypes/Serialization/TypeSpecInputDictionaryTypeConverter.cs

@@ -10,6 +10,8 @@ namespace AutoRest.CSharp.Common.Input
 {
     internal sealed class TypeSpecInputDictionaryTypeConverter : JsonConverter<InputDictionaryType>
     {
+        internal const string DictionaryKind = "dict";
+
         private readonly TypeSpecReferenceHandler _referenceHandler;
 
         public TypeSpecInputDictionaryTypeConverter(TypeSpecReferenceHandler referenceHandler)
@@ -20,9 +22,6 @@ public TypeSpecInputDictionaryTypeConverter(TypeSpecReferenceHandler referenceHa
         public override InputDictionaryType? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
             => reader.ReadReferenceAndResolve<InputDictionaryType>(_referenceHandler.CurrentResolver) ?? CreateDictionaryType(ref reader, null, options, _referenceHandler.CurrentResolver);
 
-        public override void Write(Utf8JsonWriter writer, InputDictionaryType value, JsonSerializerOptions options)
-            => throw new NotSupportedException("Writing not supported");
-
         public static InputDictionaryType CreateDictionaryType(ref Utf8JsonReader reader, string? id, JsonSerializerOptions options, ReferenceResolver resolver)
         {
             var isFirstProperty = id == null;
@@ -56,5 +55,20 @@ public static InputDictionaryType CreateDictionaryType(ref Utf8JsonReader reader
             }
             return dictType;
         }
+
+        public override void Write(Utf8JsonWriter writer, InputDictionaryType value, JsonSerializerOptions options)
+            => writer.WriteObjectOrReference(value, options, _referenceHandler.CurrentResolver, WriteInputDictionaryTypeProperties);
+
+        private static void WriteInputDictionaryTypeProperties(Utf8JsonWriter writer, InputDictionaryType value, JsonSerializerOptions options)
+        {
+            // kind
+            writer.WriteString("kind", DictionaryKind);
+            // keyType
+            writer.WriteObject("keyType", value.KeyType, options);
+            // valueType
+            writer.WriteObject("valueType", value.ValueType, options);
+            // decorators
+            writer.WriteArray("decorators", value.Decorators, options);
+        }
     }
 }

src/AutoRest.CSharp/Common/Input/InputTypes/Serialization/TypeSpecInputDurationTypeConverter.cs

@@ -10,6 +10,8 @@ namespace AutoRest.CSharp.Common.Input
 {
     internal class TypeSpecInputDurationTypeConverter : JsonConverter<InputDurationType>
     {
+        internal const string DurationKind = "duration";
+
         private readonly TypeSpecReferenceHandler _referenceHandler;
         public TypeSpecInputDurationTypeConverter(TypeSpecReferenceHandler referenceHandler)
         {
@@ -19,9 +21,6 @@ public TypeSpecInputDurationTypeConverter(TypeSpecReferenceHandler referenceHand
         public override InputDurationType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
            => reader.ReadReferenceAndResolve<InputDurationType>(_referenceHandler.CurrentResolver) ?? CreateDurationType(ref reader, null, null, options, _referenceHandler.CurrentResolver);
 
-        public override void Write(Utf8JsonWriter writer, InputDurationType value, JsonSerializerOptions options)
-            => throw new NotSupportedException("Writing not supported");
-
         public static InputDurationType CreateDurationType(ref Utf8JsonReader reader, string? id, string? name, JsonSerializerOptions options, ReferenceResolver resolver)
         {
             var isFirstProperty = id == null;
@@ -61,9 +60,11 @@ public static InputDurationType CreateDurationType(ref Utf8JsonReader reader, st
             return dateTimeType;
         }
 
+        private const string DurationConstantEncode = "duration-constant";
+
         private static DurationKnownEncoding CreateDurationKnownEncoding(string encode)
         {
-            if (encode == "duration-constant")
+            if (encode == DurationConstantEncode)
             {
                 return DurationKnownEncoding.DurationConstant;
             }
@@ -73,5 +74,30 @@ private static DurationKnownEncoding CreateDurationKnownEncoding(string encode)
             }
             throw new JsonException($"Encoding of Duration type {encode} is unknown.");
         }
+
+        public override void Write(Utf8JsonWriter writer, InputDurationType value, JsonSerializerOptions options)
+            => writer.WriteObjectOrReference(value, options, _referenceHandler.CurrentResolver, WriteInputDurationTypeProperties);
+
+        private static void WriteInputDurationTypeProperties(Utf8JsonWriter writer, InputDurationType value, JsonSerializerOptions options)
+        {
+            // kind
+            writer.WriteString("kind", DurationKind);
+            // name
+            writer.WriteString("name", value.Name);
+            // encode
+            writer.WriteString("encode", value.Encode switch
+            {
+                DurationKnownEncoding.DurationConstant => DurationConstantEncode,
+                _ => value.Encode.ToString().ToLowerInvariant(),
+            });
+            // wireType
+            writer.WriteObject("wireType", value.WireType, options);
+            // crossLanguageDefinitionId
+            writer.WriteString("crossLanguageDefinitionId", value.CrossLanguageDefinitionId);
+            // baseType
+            writer.WriteObjectIfPresent("baseType", value.BaseType, options);
+            // decorators
+            writer.WriteArray("decorators", value.Decorators, options);
+        }
     }
 }

src/AutoRest.CSharp/Common/Input/InputTypes/Serialization/TypeSpecInputEnumTypeConverter.cs

@@ -11,6 +11,8 @@ namespace AutoRest.CSharp.Common.Input
 {
     internal sealed class TypeSpecInputEnumTypeConverter : JsonConverter<InputEnumType>
     {
+        internal const string EnumKind = "enum";
+
         private readonly TypeSpecReferenceHandler _referenceHandler;
 
         public TypeSpecInputEnumTypeConverter(TypeSpecReferenceHandler referenceHandler)
@@ -21,9 +23,6 @@ public TypeSpecInputEnumTypeConverter(TypeSpecReferenceHandler referenceHandler)
         public override InputEnumType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
             => reader.ReadReferenceAndResolve<InputEnumType>(_referenceHandler.CurrentResolver) ?? CreateEnumType(ref reader, null, null, options, _referenceHandler.CurrentResolver);
 
-        public override void Write(Utf8JsonWriter writer, InputEnumType value, JsonSerializerOptions options)
-            => throw new NotSupportedException("Writing not supported");
-
         public static InputEnumType CreateEnumType(ref Utf8JsonReader reader, string? id, string? name, JsonSerializerOptions options, ReferenceResolver resolver)
         {
             var isFirstProperty = id == null && name == null;
@@ -94,5 +93,38 @@ public static InputEnumType CreateEnumType(ref Utf8JsonReader reader, string? id
             }
             return enumType;
         }
+
+        public override void Write(Utf8JsonWriter writer, InputEnumType value, JsonSerializerOptions options)
+            => writer.WriteObjectOrReference(value, options, _referenceHandler.CurrentResolver, WriteInputEnumTypeProperties);
+
+        private static void WriteInputEnumTypeProperties(Utf8JsonWriter writer, InputEnumType value, JsonSerializerOptions options)
+        {
+            // kind
+            writer.WriteString("kind", EnumKind);
+            // name
+            writer.WriteString("name", value.Name);
+            // crossLanguageDefinitionId
+            writer.WriteString("crossLanguageDefinitionId", value.CrossLanguageDefinitionId);
+            // valueType
+            writer.WriteObject("valueType", value.ValueType, options);
+            // values
+            writer.WriteArray("values", value.Values, options);
+            // access
+            writer.WriteStringIfPresent("access", value.Accessibility);
+            // namespace
+            writer.WriteString("namespace", string.Empty); // here the writing is a shimming layer from swagger to typespec. Swagger does not have the concept of namespace
+            // deprecation
+            writer.WriteStringIfPresent("deprecation", value.Deprecated);
+            // summary
+            writer.WriteStringIfPresent("summary", value.Summary);
+            // doc
+            writer.WriteStringIfPresent("doc", value.Doc);
+            // isFixed
+            writer.WriteBoolean("isFixed", !value.IsExtensible);
+            // usage
+            writer.WriteString("usage", value.Usage.ToString());
+            // decorators
+            writer.WriteArray("decorators", value.Decorators, options);
+        }
     }
 }