Consolidate AdditionalProperties with raw data field (Phase 1)

src/AutoRest.CSharp/Common/Generation/Types/TypeFactory.cs

@@ -4,16 +4,13 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Net;
 using System.Text;
 using AutoRest.CSharp.Common.Input;
-using AutoRest.CSharp.Common.Output.Models.Types;
 using AutoRest.CSharp.Input;
-using AutoRest.CSharp.Output.Models.Shared;
 using AutoRest.CSharp.Output.Models.Types;
 using Azure;
 using Azure.Core;
@@ -25,12 +22,13 @@ namespace AutoRest.CSharp.Generation.Types
     internal class TypeFactory
     {
         private readonly OutputLibrary _library;
-        private readonly Type _unknownType;
+
+        public Type UnknownType { get; }
 
         public TypeFactory(OutputLibrary library, Type unknownType)
         {
             _library = library;
-            _unknownType = unknownType;
+            UnknownType = unknownType;
         }
 
         private Type AzureResponseErrorType => typeof(ResponseError);
@@ -93,7 +91,7 @@ public TypeFactory(OutputLibrary library, Type unknownType)
                 _ => new CSharpType(typeof(object), inputType.IsNullable),
             },
             InputGenericType genericType => new CSharpType(genericType.Type, CreateType(genericType.ArgumentType)).WithNullable(inputType.IsNullable),
-            InputIntrinsicType { Kind: InputIntrinsicTypeKind.Unknown } => _unknownType,
+            InputIntrinsicType { Kind: InputIntrinsicTypeKind.Unknown } => UnknownType,
             CodeModelType cmt => CreateType(cmt.Schema, cmt.IsNullable),
             _ => throw new Exception("Unknown type")
         };
@@ -141,8 +139,8 @@ private Type GetListType(Schema schema)
             AllSchemaTypes.Unixtime => typeof(DateTimeOffset),
             AllSchemaTypes.Uri => typeof(Uri),
             AllSchemaTypes.Uuid => typeof(Guid),
-            AllSchemaTypes.Any => _unknownType,
-            AllSchemaTypes.AnyObject => ToXMsFormatType(format) ?? _unknownType,
+            AllSchemaTypes.Any => UnknownType,
+            AllSchemaTypes.AnyObject => ToXMsFormatType(format) ?? UnknownType,
             AllSchemaTypes.Binary => typeof(byte[]),
             _ => null
         };

src/AutoRest.CSharp/Common/Output/Builders/BuilderHelpers.cs

@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Security;
 using System.Text;
 using AutoRest.CSharp.Common.Input;
 using AutoRest.CSharp.Generation.Types;
@@ -358,5 +357,66 @@ public static MethodSignatureModifiers MapModifiers(ISymbol symbol)
             }
             return modifiers;
         }
+
+        public static CSharpType CreateAdditionalPropertiesPropertyType(CSharpType originalType, CSharpType unknownType)
+        {
+            // TODO -- we only construct additional properties when the type is verifiable, because we always need the property to fall into the bucket of serialized additional raw data field when it does not fit the additional properties.
+            var arguments = originalType.Arguments;
+            var keyType = arguments[0];
+            var valueType = arguments[1];
+
+            return originalType.MakeGenericType(new[] { ReplaceUnverifiableType(keyType, unknownType), ReplaceUnverifiableType(valueType, unknownType) });
+        }
+
+        private static CSharpType ReplaceUnverifiableType(CSharpType type, CSharpType unknownType)
+        {
+            // when the type is System.Object
+            if (type.EqualsIgnoreNullable(unknownType))
+            {
+                return type;
+            }
+
+            // when the type is a verifiable type
+            if (BuilderHelpers.IsVerifiableType(type))
+            {
+                return type;
+            }
+
+            // when the type is a union
+            if (type.IsUnion)
+            {
+                return type;
+            }
+
+            // otherwise the type is not a verifiable type
+            // replace for list
+            if (type.IsList)
+            {
+                return type.MakeGenericType(new[] { ReplaceUnverifiableType(type.Arguments[0], unknownType) });
+            }
+            // replace for dictionary
+            if (type.IsDictionary)
+            {
+                return type.MakeGenericType(new[] { ReplaceUnverifiableType(type.Arguments[0], unknownType), ReplaceUnverifiableType(type.Arguments[1], unknownType) });
+            }
+            // for the other cases, wrap them in a union
+            return CSharpType.FromUnion(new[] { type }, type.IsNullable);
+        }
+
+        private static readonly HashSet<Type> _verifiableTypes = new HashSet<Type>
+        {
+            // The following types are constructed by the `TryGetXXX` methods on `JsonElement`.
+            typeof(byte), typeof(byte[]), typeof(sbyte),
+            typeof(DateTime), typeof(DateTimeOffset),
+            typeof(decimal), typeof(double), typeof(short), typeof(int), typeof(long), typeof(float),
+            typeof(ushort), typeof(uint), typeof(ulong),
+            typeof(Guid),
+            // The following types have a firm JsonValueKind to verify
+            typeof(string), typeof(bool)
+        };
+
+        public static bool IsVerifiableType(Type type) => _verifiableTypes.Contains(type);
+
+        public static bool IsVerifiableType(CSharpType type) => type is { IsFrameworkType: true, FrameworkType: { } frameworkType } && IsVerifiableType(frameworkType);
     }
 }