feat(cadl): support literal type model property (#3036)

archerzz · web-flow · commit c8280c0cacac · 2023-02-09T15:19:34.000+08:00
- change json cnoverter for `InputModelProperty` to set the `DefaultValue` property if the property type is a literal type - update `ObjectTypeProperty` so that `DefaultValue` is set if it's from literal type - change `ModelTypeProviderFields`: - exclude literal properties from constructor parameter list - literal properties are `internal readonly` - change `ModelTypeProvider`: - update the criteria on properties to be serialized, now literal type property will be serialized regardless it's read-only - skip deserialization for literal type properties - fix an issue in emitter that boolean literal type is not identified - in emitter, set literal parameters in operations to constant parameter types - minor refactoring - update test projects resolve #3035
diff --git a/src/AutoRest.CSharp/Common/Generation/Writers/JsonCodeWriterExtensions.cs b/src/AutoRest.CSharp/Common/Generation/Writers/JsonCodeWriterExtensions.cs
@@ -286,7 +286,7 @@ private static void ToSerializeCall(this CodeWriter writer, FormattableString wr
 
         private static void DeserializeIntoObjectProperties(this CodeWriter writer, IEnumerable<JsonPropertySerialization> propertySerializations, FormattableString itemVariable, Dictionary<JsonPropertySerialization, ObjectPropertyVariable> propertyVariables)
         {
-            foreach (JsonPropertySerialization property in propertySerializations)
+            foreach (JsonPropertySerialization property in propertySerializations.Where(p => !p.ShouldSkipDeserialization))
             {
                 writer.Append($"if({itemVariable}.NameEquals({property.SerializedName:L}u8))");
                 using (writer.Scope())
@@ -379,9 +379,9 @@ private static FormattableString GetOptionalFormattable(JsonPropertySerializatio
         }
 
         /// Collects a list of properties being read from all level of object hierarchy
-        private static void CollectProperties(Dictionary<JsonPropertySerialization, ObjectPropertyVariable> propertyVariables, IEnumerable<JsonPropertySerialization> jsonProperties)
+        private static void CollectPropertiesForDeserialization(Dictionary<JsonPropertySerialization, ObjectPropertyVariable> propertyVariables, IEnumerable<JsonPropertySerialization> jsonProperties)
         {
-            foreach (JsonPropertySerialization jsonProperty in jsonProperties)
+            foreach (JsonPropertySerialization jsonProperty in jsonProperties.Where(p => !p.ShouldSkipDeserialization))
             {
                 if (jsonProperty.ValueType != null)
                 {
@@ -399,7 +399,7 @@ private static void CollectProperties(Dictionary<JsonPropertySerialization, Obje
                 }
                 else if (jsonProperty.PropertySerializations != null)
                 {
-                    CollectProperties(propertyVariables, jsonProperty.PropertySerializations);
+                    CollectPropertiesForDeserialization(propertyVariables, jsonProperty.PropertySerializations);
                 }
             }
         }
@@ -492,7 +492,7 @@ public static void WriteObjectInitialization(this CodeWriter writer, JsonObjectS
             // collect all properties and initialize the dictionary
             var propertyVariables = new Dictionary<JsonPropertySerialization, ObjectPropertyVariable>();
 
-            CollectProperties(propertyVariables, serialization.Properties);
+            CollectPropertiesForDeserialization(propertyVariables, serialization.Properties);
 
             var additionalProperties = serialization.AdditionalProperties;
             if (additionalProperties != null)
diff --git a/src/AutoRest.CSharp/Common/Generation/Writers/ModelWriter.cs b/src/AutoRest.CSharp/Common/Generation/Writers/ModelWriter.cs
@@ -309,7 +309,7 @@ protected virtual void AddCtorAttribute(CodeWriter writer, ObjectType schema, Ob
         {
         }
 
-        public void WriteConstructor(CodeWriter writer, ObjectType schema)
+        private void WriteConstructor(CodeWriter writer, ObjectType schema)
         {
             foreach (var constructor in schema.Constructors)
             {
diff --git a/src/AutoRest.CSharp/Common/Input/CadlInputLiteralTypeConverter.cs b/src/AutoRest.CSharp/Common/Input/CadlInputLiteralTypeConverter.cs
@@ -85,28 +85,28 @@ public static object ReadLiteralValue(ref Utf8JsonReader reader, string property
             Object? value = null;
             switch (type)
             {
-                case InputPrimitiveType primitype:
-                    switch (primitype.Kind)
+                case InputPrimitiveType primitiveType:
+                    switch (primitiveType.Kind)
                     {
                         case InputTypeKind.String:
                             value = reader.GetString() ?? throw new JsonException();
                             break;
                         case InputTypeKind.Int32:
                             value = reader.GetInt32();
                             break;
-                        case InputTypeKind.Int64:
-                            value = reader.GetInt64();
+                        case InputTypeKind.Float64:
+                            value = reader.GetDouble();
                             break;
                         case InputTypeKind.Boolean:
                             value = reader.GetBoolean();
                             break;
                         default:
-                            throw new JsonException($"Not supported litreal type {primitype.Kind}.");
+                            throw new JsonException($"Not supported literal type {primitiveType.Kind}.");
 
                     }
                     break;
                 default:
-                    throw new JsonException($"Not supported litreal type {type.Name}.");
+                    throw new JsonException($"Not supported literal type {type.Name}.");
             }
             reader.Read();
             return value;
diff --git a/src/AutoRest.CSharp/Common/Input/CadlInputModelPropertyConverter.cs b/src/AutoRest.CSharp/Common/Input/CadlInputModelPropertyConverter.cs
@@ -55,13 +55,35 @@ private static InputModelProperty ReadInputModelProperty(ref Utf8JsonReader read
             description = BuilderHelpers.EscapeXmlDocDescription(description);
             propertyType = propertyType ?? throw new JsonException($"{nameof(InputModelProperty)} must have a property type.");
 
-            var property = new InputModelProperty(name, serializedName ?? name, description, propertyType, isRequired, isReadOnly, isDiscriminator);
+            var property = new InputModelProperty(name, serializedName ?? name, description, propertyType, isRequired, isReadOnly, isDiscriminator, GetDefaultValue(propertyType));
             if (id != null)
             {
                 resolver.AddReference(id, property);
             }
 
             return property;
         }
+
+        private static FormattableString? GetDefaultValue(InputType propertyType)
+        {
+            if (propertyType is not InputLiteralType literalType)
+            {
+                return null;
+            }
+
+            return literalType.LiteralValueType switch
+            {
+                InputPrimitiveType primitiveType => primitiveType.Kind switch
+                {
+                    InputTypeKind.Boolean => $"{literalType.Value.ToString()!.ToLower()}",
+                    InputTypeKind.Float32 or InputTypeKind.Float64 or InputTypeKind.Float128
+                        or InputTypeKind.Int32 or InputTypeKind.Int64 => $"{literalType.Value.ToString()}",
+                    InputTypeKind.String => $"\"{(literalType.Value).ToString()}\"",
+                    _ => throw new Exception($"Unsupported literal value type: {primitiveType}"),
+
+                },
+                _ => throw new Exception($"Unsupported literal value type: {literalType.LiteralValueType}"),
+            };
+        }
     }
 }
diff --git a/src/AutoRest.CSharp/Common/Output/Builders/SerializationBuilder.cs b/src/AutoRest.CSharp/Common/Output/Builders/SerializationBuilder.cs
@@ -267,6 +267,7 @@ private IEnumerable<JsonPropertySerialization> GetPropertySerializationsFromBag(
                     BuildSerialization(property.Schema, objectProperty.ValueType),
                     property.IsRequired,
                     property.IsReadOnly,
+                    false,
                     objectProperty.OptionalViaNullability);
             }
 
diff --git a/src/AutoRest.CSharp/Common/Output/Models/RestClientBuilder.cs b/src/AutoRest.CSharp/Common/Output/Models/RestClientBuilder.cs
@@ -351,7 +351,7 @@ private ReferenceOrConstant CreateReference(InputParameter operationParameter, P
                 return (ReferenceOrConstant)_parameters[operationParameter.Name];
             }
 
-            if (operationParameter.Kind == InputOperationParameterKind.Constant && parameter.DefaultValue != null)
+            if (operationParameter is { Kind:InputOperationParameterKind.Constant } && parameter.DefaultValue is not null)
             {
                 return (ReferenceOrConstant)parameter.DefaultValue;
             }
diff --git a/src/AutoRest.CSharp/Common/Output/Models/Serialization/Json/JsonAdditionalPropertiesSerialization.cs b/src/AutoRest.CSharp/Common/Output/Models/Serialization/Json/JsonAdditionalPropertiesSerialization.cs
@@ -12,7 +12,7 @@ internal class JsonAdditionalPropertiesSerialization : JsonPropertySerialization
         public CSharpType Type { get; }
 
         public JsonAdditionalPropertiesSerialization(ObjectTypeProperty property, JsonSerialization valueSerialization, CSharpType type)
-            : base(property.Declaration.Name.ToVariableName(), property.Declaration.Name, property.Declaration.Name, property.Declaration.Type, property.ValueType, valueSerialization, true, property.IsReadOnly, property.OptionalViaNullability)
+            : base(property.Declaration.Name.ToVariableName(), property.Declaration.Name, property.Declaration.Name, property.Declaration.Type, property.ValueType, valueSerialization, true, property.IsReadOnly, false, property.OptionalViaNullability)
         {
             Type = type;
         }
diff --git a/src/AutoRest.CSharp/Common/Output/Models/Serialization/Json/JsonPropertySerialization.cs b/src/AutoRest.CSharp/Common/Output/Models/Serialization/Json/JsonPropertySerialization.cs
@@ -8,8 +8,8 @@ namespace AutoRest.CSharp.Output.Models.Serialization.Json
 {
     internal class JsonPropertySerialization : PropertySerialization
     {
-        public JsonPropertySerialization(string parameterName, string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, JsonSerialization valueSerialization, bool isRequired, bool shouldSkipSerialization, bool optionalViaNullability)
-            : base(propertyName, serializedName, propertyType, valueType, isRequired, shouldSkipSerialization)
+        public JsonPropertySerialization(string parameterName, string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, JsonSerialization valueSerialization, bool isRequired, bool shouldSkipSerialization, bool shouldSkipDeserialization, bool optionalViaNullability)
+            : base(propertyName, serializedName, propertyType, valueType, isRequired, shouldSkipSerialization, shouldSkipDeserialization)
         {
             ParameterName = parameterName;
             OptionalViaNullability = optionalViaNullability;
diff --git a/src/AutoRest.CSharp/Common/Output/Models/Serialization/PropertySerialization.cs b/src/AutoRest.CSharp/Common/Output/Models/Serialization/PropertySerialization.cs
@@ -13,15 +13,22 @@ internal abstract class PropertySerialization
         public CSharpType? ValueType { get; }
         public bool IsRequired { get; }
         public bool ShouldSkipSerialization { get; }
+        public bool ShouldSkipDeserialization { get; }
 
-        protected PropertySerialization(string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, bool isRequired, bool shouldSkipSerialization)
+        protected PropertySerialization(string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, bool isRequired, bool shouldSkipSerialization) :
+            this(propertyName, serializedName, propertyType, valueType, isRequired, shouldSkipSerialization, false)
+        {
+        }
+
+        protected PropertySerialization(string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, bool isRequired, bool shouldSkipSerialization, bool shouldSkipDeserialization)
         {
             PropertyName = propertyName;
             SerializedName = serializedName;
             PropertyType = propertyType;
             ValueType = valueType;
             IsRequired = isRequired;
             ShouldSkipSerialization = shouldSkipSerialization;
+            ShouldSkipDeserialization = shouldSkipDeserialization;
         }
     }
 }
diff --git a/src/AutoRest.CSharp/Common/Output/Models/Types/ModelTypeProvider.cs b/src/AutoRest.CSharp/Common/Output/Models/Types/ModelTypeProvider.cs
@@ -147,6 +147,7 @@ private IEnumerable<JsonPropertySerialization> CreatePropertySerializations()
                         valueSerialization,
                         property.IsRequired,
                         shouldSkipSerialization,
+                        ShouldSkipDeserialization(property),
                         optionalViaNullability));
                 }
             }
@@ -160,6 +161,11 @@ private bool ShouldSkipSerialization(ObjectTypeProperty property)
                 return false;
             }
 
+            if (property.InputModelProperty.Type is InputLiteralType)
+            {
+                return false;
+            }
+
             if (property.InputModelProperty!.IsReadOnly)
             {
                 return true;
@@ -173,6 +179,8 @@ private bool ShouldSkipSerialization(ObjectTypeProperty property)
             return property.IsReadOnly && _inputModel.Usage is not InputModelTypeUsage.Input;
         }
 
+        private bool ShouldSkipDeserialization(ObjectTypeProperty property) => property.InputModelProperty?.Type is InputLiteralType;
+
         private ConstructorSignature? CreateSerializationConstructorSignature(string name, IReadOnlyList<Parameter> publicParameters, IReadOnlyList<Parameter> serializationParameters)
         {
             if (!serializationParameters.Any(p => TypeFactory.IsList(p.Type)) && publicParameters.SequenceEqual(serializationParameters))
diff --git a/src/AutoRest.CSharp/Common/Output/Models/Types/ModelTypeProviderFields.cs b/src/AutoRest.CSharp/Common/Output/Models/Types/ModelTypeProviderFields.cs
@@ -64,6 +64,10 @@ public ModelTypeProviderFields(InputModelType inputModel, TypeFactory typeFactor
                 fields.Add(field);
                 fieldsToInputs[field] = inputModelProperty;
 
+                if (inputModelProperty.Type is InputLiteralType)
+                {
+                    continue; // literal property does not show up in the constructor parameter list
+                }
                 var parameter = Parameter.FromModelProperty(inputModelProperty, existingMember is IFieldSymbol ? inputModelProperty.Name.ToVariableName() : field.Name.FirstCharToLowerCase(), field.Type);
                 parametersToFields[parameter.Name] = field;
                 serializationParameters.Add(parameter);
@@ -95,9 +99,10 @@ private static FieldDeclaration CreateField(string fieldName, CSharpType fieldTy
                 inputModelProperty.Type is CodeModelType type && (type.Schema is ArraySchema or DictionarySchema);
             var propertyIsRequiredInNonRoundTripModel = inputModel.Usage is InputModelTypeUsage.Input or InputModelTypeUsage.Output && inputModelProperty.IsRequired;
             var propertyIsOptionalInOutputModel = inputModel.Usage is InputModelTypeUsage.Output && !inputModelProperty.IsRequired;
-            var propertyIsReadOnly = inputModelProperty.IsReadOnly || propertyIsCollection || propertyIsRequiredInNonRoundTripModel || propertyIsOptionalInOutputModel;
+            var propertyIsLiteralType = inputModelProperty.Type is InputLiteralType;
+            var propertyIsReadOnly = inputModelProperty.IsReadOnly || propertyIsLiteralType || propertyIsCollection || propertyIsRequiredInNonRoundTripModel || propertyIsOptionalInOutputModel;
 
-            var fieldModifiers = propertyIsReadOnly ? Public | ReadOnly : Public;
+            var fieldModifiers = propertyIsReadOnly ? (propertyIsLiteralType ? Internal : Public ) | ReadOnly : Public;
 
             CodeWriterDeclaration declaration = new CodeWriterDeclaration(fieldName);
             declaration.SetActualName(fieldName);
diff --git a/src/AutoRest.CSharp/Common/Output/Models/Types/ObjectTypeProperty.cs b/src/AutoRest.CSharp/Common/Output/Models/Types/ObjectTypeProperty.cs
@@ -20,7 +20,8 @@ public ObjectTypeProperty(FieldDeclaration field, InputModelProperty inputModelP
             : this(new MemberDeclarationOptions(field.Accessibility, field.Name, field.Type), field.Description?.ToString() ?? String.Empty, field.Modifiers.HasFlag(FieldModifiers.ReadOnly), null, field.IsRequired, inputModelProperty: inputModelProperty)
         {
             // now the default value will be set only when the model is generated from property bag
-            if (enclosingType is ModelTypeProvider model && model.IsPropertyBag)
+            if ((enclosingType is ModelTypeProvider model && model.IsPropertyBag) ||
+                (inputModelProperty.Type is InputLiteralType)) // or the property is a literal type
             {
                 DefaultValue = field.DefaultValue;
             }
diff --git a/src/AutoRest.CSharp/LowLevel/Output/OperationMethodChainBuilder.cs b/src/AutoRest.CSharp/LowLevel/Output/OperationMethodChainBuilder.cs
@@ -436,9 +436,9 @@ private void AddReference(string nameInRequest, InputParameter? operationParamet
             _requestParts.Add(new RequestPartSource(nameInRequest, operationParameter, reference, serializationFormat));
         }
 
-        private ReferenceOrConstant CreateReference(InputParameter? operationParameter, Parameter parameter)
+        private ReferenceOrConstant CreateReference(InputParameter operationParameter, Parameter parameter)
         {
-            if (operationParameter?.Kind == InputOperationParameterKind.Client)
+            if (operationParameter.Kind == InputOperationParameterKind.Client)
             {
                 var field = operationParameter.IsEndpoint ? _fields.EndpointField : _fields.GetFieldByParameter(parameter);
                 if (field == null)
@@ -449,7 +449,7 @@ private ReferenceOrConstant CreateReference(InputParameter? operationParameter,
                 return new Reference(field.Name, field.Type);
             }
 
-            if (operationParameter?.Kind == InputOperationParameterKind.Constant && parameter.DefaultValue != null)
+            if (operationParameter.Kind is InputOperationParameterKind.Constant && parameter.DefaultValue is not null)
             {
                 return (ReferenceOrConstant)parameter.DefaultValue;
             }
diff --git a/src/CADL.Extension/Emitter.Csharp/src/emitter.ts b/src/CADL.Extension/Emitter.Csharp/src/emitter.ts
@@ -846,13 +846,14 @@ function loadOperation(
         const isContentType: boolean =
             requestLocation === RequestLocation.Header &&
             name.toLowerCase() === "content-type";
-        const kind: InputOperationParameterKind = isContentType
-            ? InputOperationParameterKind.Constant
-            : isApiVer
-            ? defaultValue
+        const kind: InputOperationParameterKind =
+            isContentType || inputType.Name === "Literal"
                 ? InputOperationParameterKind.Constant
-                : InputOperationParameterKind.Client
-            : InputOperationParameterKind.Method;
+                : isApiVer
+                ? defaultValue
+                    ? InputOperationParameterKind.Constant
+                    : InputOperationParameterKind.Client
+                : InputOperationParameterKind.Method;
         return {
             Name: param.name,
             NameInRequest: name,
diff --git a/src/CADL.Extension/Emitter.Csharp/src/lib/model.ts b/src/CADL.Extension/Emitter.Csharp/src/lib/model.ts
@@ -70,7 +70,13 @@ export function mapCadlTypeToCSharpInputTypeKind(
         case "Enum":
             return InputTypeKind.Enum;
         case "Number":
-            return InputTypeKind.Int32;
+            let nubmerValue = cadlType.value;
+            if (nubmerValue % 1 === 0) {
+                return InputTypeKind.Int32;
+            }
+            return InputTypeKind.Float64;
+        case "Boolean":
+            return InputTypeKind.Boolean;
         case "String":
             if (format === "date") return InputTypeKind.DateTime;
             if (format === "uri") return InputTypeKind.Uri;
diff --git a/test/CadlRanchMockApis/src/FirstTest-Cadl.ts b/test/CadlRanchMockApis/src/FirstTest-Cadl.ts
@@ -0,0 +1,41 @@
+import { passOnSuccess, ScenarioMockApi, mockapi, json } from "@azure-tools/cadl-ranch-api";
+
+/**
+ * Test mock server for `FirstTest-cadl` test project.
+ */
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.FirstTestCadl_CreateLiteral = passOnSuccess([
+  mockapi.post("/literal", (req) => {
+    req.expect.bodyEquals({
+        name: "test",
+        requiredUnion: "test",
+        requiredBadDescription: "abc",
+        requiredLiteralString: "accept",
+        requiredLiteralInt: 123,
+        requiredLiteralDouble: 1.23,
+        requiredLiteralBool: false,
+        optionalLiteralString: "reject",
+        optionalLiteralInt: 456,
+        optionalLiteralDouble: 4.56,
+        optionalLiteralBool: true,
+    });
+    return {
+      status: 200,
+      body: json({
+        name: "literal",
+        requiredUnion: "union",
+        requiredBadDescription: "def",
+        // below are useless
+        requiredLiteralString: "reject",
+        requiredLiteralInt: 12345,
+        requiredLiteralDouble: 123.45,
+        requiredLiteralBool: true,
+        optionalLiteralString: "accept",
+        optionalLiteralInt: 12345,
+        optionalLiteralDouble: 123.45,
+        optionalLiteralBool: false,
+      })
+    };
+  }),
+]);
diff --git a/test/CadlRanchProjects.Tests/LiteralValueTypeTests.cs b/test/CadlRanchProjects.Tests/LiteralValueTypeTests.cs
diff --git a/test/TestProjects/FirstTest-Cadl/Customization/CadlFirstTestClient.cs b/test/TestProjects/FirstTest-Cadl/Customization/CadlFirstTestClient.cs
diff --git a/test/TestProjects/FirstTest-Cadl/FirstTest-Cadl.cadl b/test/TestProjects/FirstTest-Cadl/FirstTest-Cadl.cadl
diff --git a/test/TestProjects/FirstTest-Cadl/Generated/CadlFirstTestClient.cs b/test/TestProjects/FirstTest-Cadl/Generated/CadlFirstTestClient.cs
diff --git a/test/TestProjects/FirstTest-Cadl/Generated/Docs/CadlFirstTestClient.xml b/test/TestProjects/FirstTest-Cadl/Generated/Docs/CadlFirstTestClient.xml
diff --git a/test/TestProjects/FirstTest-Cadl/Generated/Models/Thing.Serialization.cs b/test/TestProjects/FirstTest-Cadl/Generated/Models/Thing.Serialization.cs
diff --git a/test/TestProjects/FirstTest-Cadl/Generated/Models/Thing.cs b/test/TestProjects/FirstTest-Cadl/Generated/Models/Thing.cs
diff --git a/test/TestProjects/FirstTest-Cadl/Generated/cadl.json b/test/TestProjects/FirstTest-Cadl/Generated/cadl.json

Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,7 @@ private static void ToSerializeCall(this CodeWriter writer, FormattableString wr`
`286`	`286`
`287`	`287`	`private static void DeserializeIntoObjectProperties(this CodeWriter writer, IEnumerable<JsonPropertySerialization> propertySerializations, FormattableString itemVariable, Dictionary<JsonPropertySerialization, ObjectPropertyVariable> propertyVariables)`
`288`	`288`	`{`
`289`		`- foreach (JsonPropertySerialization property in propertySerializations)`
	`289`	`+ foreach (JsonPropertySerialization property in propertySerializations.Where(p => !p.ShouldSkipDeserialization))`
`290`	`290`	`{`
`291`	`291`	`writer.Append($"if({itemVariable}.NameEquals({property.SerializedName:L}u8))");`
`292`	`292`	`using (writer.Scope())`
`@@ -379,9 +379,9 @@ private static FormattableString GetOptionalFormattable(JsonPropertySerializatio`
`379`	`379`	`}`
`380`	`380`
`381`	`381`	`/// Collects a list of properties being read from all level of object hierarchy`
`382`		`- private static void CollectProperties(Dictionary<JsonPropertySerialization, ObjectPropertyVariable> propertyVariables, IEnumerable<JsonPropertySerialization> jsonProperties)`
	`382`	`+ private static void CollectPropertiesForDeserialization(Dictionary<JsonPropertySerialization, ObjectPropertyVariable> propertyVariables, IEnumerable<JsonPropertySerialization> jsonProperties)`
`383`	`383`	`{`
`384`		`- foreach (JsonPropertySerialization jsonProperty in jsonProperties)`
	`384`	`+ foreach (JsonPropertySerialization jsonProperty in jsonProperties.Where(p => !p.ShouldSkipDeserialization))`
`385`	`385`	`{`
`386`	`386`	`if (jsonProperty.ValueType != null)`
`387`	`387`	`{`
`@@ -399,7 +399,7 @@ private static void CollectProperties(Dictionary<JsonPropertySerialization, Obje`
`399`	`399`	`}`
`400`	`400`	`else if (jsonProperty.PropertySerializations != null)`
`401`	`401`	`{`
`402`		`- CollectProperties(propertyVariables, jsonProperty.PropertySerializations);`
	`402`	`+ CollectPropertiesForDeserialization(propertyVariables, jsonProperty.PropertySerializations);`
`403`	`403`	`}`
`404`	`404`	`}`
`405`	`405`	`}`
`@@ -492,7 +492,7 @@ public static void WriteObjectInitialization(this CodeWriter writer, JsonObjectS`
`492`	`492`	`// collect all properties and initialize the dictionary`
`493`	`493`	`var propertyVariables = new Dictionary<JsonPropertySerialization, ObjectPropertyVariable>();`
`494`	`494`
`495`		`- CollectProperties(propertyVariables, serialization.Properties);`
	`495`	`+ CollectPropertiesForDeserialization(propertyVariables, serialization.Properties);`
`496`	`496`
`497`	`497`	`var additionalProperties = serialization.AdditionalProperties;`
`498`	`498`	`if (additionalProperties != null)`
Original file line number	Diff line number	Diff line change
`@@ -309,7 +309,7 @@ protected virtual void AddCtorAttribute(CodeWriter writer, ObjectType schema, Ob`
`309`	`309`	`{`
`310`	`310`	`}`
`311`	`311`
`312`		`- public void WriteConstructor(CodeWriter writer, ObjectType schema)`
	`312`	`+ private void WriteConstructor(CodeWriter writer, ObjectType schema)`
`313`	`313`	`{`
`314`	`314`	`foreach (var constructor in schema.Constructors)`
`315`	`315`	`{`
Original file line number	Diff line number	Diff line change
`@@ -267,6 +267,7 @@ private IEnumerable<JsonPropertySerialization> GetPropertySerializationsFromBag(`
`267`	`267`	`BuildSerialization(property.Schema, objectProperty.ValueType),`
`268`	`268`	`property.IsRequired,`
`269`	`269`	`property.IsReadOnly,`
	`270`	`+ false,`
`270`	`271`	`objectProperty.OptionalViaNullability);`
`271`	`272`	`}`
`272`	`273`
Original file line number	Diff line number	Diff line change
`@@ -351,7 +351,7 @@ private ReferenceOrConstant CreateReference(InputParameter operationParameter, P`
`351`	`351`	`return (ReferenceOrConstant)_parameters[operationParameter.Name];`
`352`	`352`	`}`
`353`	`353`
`354`		`- if (operationParameter.Kind == InputOperationParameterKind.Constant && parameter.DefaultValue != null)`
	`354`	`+ if (operationParameter is { Kind:InputOperationParameterKind.Constant } && parameter.DefaultValue is not null)`
`355`	`355`	`{`
`356`	`356`	`return (ReferenceOrConstant)parameter.DefaultValue;`
`357`	`357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal class JsonAdditionalPropertiesSerialization : JsonPropertySerialization`
`12`	`12`	`public CSharpType Type { get; }`
`13`	`13`
`14`	`14`	`public JsonAdditionalPropertiesSerialization(ObjectTypeProperty property, JsonSerialization valueSerialization, CSharpType type)`
`15`		`- : base(property.Declaration.Name.ToVariableName(), property.Declaration.Name, property.Declaration.Name, property.Declaration.Type, property.ValueType, valueSerialization, true, property.IsReadOnly, property.OptionalViaNullability)`
	`15`	`+ : base(property.Declaration.Name.ToVariableName(), property.Declaration.Name, property.Declaration.Name, property.Declaration.Type, property.ValueType, valueSerialization, true, property.IsReadOnly, false, property.OptionalViaNullability)`
`16`	`16`	`{`
`17`	`17`	`Type = type;`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ namespace AutoRest.CSharp.Output.Models.Serialization.Json`
`8`	`8`	`{`
`9`	`9`	`internal class JsonPropertySerialization : PropertySerialization`
`10`	`10`	`{`
`11`		`- public JsonPropertySerialization(string parameterName, string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, JsonSerialization valueSerialization, bool isRequired, bool shouldSkipSerialization, bool optionalViaNullability)`
`12`		`- : base(propertyName, serializedName, propertyType, valueType, isRequired, shouldSkipSerialization)`
	`11`	`+ public JsonPropertySerialization(string parameterName, string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, JsonSerialization valueSerialization, bool isRequired, bool shouldSkipSerialization, bool shouldSkipDeserialization, bool optionalViaNullability)`
	`12`	`+ : base(propertyName, serializedName, propertyType, valueType, isRequired, shouldSkipSerialization, shouldSkipDeserialization)`
`13`	`13`	`{`
`14`	`14`	`ParameterName = parameterName;`
`15`	`15`	`OptionalViaNullability = optionalViaNullability;`
Original file line number	Diff line number	Diff line change
`@@ -13,15 +13,22 @@ internal abstract class PropertySerialization`
`13`	`13`	`public CSharpType? ValueType { get; }`
`14`	`14`	`public bool IsRequired { get; }`
`15`	`15`	`public bool ShouldSkipSerialization { get; }`
	`16`	`+ public bool ShouldSkipDeserialization { get; }`
`16`	`17`
`17`		`- protected PropertySerialization(string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, bool isRequired, bool shouldSkipSerialization)`
	`18`	`+ protected PropertySerialization(string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, bool isRequired, bool shouldSkipSerialization) :`
	`19`	`+ this(propertyName, serializedName, propertyType, valueType, isRequired, shouldSkipSerialization, false)`
	`20`	`+ {`
	`21`	`+ }`
	`22`	`+`
	`23`	`+ protected PropertySerialization(string propertyName, string serializedName, CSharpType propertyType, CSharpType? valueType, bool isRequired, bool shouldSkipSerialization, bool shouldSkipDeserialization)`
`18`	`24`	`{`
`19`	`25`	`PropertyName = propertyName;`
`20`	`26`	`SerializedName = serializedName;`
`21`	`27`	`PropertyType = propertyType;`
`22`	`28`	`ValueType = valueType;`
`23`	`29`	`IsRequired = isRequired;`
`24`	`30`	`ShouldSkipSerialization = shouldSkipSerialization;`
	`31`	`+ ShouldSkipDeserialization = shouldSkipDeserialization;`
`25`	`32`	`}`
`26`	`33`	`}`
`27`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -147,6 +147,7 @@ private IEnumerable<JsonPropertySerialization> CreatePropertySerializations()`
`147`	`147`	`valueSerialization,`
`148`	`148`	`property.IsRequired,`
`149`	`149`	`shouldSkipSerialization,`
	`150`	`+ ShouldSkipDeserialization(property),`
`150`	`151`	`optionalViaNullability));`
`151`	`152`	`}`
`152`	`153`	`}`
`@@ -160,6 +161,11 @@ private bool ShouldSkipSerialization(ObjectTypeProperty property)`
`160`	`161`	`return false;`
`161`	`162`	`}`
`162`	`163`
	`164`	`+ if (property.InputModelProperty.Type is InputLiteralType)`
	`165`	`+ {`
	`166`	`+ return false;`
	`167`	`+ }`
	`168`	`+`
`163`	`169`	`if (property.InputModelProperty!.IsReadOnly)`
`164`	`170`	`{`
`165`	`171`	`return true;`
`@@ -173,6 +179,8 @@ private bool ShouldSkipSerialization(ObjectTypeProperty property)`
`173`	`179`	`return property.IsReadOnly && _inputModel.Usage is not InputModelTypeUsage.Input;`
`174`	`180`	`}`
`175`	`181`
	`182`	`+ private bool ShouldSkipDeserialization(ObjectTypeProperty property) => property.InputModelProperty?.Type is InputLiteralType;`
	`183`	`+`
`176`	`184`	`private ConstructorSignature? CreateSerializationConstructorSignature(string name, IReadOnlyList<Parameter> publicParameters, IReadOnlyList<Parameter> serializationParameters)`
`177`	`185`	`{`
`178`	`186`	`if (!serializationParameters.Any(p => TypeFactory.IsList(p.Type)) && publicParameters.SequenceEqual(serializationParameters))`