Enable customizing the default values in PropertyCSScriptSerializer

AndriySvyryd · AndriySvyryd · commit 214cecb218f7 · 2016-11-24T14:08:37.000-08:00
Change ICSScriptSerializable.GetSerializer() to return ICSScriptSerializer
Fix parameters not being used in DeserializeAsync
Don't use dynamic dispatch in LiteralCSScriptSerializer
diff --git a/global.json b/global.json
@@ -1,6 +1,6 @@
 {
   "projects": [ "src", "test" ],
   "sdk": {
-    "version": "1.0.0-preview2-003131"
+    "version": "1.0.0-preview2-1-003177"
   }
 }
diff --git a/src/CSharpScriptSerializer/CSScriptSerializer.cs b/src/CSharpScriptSerializer/CSScriptSerializer.cs
@@ -41,7 +41,8 @@ public static Task<T> DeserializeAsync<T>(string script)
         public static T Deserialize<T>(string script, IEnumerable<Assembly> referencedAssemblies, IEnumerable<string> imports)
             => DeserializeAsync<T>(script, referencedAssemblies, imports).GetAwaiter().GetResult();
 
-        public static Task<T> DeserializeAsync<T>(string script, IEnumerable<Assembly> referencedAssemblies, IEnumerable<string> imports)
+        public static Task<T> DeserializeAsync<T>(
+            string script, IEnumerable<Assembly> referencedAssemblies, IEnumerable<string> imports)
             => CSharpScript.EvaluateAsync<T>(script,
                 ScriptOptions.Default.WithReferences(
                     typeof(T).GetTypeInfo().Assembly,
@@ -53,10 +54,12 @@ public static Task<T> DeserializeAsync<T>(string script, IEnumerable<Assembly> r
                     .AddReferences(typeof(CSScriptSerializer).GetTypeInfo()
                         .Assembly.GetReferencedAssemblies()
                         .Select(Assembly.Load))
+                    .AddReferences(referencedAssemblies)
                     .AddImports(
                         typeof(T).GetTypeInfo().Namespace,
                         typeof(DateTime).GetTypeInfo().Namespace,
-                        typeof(List<>).GetTypeInfo().Namespace));
+                        typeof(List<>).GetTypeInfo().Namespace)
+                    .AddImports(imports));
 
         public static string Serialize(object obj)
         {
@@ -80,10 +83,7 @@ public static CompilationUnitSyntax GetCompilationUnitExpression(object obj)
 
         public static ExpressionSyntax GetCreationExpression(object obj)
         {
-            var serializable = obj as ICSScriptSerializable;
-            return serializable != null
-                ? serializable.GetCreation()
-                : GetSerializer(obj).GetCreation(obj);
+            return GetSerializer(obj).GetCreation(obj);
         }
 
         private static ICSScriptSerializer GetSerializer(object obj)
@@ -93,6 +93,12 @@ private static ICSScriptSerializer GetSerializer(object obj)
                 return NullCSScriptSerializer.Instance;
             }
 
+            var serializable = obj as ICSScriptSerializable;
+            if (serializable != null)
+            {
+                return serializable.GetSerializer();
+            }
+
             var type = UnwrapNullableType(obj.GetType());
             if (type == typeof(bool))
             {
@@ -238,7 +244,6 @@ private static ICSScriptSerializer CreateSerializer(Type type)
                 throw new InvalidOperationException($"The type {type} does not have public writable properties");
             }
 
-            // TODO: record types being constructed to avoid recursion
             return (CSScriptSerializer)GetDeclaredConstructor(
                 typeof(PropertyCSScriptSerializer<>).MakeGenericType(type), types: null)
                 .Invoke(parameters: null);
diff --git a/src/CSharpScriptSerializer/CollectionCSScriptSerializer.cs b/src/CSharpScriptSerializer/CollectionCSScriptSerializer.cs
@@ -13,19 +13,19 @@ public class CollectionCSScriptSerializer<T> : ConstructorCSScriptSerializer<T>
         private readonly Func<T, IEnumerable<object>> _getEnumerable;
 
         public CollectionCSScriptSerializer()
-            : this(elementDecomposers: null, parameterGetters: null)
+            : this(elementDecomposers: null, constructorParameterGetters: null)
         {
         }
 
         public CollectionCSScriptSerializer(
             IReadOnlyCollection<Func<object, object>> elementDecomposers)
