remove another constrait on model factory

src/AutoRest.CSharp/Common/Output/Models/Types/ModelFactoryTypeProvider.cs

@@ -20,32 +20,47 @@
 using AutoRest.CSharp.Utilities;
 using Azure.Core.Expressions.DataFactory;
 using Azure.ResourceManager.Models;
+using Microsoft.CodeAnalysis;
 using static AutoRest.CSharp.Common.Output.Models.Snippets;
 
 namespace AutoRest.CSharp.Output.Models.Types
 {
     internal sealed class ModelFactoryTypeProvider : TypeProvider
     {
+        private static readonly IReadOnlySet<MethodInfo> ExistingModelFactoryMethods;
+
+        static ModelFactoryTypeProvider()
+        {
+            var methods = new HashSet<MethodInfo>();
+            foreach (var method in typeof(ResourceManagerModelFactory).GetMethods(BindingFlags.Static | BindingFlags.Public))
+            {
+                methods.Add(method);
+            }
+            foreach (var method in typeof(DataFactoryModelFactory).GetMethods(BindingFlags.Static | BindingFlags.Public))
+            {
+                methods.Add(method);
+            }
+
+            ExistingModelFactoryMethods = methods;
+        }
+
         protected override string DefaultName { get; }
         protected override string DefaultAccessibility { get; }
 
         private IEnumerable<Method>? _methods;
-        public IEnumerable<Method> Methods => _methods ??= Models.Select(CreateMethod);
+        public IEnumerable<Method> Methods => _methods ??= _models.Select(CreateMethod);
 
-        public IEnumerable<SerializableObjectType> Models { get; }
+        private readonly IEnumerable<SerializableObjectType> _models;
 
         public FormattableString Description => $"Model factory for models.";
 
         internal string FullName => $"{Type.Namespace}.{Type.Name}";
 
         private ModelFactoryTypeProvider(IEnumerable<SerializableObjectType> objectTypes, string defaultClientName, string defaultNamespace, SourceInputModel? sourceInputModel) : base(defaultNamespace, sourceInputModel)
         {
-            Models = objectTypes;
-
+            _models = objectTypes;
             DefaultName = $"{defaultClientName}ModelFactory".ToCleanName();
             DefaultAccessibility = "public";
-            ExistingModelFactoryMethods = typeof(ResourceManagerModelFactory).GetMethods(BindingFlags.Static | BindingFlags.Public).ToHashSet();
-            ExistingModelFactoryMethods.UnionWith(typeof(DataFactoryModelFactory).GetMethods(BindingFlags.Static | BindingFlags.Public).ToHashSet());
         }
 
         public static ModelFactoryTypeProvider? TryCreate(IEnumerable<TypeProvider> models, SourceInputModel? sourceInputModel)
@@ -86,9 +101,7 @@ private static string GetDefaultNamespace()
             return Configuration.Namespace;
         }
 
-        public HashSet<MethodInfo> ExistingModelFactoryMethods { get; }
-
-        private ValueExpression BuildPropertyAssignmentExpression(Parameter parameter, ObjectTypeProperty property)
+        private static ValueExpression BuildPropertyAssignmentExpression(Parameter parameter, ObjectTypeProperty property)
         {
             ValueExpression p = parameter;
             var propertyStack = property.BuildHierarchyStack();
@@ -154,7 +167,7 @@ private ValueExpression BuildPropertyAssignmentExpression(Parameter parameter, O
             return result;
         }
 
-        private Method CreateMethod(SerializableObjectType model)
+        private static Method CreateMethod(SerializableObjectType model)
         {
             var ctor = model.SerializationConstructor;
             var ctorToCall = ctor;
@@ -173,13 +186,20 @@ private Method CreateMethod(SerializableObjectType model)
                 if (property == null)
                 {
                     // if the property is not found, in order not to introduce compilation errors, we need to add a `default` into the argument list
-                    methodArguments.Add(new PositionalParameterReference(ctorParameter.Name, Default));
+                    methodArguments.Add(new PositionalParameterReference(ctorParameter.Name, Default.CastTo(ctorParameter.Type)));
                     continue;
                 }
 
                 if (property.FlattenedProperty != null)
                     property = property.FlattenedProperty;
 
+                // for the parameter corresponding to non-public property, we just add default or null
+                if (property.Declaration.Accessibility != "public" && property != model.Discriminator?.Property)
+                {
+                    methodArguments.Add(new PositionalParameterReference(ctorParameter.Name, ctorParameter.Type.IsValueType ? Default.CastTo(ctorParameter.Type) : Null.CastTo(ctorParameter.Type)));
+                    continue;
+                }
+
                 var parameterName = property.Declaration.Name.ToVariableName();
                 var inputType = property.Declaration.Type;
                 Constant? overriddenDefaultValue = null;
@@ -263,12 +283,6 @@ private static bool RequiresModelFactory(SerializableObjectType model)
             }
 
             var properties = model.EnumerateHierarchy().SelectMany(obj => obj.Properties);
-            // we skip the models with internal properties when the internal property is neither a discriminator or safe flattened
-            if (properties.Any(p => p.Declaration.Accessibility != "public" && (model.Discriminator?.Property != p && p.FlattenedProperty == null)))
-            {
-                return false;
-            }
-
             if (!properties.Any(p => p.IsReadOnly && !TypeFactory.IsReadWriteDictionary(p.ValueType) && !TypeFactory.IsReadWriteList(p.ValueType)))
             {
                 return false;

test/AutoRest.TestServer.Tests/TypeSchemaMappingTest.cs

@@ -218,7 +218,6 @@ public void GuidPropertyDeserializedCorrectly()
         [Test]
         public void UriPropertyDeserializedCorrectly()
         {
-            DateTime date = DateTime.UtcNow;
             ModelWithUriProperty model = ModelWithUriProperty.DeserializeModelWithUriProperty(JsonDocument.Parse("{\"Uri\":\"http://localhost\"}").RootElement);
 
             Assert.AreEqual("http://localhost/", model.Uri.AbsoluteUri);
@@ -263,7 +262,7 @@ public void ModelFactoryIsInternal()
         [Test]
         public void ModelFactoryPublicMethods()
         {
-            TypeAsserts.TypeOnlyDeclaresThesePublicMethods(typeof(MainModelFactory), nameof(ModelWithGuidProperty), nameof(ModelWithAbstractModel));
+            TypeAsserts.TypeOnlyDeclaresThesePublicMethods(typeof(MainModelFactory), nameof(ModelWithGuidProperty), nameof(ModelWithAbstractModel), nameof(PublicModelWithInternalProperty));
         }
 
         [Test]