Implement SystemObjectProvider and type replacement

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.Input/src/Microsoft.Generator.CSharp.Input.csproj

@@ -10,8 +10,4 @@
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)..\..\Microsoft.Generator.CSharp\src\Shared\StringExtensions.cs" LinkBase="Shared" />
-  </ItemGroup>
-
 </Project>

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Shared/StringExtensions.cs → packages/http-client-csharp/generator/Microsoft.Generator.CSharp.Input/src/Utilities/StringExtensions.cs

@@ -8,9 +8,9 @@
 using System.Text.RegularExpressions;
 using Microsoft.CodeAnalysis.CSharp;
 
-namespace Microsoft.Generator.CSharp
+namespace Microsoft.Generator.CSharp.Input
 {
-    internal static class StringExtensions
+    public static class StringExtensions
     {
         private static bool IsWordSeparator(char c) => !SyntaxFacts.IsIdentifierPartCharacter(c) || c == '_';
         private static readonly Regex HumanizedCamelCaseRegex = new Regex(@"([A-Z])", RegexOptions.Compiled);

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Expressions/FormattableStringExpression.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Generator.CSharp.Input;
 
 namespace Microsoft.Generator.CSharp.Expressions
 {

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/OutputLibrary.cs

@@ -48,7 +48,7 @@ private static TypeProvider[] BuildModels()
             foreach (var inputModel in input.Models)
             {
                 var outputModel = CodeModelPlugin.Instance.TypeFactory.CreateModel(inputModel);
-                if (outputModel != null)
+                if (outputModel != null && outputModel is not SystemObjectProvider)
                 {
                     models.Add(outputModel);
                     var unknownVariant = inputModel.DiscriminatedSubtypes.Values.FirstOrDefault(m => m.IsUnknownDiscriminatorModel);

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Providers/FieldProvider.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.Generator.CSharp.Expressions;
+using Microsoft.Generator.CSharp.Input;
 using Microsoft.Generator.CSharp.Primitives;
 using Microsoft.Generator.CSharp.Statements;
 

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Providers/ModelFactoryProvider.cs

@@ -69,7 +69,7 @@ protected override MethodProvider[] BuildMethods()
             var methods = new List<MethodProvider>(_models.Count());
             foreach (var model in _models)
             {
-                var modelProvider = CodeModelPlugin.Instance.TypeFactory.CreateModel(model);
+                var modelProvider = CodeModelPlugin.Instance.TypeFactory.CreateModel(model) as ModelProvider;
                 if (modelProvider is null || modelProvider.DeclarationModifiers.HasFlag(TypeSignatureModifiers.Internal))
                     continue;
 

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Providers/ModelProvider.cs

@@ -15,7 +15,7 @@
 
 namespace Microsoft.Generator.CSharp.Providers
 {
-    public sealed class ModelProvider : TypeProvider
+    public class ModelProvider : TypeProvider
     {
         private const string AdditionalBinaryDataPropsFieldDescription = "Keeps track of any properties unknown to the library.";
         private readonly InputModelType _inputModel;
@@ -57,7 +57,7 @@ private IReadOnlyList<ModelProvider> BuildDerivedModels()
             // add discriminated subtypes
             foreach (var subtype in _inputModel.DiscriminatedSubtypes)
             {
-                var model = CodeModelPlugin.Instance.TypeFactory.CreateModel(subtype.Value);
+                var model = CodeModelPlugin.Instance.TypeFactory.CreateModel(subtype.Value) as ModelProvider;
                 if (model != null)
                 {
                     derivedModels.Add(model);
@@ -67,7 +67,7 @@ private IReadOnlyList<ModelProvider> BuildDerivedModels()
             // add derived models
             foreach (var derivedModel in _inputModel.DerivedModels)
             {
-                var model = CodeModelPlugin.Instance.TypeFactory.CreateModel(derivedModel);
+                var model = CodeModelPlugin.Instance.TypeFactory.CreateModel(derivedModel) as ModelProvider;
                 if (model != null)
                 {
                     derivedModels.Add(model);
@@ -76,7 +76,23 @@ private IReadOnlyList<ModelProvider> BuildDerivedModels()
 
             return [.. derivedModels];
         }
-        internal override TypeProvider? BaseTypeProvider => BaseModelProvider;
+
+        internal override TypeProvider? BaseTypeProvider
+        {
+            get
+            {
+                if (_baseTypeProvider?.Value is ModelProvider modelProvider)
+                {
+                    return modelProvider;
+                }
+                else if (_baseTypeProvider?.Value is SystemObjectProvider systemObjectProvider)
+                {
+                    return systemObjectProvider;
+                }
+
+                return null;
+            }
+        }
 
         public ModelProvider? BaseModelProvider
             => _baseModelProvider ??= (_baseTypeProvider?.Value is ModelProvider baseModelProvider ? baseModelProvider : null);
@@ -90,7 +106,7 @@ public ModelProvider? BaseModelProvider
 
         protected override CSharpType? GetBaseType()
         {
-            return BaseModelProvider?.Type;
+            return BaseTypeProvider?.Type;
         }
 
         protected override TypeProvider[] BuildSerializationProviders()

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Providers/PropertyProvider.cs

@@ -54,6 +54,13 @@ protected PropertyProvider()
 
         internal static bool TryCreate(InputModelProperty inputProperty, TypeProvider enclosingType, [NotNullWhen(true)] out PropertyProvider? property)
         {
+            var inputPropertyType = inputProperty.Type as InputModelType;
+            if (inputPropertyType != null && CodeModelPlugin.Instance.TypeFactory.TryGetPropertyTypeReplacement(inputPropertyType, out var replacement))
+            {
+                property = new PropertyProvider(inputProperty, replacement.Type, enclosingType);
+                return true;
+            }
+
             var type = CodeModelPlugin.Instance.TypeFactory.CreateCSharpType(inputProperty.Type);
             if (type == null)
             {

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Providers/SystemObjectProvider.cs

@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using Microsoft.Generator.CSharp.Input;
+using Microsoft.Generator.CSharp.Primitives;
+using Microsoft.Generator.CSharp.Statements;
+
+namespace Microsoft.Generator.CSharp.Providers
+{
+    public class SystemObjectProvider : TypeProvider
+    {
+        private readonly Type _type;
+        private const string InitializationCtorAttributeName = "InitializationConstructorAttribute";
+        private const string SerializationCtorAttributeName = "SerializationConstructorAttribute";
+
+        public SystemObjectProvider(Type type) : base()
+        {
+            _type = type;
+        }
+
+        protected override string BuildName() => _type.Name;
+
+        protected override string BuildRelativeFilePath() => throw new InvalidOperationException("This type should not be writing in generation");
+
+        protected override ConstructorProvider[] BuildConstructors()
+        {
+            var initializationCtor = GetCtor(_type, InitializationCtorAttributeName);
+            var serializationCtor = GetCtor(_type, SerializationCtorAttributeName);
+
+            return [BuildConstructor(initializationCtor), BuildConstructor(serializationCtor)];
+        }
+
+        private ConstructorProvider BuildConstructor(ConstructorInfo ctor)
+        {
+            var parameters = new List<ParameterProvider>();
+            foreach (var param in ctor.GetParameters())
+            {
+                var parameter = new ParameterProvider(param.Name!, $"The {param.Name}", param.ParameterType);
+                parameters.Add(parameter);
+            }
+
+            // we should only add initializers when there is a corresponding parameter
+            List<ParameterProvider> arguments = new List<ParameterProvider>();
+            foreach (var property in Properties)
+            {
+                var parameter = parameters.FirstOrDefault(p => p.Name == property.Name.ToVariableName());
+                if (parameter is not null)
+                {
+                    arguments.Add(parameter);
+                }
+            }
+
+            var modifiers = ctor.IsFamily ? MethodSignatureModifiers.Protected : MethodSignatureModifiers.Public;
+            var signature = new ConstructorSignature(Type, null, modifiers, parameters, Initializer: new ConstructorInitializer(false, arguments));
+
+            return new ConstructorProvider(signature, MethodBodyStatement.Empty, this);
+        }
+
+        private static ConstructorInfo GetCtor(Type type, string attributeType)
+        {
+            if (TryGetCtor(type, attributeType, out var ctor))
+                return ctor;
+
+            throw new InvalidOperationException($"{attributeType} ctor was not found for {type.Name}");
+        }
+
+        private static bool TryGetCtor(Type type, string attributeType, [MaybeNullWhen(false)] out ConstructorInfo result)
+        {
+            foreach (var ctor in type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.CreateInstance))
+            {
+                if (ctor.GetCustomAttributes().FirstOrDefault(a => a.GetType().Name == attributeType) != null)
+                {
+                    result = ctor;
+                    return true;
+                }
+            }
+
+            result = null;
+            return false;
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Providers/TypeProvider.cs

@@ -123,11 +123,7 @@ public string? Deprecated
 
         private TypeSignatureModifiers? _declarationModifiers;
 
-        public TypeSignatureModifiers DeclarationModifiers
-        {
-            get => _declarationModifiers ??= GetDeclarationModifiersInternal();
-            private set => _declarationModifiers = value;
-        }
+        public TypeSignatureModifiers DeclarationModifiers => _declarationModifiers ??= GetDeclarationModifiersInternal();
 
         protected virtual TypeSignatureModifiers GetDeclarationModifiers() => TypeSignatureModifiers.None;
 
@@ -332,7 +328,9 @@ public void Update(
             IEnumerable<FieldProvider>? fields = null,
             IEnumerable<TypeProvider>? serializations = null,
             IEnumerable<TypeProvider>? nestedTypes = null,
-            XmlDocProvider? xmlDocs = null)
+            XmlDocProvider? xmlDocs = null,
+            TypeSignatureModifiers? modifiers = null,
+            string? relativeFilePath = null)
         {
             if (methods != null)
             {
@@ -362,6 +360,14 @@ public void Update(
             {
                 XmlDocs = xmlDocs;
             }
+            if (modifiers != null)
+            {
+                _declarationModifiers = modifiers;
+            }
+            if (relativeFilePath != null)
+            {
+                _relativeFilePath = relativeFilePath;
+            }
         }
         public IReadOnlyList<EnumTypeMember> EnumValues => _enumValues ??= BuildEnumValues();
 

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/TypeFactory.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using Microsoft.Generator.CSharp.Input;
 using Microsoft.Generator.CSharp.Primitives;
@@ -43,6 +44,20 @@ protected internal TypeFactory()
 
         public CSharpType? CreateCSharpType(InputType inputType)
         {
+            var inputModelType = inputType as InputModelType;
+
+            if (inputModelType is not null)
+            {
+                if (TryGetTypeReplacement(inputModelType, out var typeReplacement))
+                {
+                    return typeReplacement.Type;
+                }
+                else if (TryGetPropertyTypeReplacement(inputModelType, out var propertyReplacement))
+                {
+                    return propertyReplacement.Type;
+                }
+            }
+
             if (TypeCache.TryGetValue(inputType, out var type))
             {
                 return type;
@@ -141,8 +156,13 @@ protected internal TypeFactory()
         /// </summary>
         /// <param name="model">The <see cref="InputModelType"/> to convert.</param>
         /// <returns>An instance of <see cref="TypeProvider"/>.</returns>
-        public ModelProvider? CreateModel(InputModelType model)
+        public TypeProvider? CreateModel(InputModelType model)
         {
+            if (TryGetTypeReplacement(model, out var replacement))
+            {
+                return replacement;
+            }
+
             if (CSharpToModelProvider.TryGetValue(model, out var modelProvider))
                 return modelProvider;
 
@@ -151,6 +171,18 @@ protected internal TypeFactory()
             return modelProvider;
         }
 
+        public virtual bool TryGetTypeReplacement(InputModelType inputModelType, [NotNullWhen(true)] out SystemObjectProvider? replacement)
+        {
+            replacement = null;
+            return false;
+        }
+
+        public virtual bool TryGetPropertyTypeReplacement(InputModelType inputModelType, [NotNullWhen(true)] out SystemObjectProvider? replacement)
+        {
+            replacement = null;
+            return false;
+        }
+
         private ModelProvider? CreateModelCore(InputModelType model)
         {
             ModelProvider? type = new ModelProvider(model);

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Utilities/FormattableStringHelpers.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
+using Microsoft.Generator.CSharp.Input;
 using Microsoft.Generator.CSharp.Providers;
 
 namespace Microsoft.Generator.CSharp

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/src/Writers/CodeWriter.cs

@@ -8,6 +8,7 @@
 using System.Text;
 using Microsoft.CodeAnalysis;
 using Microsoft.Generator.CSharp.Expressions;
+using Microsoft.Generator.CSharp.Input;
 using Microsoft.Generator.CSharp.Primitives;
 using Microsoft.Generator.CSharp.Providers;
 using Microsoft.Generator.CSharp.Snippets;

packages/http-client-csharp/generator/Microsoft.Generator.CSharp/test/Utilities/StringExtensionsTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Generator.CSharp.Input;
 using NUnit.Framework;
 
 namespace Microsoft.Generator.CSharp.Tests.Utilities