-            : this(elementDecomposers, parameterGetters: null)
+            : this(elementDecomposers, constructorParameterGetters: null)
         {
         }
 
         public CollectionCSScriptSerializer(
-            IReadOnlyCollection<Func<T, object>> parameterGetters)
-            : this(elementDecomposers: null, parameterGetters: parameterGetters)
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters)
+            : this(elementDecomposers: null, constructorParameterGetters: constructorParameterGetters)
         {
         }
 
@@ -37,9 +37,9 @@ public CollectionCSScriptSerializer(
         }
 
         public CollectionCSScriptSerializer(
-            IReadOnlyCollection<Func<T, object>> parameterGetters,
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters,
             Func<T, IEnumerable<object>> getEnumerable)
-            : this(elementDecomposers: null, parameterGetters: parameterGetters, getEnumerable: getEnumerable)
+            : this(elementDecomposers: null, constructorParameterGetters: constructorParameterGetters, getEnumerable: getEnumerable)
         {
         }
 
@@ -52,8 +52,8 @@ public CollectionCSScriptSerializer(
 
         public CollectionCSScriptSerializer(
             IReadOnlyCollection<Func<object, object>> elementDecomposers,
-            IReadOnlyCollection<Func<T, object>> parameterGetters)
-            : this(elementDecomposers, parameterGetters, getEnumerable: null)
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters)
+            : this(elementDecomposers, constructorParameterGetters, getEnumerable: null)
         {
         }
 
@@ -71,9 +71,9 @@ public CollectionCSScriptSerializer(
 
         public CollectionCSScriptSerializer(
             IReadOnlyCollection<Func<object, object>> elementDecomposers,
-            IReadOnlyCollection<Func<T, object>> parameterGetters,
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters,
             Func<T, IEnumerable<object>> getEnumerable)
-            : base(parameterGetters)
+            : base(constructorParameterGetters)
         {
             _elementDecomposers = elementDecomposers;
             _getEnumerable = getEnumerable ?? (o => ((IEnumerable)o).Cast<object>());
diff --git a/src/CSharpScriptSerializer/ConstructorCSScriptSerializer.cs b/src/CSharpScriptSerializer/ConstructorCSScriptSerializer.cs
@@ -9,10 +9,10 @@ namespace CSharpScriptSerialization
     public class ConstructorCSScriptSerializer<T> : CSScriptSerializer
     {
         private ObjectCreationExpressionSyntax _objectCreationExpression;
-        private readonly IReadOnlyCollection<Func<T, object>> _parameterGetters;
+        private readonly IReadOnlyCollection<Func<T, object>> _constructorParameterGetters;
 
         public ConstructorCSScriptSerializer()
-            : this(parameterGetters: null)
+            : this(constructorParameterGetters: null)
         {
         }
 
@@ -22,27 +22,27 @@ public ConstructorCSScriptSerializer(IReadOnlyCollection<Func<object, object>> n
         {
         }
 
-        public ConstructorCSScriptSerializer(IReadOnlyCollection<Func<T, object>> parameterGetters)
+        public ConstructorCSScriptSerializer(IReadOnlyCollection<Func<T, object>> constructorParameterGetters)
             : base(typeof(T))
         {
-            _parameterGetters = parameterGetters;
+            _constructorParameterGetters = constructorParameterGetters;
         }
 
         protected virtual bool GenerateEmptyArgumentList => true;
 
         public override ExpressionSyntax GetCreation(object obj) => GetObjectCreationExpression((T)obj);
 
         protected virtual ObjectCreationExpressionSyntax GetObjectCreationExpression(T obj)
-            => _parameterGetters == null
-               || _parameterGetters.Count == 0
+            => _constructorParameterGetters == null
+               || _constructorParameterGetters.Count == 0
                 ? GenerateEmptyArgumentList
                     ? GetObjectCreationExpression().WithArgumentList(SyntaxFactory.ArgumentList())
                     : GetObjectCreationExpression()
                 : GetObjectCreationExpression()
                     .WithArgumentList(AddNewLine(SyntaxFactory.ArgumentList(
                         SyntaxFactory.SeparatedList<ArgumentSyntax>(
                             ToCommaSeparatedList(
-                                _parameterGetters.Select(a =>
+                                _constructorParameterGetters.Select(a =>
                                     SyntaxFactory.Argument(GetCreationExpression(a(obj)))))))));
 
         protected virtual ObjectCreationExpressionSyntax GetObjectCreationExpression()
diff --git a/src/CSharpScriptSerializer/Extensions.cs b/src/CSharpScriptSerializer/Extensions.cs
@@ -24,5 +24,20 @@ internal static IEnumerable<T> GetFlags<T>(this T flags)
 
             return values;
         }
+
+        internal static TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
+            => dictionary.GetValueOrDefault(key, default(TValue));
+
+        internal static TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary,
+            TKey key, TValue fallBack)
+        {
+            TValue value;
+            if (dictionary.TryGetValue(key, out value))
+            {
+                return value;
+            }
+
+            return fallBack;
+        }
     }
 }
diff --git a/src/CSharpScriptSerializer/ICSScriptSerializable.cs b/src/CSharpScriptSerializer/ICSScriptSerializable.cs
@@ -1,9 +1,7 @@
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
 namespace CSharpScriptSerialization
 {
     public interface ICSScriptSerializable
     {
-        ExpressionSyntax GetCreation();
+        ICSScriptSerializer GetSerializer();
     }
 }
diff --git a/src/CSharpScriptSerializer/LiteralCSScriptSerializer.cs b/src/CSharpScriptSerializer/LiteralCSScriptSerializer.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
@@ -17,6 +19,24 @@ public LiteralCSScriptSerializer(Type type, SyntaxKind kind)
         public override ExpressionSyntax GetCreation(object obj)
             => SyntaxFactory.LiteralExpression(
                 Kind,
-                SyntaxFactory.Literal((dynamic)obj));
+                LiteralFactories[obj.GetType()](obj));
+
+        private static readonly Dictionary<Type, Func<object, SyntaxToken>> LiteralFactories =
+            new Dictionary<Type, Func<object, SyntaxToken>>
+            {
+                {typeof(char), x => SyntaxFactory.Literal((char)x)},
+                {typeof(decimal), x => SyntaxFactory.Literal((decimal)x)},
+                {typeof(double), x => SyntaxFactory.Literal((double)x)},
+                {typeof(float), x => SyntaxFactory.Literal((float)x)},
+                {typeof(int), x => SyntaxFactory.Literal((int)x)},
+                {typeof(long), x => SyntaxFactory.Literal((long)x)},
+                {typeof(string), x => SyntaxFactory.Literal((string)x)},
+                {typeof(uint), x => SyntaxFactory.Literal((uint)x)},
+                {typeof(ulong), x => SyntaxFactory.Literal((ulong)x)},
+                {typeof(short), x => SyntaxFactory.Literal((short)x)},
+                {typeof(byte), x => SyntaxFactory.Literal((byte)x)},
+                {typeof(ushort), x => SyntaxFactory.Literal((ushort)x)},
+                {typeof(sbyte), x => SyntaxFactory.Literal((sbyte)x)}
+            };
     }
 }
diff --git a/src/CSharpScriptSerializer/PropertyCSScriptSerializer.cs b/src/CSharpScriptSerializer/PropertyCSScriptSerializer.cs
@@ -23,36 +23,64 @@ public PropertyCSScriptSerializer(IReadOnlyCollection<Func<T, object>> argumentG
         }
 
         public PropertyCSScriptSerializer(IEnumerable<PropertyInfo> properties)
-            : this(properties, parameterGetters: null)
+            : this(properties, constructorParameterGetters: null)
         {
         }
 
         public PropertyCSScriptSerializer(IReadOnlyDictionary<string, Func<T, object>> propertyValueGetters)
-            : this(propertyValueGetters, parameterGetters: null)
+            : this(propertyValueGetters, constructorParameterGetters: null)
         {
         }
 
         public PropertyCSScriptSerializer(IEnumerable<PropertyInfo> properties,
-            IReadOnlyCollection<Func<T, object>> parameterGetters)
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters)
+            : this(properties.Select(p => new PropertyData(
+                p.Name,
+                p.PropertyType,
+                CreatePropertyInitializer(p),
+                o => GetDefault(p.PropertyType))).ToArray(),
+                constructorParameterGetters)
+        {
+        }
+
+        public PropertyCSScriptSerializer(IReadOnlyDictionary<string, Func<T, object>> propertyValueGetters,
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters)
+            : this(propertyValueGetters, constructorParameterGetters, new Dictionary<string, object>())
+        {
+        }
+
+        public PropertyCSScriptSerializer(IReadOnlyDictionary<string, Func<T, object>> propertyValueGetters,
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters,
+            IReadOnlyDictionary<string, object> propertyDefaults)
             : this(
-                properties.Select(p => new PropertyData(p.Name, p.PropertyType, CreatePropertyInitializer(p))).ToArray(),
-                parameterGetters)
+                propertyValueGetters,
+                constructorParameterGetters,
+                propertyDefaults.ToDictionary<KeyValuePair<string, object>, string, Func<T, object>>(
+                    p => p.Key,
+                    p => o => p.Value))
         {
         }
 
         public PropertyCSScriptSerializer(IReadOnlyDictionary<string, Func<T, object>> propertyValueGetters,
-            IReadOnlyCollection<Func<T, object>> parameterGetters)
-            : base(parameterGetters)
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters,
+            IReadOnlyDictionary<string, Func<T, object>> propertyDefaultGetters)
+            : this(constructorParameterGetters)
         {
             var properties = typeof(T).GetTypeInfo()
-                    .GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-                    .ToDictionary(p => p.Name);
-            _propertyData = propertyValueGetters.Select(p => new PropertyData(p.Key, properties[p.Key].PropertyType, p.Value)).ToArray();
+                .GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .ToDictionary(p => p.Name);
+            _propertyData = propertyValueGetters.Select(
+                p => new PropertyData(
+                    p.Key,
+                    properties[p.Key].PropertyType,
+                    p.Value,
+                    propertyDefaultGetters.GetValueOrDefault(p.Key, o => GetDefault(properties[p.Key].PropertyType))))
+                .ToArray();
         }
 
         protected PropertyCSScriptSerializer(IReadOnlyCollection<PropertyData> propertyData,
-            IReadOnlyCollection<Func<T, object>> parameterGetters)
-            : base(parameterGetters)
+            IReadOnlyCollection<Func<T, object>> constructorParameterGetters)
+            : base(constructorParameterGetters)
         {
             _propertyData = propertyData;
         }
@@ -62,21 +90,25 @@ protected PropertyCSScriptSerializer(IReadOnlyCollection<PropertyData> propertyD
         public override ExpressionSyntax GetCreation(object obj)
             => GetObjectCreationExpression((T)obj);
 
-        // TODO: custom defaults
         protected override ObjectCreationExpressionSyntax GetObjectCreationExpression(T obj)
             => base.GetObjectCreationExpression(obj)
                 .WithInitializer(AddNewLine(
                     SyntaxFactory.InitializerExpression(
                         SyntaxKind.ObjectInitializerExpression,
                         SyntaxFactory.SeparatedList<ExpressionSyntax>(
                             ToCommaSeparatedList(_propertyData
-                                .Select(p => new {p.PropertyName, p.PropertyType, PropertyValue = p.PropertyInitializer(obj)})
-                                .Where(p => !IsDefault(p.PropertyValue, p.PropertyType))
-                                .Select(p =>
-                                    SyntaxFactory.AssignmentExpression(
-                                        SyntaxKind.SimpleAssignmentExpression,
-                                        SyntaxFactory.IdentifierName(p.PropertyName),
-                                        GetCreationExpression(p.PropertyValue))))))));
+                                .Select(p => new
+                                {
+                                    p.PropertyName,
+                                    p.PropertyType,
+                                    PropertyValue = p.PropertyValueGetter(obj),
+                                    PropertyDefault = p.PropertyDefaultGetter(obj)
+                                })
+                                .Where(p => !Equals(p.PropertyValue, p.PropertyDefault))
+                                .Select(p => SyntaxFactory.AssignmentExpression(
+                                    SyntaxKind.SimpleAssignmentExpression,
+                                    SyntaxFactory.IdentifierName(p.PropertyName),
+                                    GetCreationExpression(p.PropertyValue))))))));
 
         protected static Func<T, object> CreatePropertyInitializer(PropertyInfo property)
         {
@@ -91,16 +123,22 @@ protected static Func<T, object> CreatePropertyInitializer(PropertyInfo property
 
         protected class PropertyData
         {
-            public PropertyData(string propertyName, Type propertyType, Func<T, object> propertyInitializer)
+            public PropertyData(
+                string propertyName,
+                Type propertyType,
+                Func<T, object> propertyValueGetter,
+                Func<T, object> propertyDefaultGetter)
             {
                 PropertyName = propertyName;
                 PropertyType = propertyType;
-                PropertyInitializer = propertyInitializer;
+                PropertyValueGetter = propertyValueGetter;
+                PropertyDefaultGetter = propertyDefaultGetter;
             }
 
             public string PropertyName { get; }
             public Type PropertyType { get; }
-            public Func<T, object> PropertyInitializer { get; }
+            public Func<T, object> PropertyValueGetter { get; }
+            public Func<T, object> PropertyDefaultGetter { get; }
         }
     }
 }
diff --git a/src/CSharpScriptSerializer/project.json b/src/CSharpScriptSerializer/project.json
diff --git a/test/CSharpScriptSerializer.Tests/RoundTrippingTest.cs b/test/CSharpScriptSerializer.Tests/RoundTrippingTest.cs
diff --git a/test/CSharpScriptSerializer.Tests/project.json b/test/CSharpScriptSerializer.Tests/project.json

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"projects": [ "src", "test" ],`
`3`	`3`	`"sdk": {`
`4`		`- "version": "1.0.0-preview2-003131"`
	`4`	`+ "version": "1.0.0-preview2-1-003177"`
`5`	`5`	`}`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,19 +13,19 @@ public class CollectionCSScriptSerializer<T> : ConstructorCSScriptSerializer<T>`
`13`	`13`	`private readonly Func<T, IEnumerable<object>> _getEnumerable;`
`14`	`14`
`15`	`15`	`public CollectionCSScriptSerializer()`
`16`		`- : this(elementDecomposers: null, parameterGetters: null)`
	`16`	`+ : this(elementDecomposers: null, constructorParameterGetters: null)`
`17`	`17`	`{`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public CollectionCSScriptSerializer(`
`21`	`21`	`IReadOnlyCollection<Func<object, object>> elementDecomposers)`
`22`		`- : this(elementDecomposers, parameterGetters: null)`
	`22`	`+ : this(elementDecomposers, constructorParameterGetters: null)`
`23`	`23`	`{`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public CollectionCSScriptSerializer(`
`27`		`- IReadOnlyCollection<Func<T, object>> parameterGetters)`
`28`		`- : this(elementDecomposers: null, parameterGetters: parameterGetters)`
	`27`	`+ IReadOnlyCollection<Func<T, object>> constructorParameterGetters)`
	`28`	`+ : this(elementDecomposers: null, constructorParameterGetters: constructorParameterGetters)`
`29`	`29`	`{`
`30`	`30`	`}`
`31`	`31`
`@@ -37,9 +37,9 @@ public CollectionCSScriptSerializer(`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public CollectionCSScriptSerializer(`
`40`		`- IReadOnlyCollection<Func<T, object>> parameterGetters,`
	`40`	`+ IReadOnlyCollection<Func<T, object>> constructorParameterGetters,`
`41`	`41`	`Func<T, IEnumerable<object>> getEnumerable)`
`42`		`- : this(elementDecomposers: null, parameterGetters: parameterGetters, getEnumerable: getEnumerable)`
	`42`	`+ : this(elementDecomposers: null, constructorParameterGetters: constructorParameterGetters, getEnumerable: getEnumerable)`
`43`	`43`	`{`
`44`	`44`	`}`
`45`	`45`
`@@ -52,8 +52,8 @@ public CollectionCSScriptSerializer(`
`52`	`52`
`53`	`53`	`public CollectionCSScriptSerializer(`
`54`	`54`	`IReadOnlyCollection<Func<object, object>> elementDecomposers,`
`55`		`- IReadOnlyCollection<Func<T, object>> parameterGetters)`
`56`		`- : this(elementDecomposers, parameterGetters, getEnumerable: null)`
	`55`	`+ IReadOnlyCollection<Func<T, object>> constructorParameterGetters)`
	`56`	`+ : this(elementDecomposers, constructorParameterGetters, getEnumerable: null)`
`57`	`57`	`{`
`58`	`58`	`}`
`59`	`59`
`@@ -71,9 +71,9 @@ public CollectionCSScriptSerializer(`
`71`	`71`
`72`	`72`	`public CollectionCSScriptSerializer(`
`73`	`73`	`IReadOnlyCollection<Func<object, object>> elementDecomposers,`
`74`		`- IReadOnlyCollection<Func<T, object>> parameterGetters,`
	`74`	`+ IReadOnlyCollection<Func<T, object>> constructorParameterGetters,`
`75`	`75`	`Func<T, IEnumerable<object>> getEnumerable)`
`76`		`- : base(parameterGetters)`
	`76`	`+ : base(constructorParameterGetters)`
`77`	`77`	`{`
`78`	`78`	`_elementDecomposers = elementDecomposers;`
`79`	`79`	`_getEnumerable = getEnumerable ?? (o => ((IEnumerable)o).Cast<object>());`
Original file line number	Diff line number	Diff line change
`@@ -9,10 +9,10 @@ namespace CSharpScriptSerialization`
`9`	`9`	`public class ConstructorCSScriptSerializer<T> : CSScriptSerializer`
`10`	`10`	`{`
`11`	`11`	`private ObjectCreationExpressionSyntax _objectCreationExpression;`
`12`		`- private readonly IReadOnlyCollection<Func<T, object>> _parameterGetters;`
	`12`	`+ private readonly IReadOnlyCollection<Func<T, object>> _constructorParameterGetters;`
`13`	`13`
`14`	`14`	`public ConstructorCSScriptSerializer()`
`15`		`- : this(parameterGetters: null)`
	`15`	`+ : this(constructorParameterGetters: null)`
`16`	`16`	`{`
`17`	`17`	`}`
`18`	`18`
`@@ -22,27 +22,27 @@ public ConstructorCSScriptSerializer(IReadOnlyCollection<Func<object, object>> n`
`22`	`22`	`{`
`23`	`23`	`}`
`24`	`24`
`25`		`- public ConstructorCSScriptSerializer(IReadOnlyCollection<Func<T, object>> parameterGetters)`
	`25`	`+ public ConstructorCSScriptSerializer(IReadOnlyCollection<Func<T, object>> constructorParameterGetters)`
`26`	`26`	`: base(typeof(T))`
`27`	`27`	`{`
`28`		`- _parameterGetters = parameterGetters;`
	`28`	`+ _constructorParameterGetters = constructorParameterGetters;`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`protected virtual bool GenerateEmptyArgumentList => true;`
`32`	`32`
`33`	`33`	`public override ExpressionSyntax GetCreation(object obj) => GetObjectCreationExpression((T)obj);`
`34`	`34`
`35`	`35`	`protected virtual ObjectCreationExpressionSyntax GetObjectCreationExpression(T obj)`
`36`		`- => _parameterGetters == null`
`37`		`- \|\| _parameterGetters.Count == 0`
	`36`	`+ => _constructorParameterGetters == null`
	`37`	`+ \|\| _constructorParameterGetters.Count == 0`
`38`	`38`	`? GenerateEmptyArgumentList`
`39`	`39`	`? GetObjectCreationExpression().WithArgumentList(SyntaxFactory.ArgumentList())`
`40`	`40`	`: GetObjectCreationExpression()`
`41`	`41`	`: GetObjectCreationExpression()`
`42`	`42`	`.WithArgumentList(AddNewLine(SyntaxFactory.ArgumentList(`
`43`	`43`	`SyntaxFactory.SeparatedList<ArgumentSyntax>(`
`44`	`44`	`ToCommaSeparatedList(`
`45`		`- _parameterGetters.Select(a =>`
	`45`	`+ _constructorParameterGetters.Select(a =>`
`46`	`46`	`SyntaxFactory.Argument(GetCreationExpression(a(obj)))))))));`
`47`	`47`
`48`	`48`	`protected virtual ObjectCreationExpressionSyntax GetObjectCreationExpression()`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,7 @@`
`1`		`-using Microsoft.CodeAnalysis.CSharp.Syntax;`
`2`		`-`
`3`	`1`	`namespace CSharpScriptSerialization`
`4`	`2`	`{`
`5`	`3`	`public interface ICSScriptSerializable`
`6`	`4`	`{`
`7`		`- ExpressionSyntax GetCreation();`
	`5`	`+ ICSScriptSerializer GetSerializer();`
`8`	`6`	`}`
`9`	`7`	`}`