Support for serialization of records with no default constructor

src/Parquet.Test/Serialisation/ParquetSerializerTest.cs

@@ -203,7 +203,7 @@
                 ["Timestamp"] = DateTime.UtcNow.AddSeconds(i),
                 ["EventName"] = i % 2 == 0 ? "on" : "off",
                 ["MeterValue"] = (double)i,
                 ["ParentId"] = (i % 4 == 0) ? null : i,
                 ["ExternalId"] = Guid.NewGuid()
             }).ToList();
 
@@ -397,7 +397,7 @@
         public async Task List_Structs_Serde_Dict() {
             var data = Enumerable.Range(0, 1_000).Select(i => new Dictionary<string, object> {
                 ["PersonId"] = i,
                 ["Comments"] = i % 2 == 0 ? "none" : null,
                 ["Addresses"] = Enumerable.Range(0, 4).Select(a => new Dictionary<string, object> {
                     ["City"] = "Birmingham",
                     ["Country"] = "United Kingdom"
@@ -854,6 +854,233 @@
             Assert.Equivalent(data2, data);
         }
 
+        public record TrivialRecord(int E, string F);
+
+        [Fact]
+        public async Task TrivialRecord_Roundtrip()
+        {
+            var expected = new[]
+            {
+                new TrivialRecord(4, "[4]"),
+                new TrivialRecord(7, "[7]"),
+            };
+
+            Assert.Equivalent(await RoundTripAsync(expected), expected);
+        }
+
+        public record NonTrivialRecord(int E, string F)
+        {
+            // Private field refers to constructor params/props, 
+            // so generates code in the primary constructor.
+            private readonly string _g = $@"{E} {F}";
+
+            public string GetG() => _g;
+        }
+
+        [Fact]
+        public async Task NonTrivialRecord_Roundtrip()
+        {
+            var expected = new[]
+            {
+                new NonTrivialRecord(5, "{5}"),
+                new NonTrivialRecord(15, "{15}"),
+                new NonTrivialRecord(25, "{25}"),
+                new NonTrivialRecord(35, "{35}"),            
+            };
+
+            var actual = await RoundTripAsync(expected);
+            Assert.Equivalent(expected, actual);
+
+            Assert.Equivalent(expected.Select(x => x.GetG()), actual.Select(x => x.GetG()));
+        }
+
+        public record RecordWithNestedList(int A, string B, List<NonTrivialRecord> NestedList)
+        {
+            private readonly string _c = $@"{A} {B}";
+
+            public string GetC() => _c;
+        }
+
+        [Fact]
+        public async Task RecordWithNestedList_Roundtrip()
+        {
+            var expected = new[]
+            {
+                new RecordWithNestedList(4, "[4]", 
+                [
+                    new NonTrivialRecord(5, "{5}"),
+                    new NonTrivialRecord(15, "{15}"),
+                    new NonTrivialRecord(25, "{25}"),
+                    new NonTrivialRecord(35, "{35}"),
+                ]),
+
+                new RecordWithNestedList(7, "[4]", 
+                [
+                    new NonTrivialRecord(2, "{2}"),
+                    new NonTrivialRecord(4, "{4}"),
+                    new NonTrivialRecord(8, "{8}"),
+                    new NonTrivialRecord(16, "{16}"),
+                ]),
+            };
+
+            var actual = await RoundTripAsync(expected);
+
+            Assert.Equivalent(expected, actual);
+
+            Assert.Equivalent(expected.Select(x => x.GetC()), actual.Select(x => x.GetC()));
+
+            Assert.Equivalent(expected[0].NestedList.Select(x => x.GetG()), actual[0].NestedList.Select(x => x.GetG()));
+            Assert.Equivalent(expected[1].NestedList.Select(x => x.GetG()), actual[1].NestedList.Select(x => x.GetG()));
+        }
+
+        public class ClassWithNullableRecordProperties
+        {
+            public TrivialRecord? Trivial { get; set; }
+
+            public NonTrivialRecord? NonTrivial { get; set; }
+
+            public RecordWithNestedList? NestedList { get; set; }
+
+            public List<TrivialRecord>? ListOfTrivial { get; set; }
+
+            public List<NonTrivialRecord>? ListOfNonTrivial { get; set; }
+
+            public List<RecordWithNestedList>? ListOfNestedList { get; set; }
+        }
+
+        [Fact]
+        public async Task ClassWithNullableRecordProperties_AllNull()
+        {
+            var expected = new[]
+            {
+                new ClassWithNullableRecordProperties(),
+            };
+
+            var actual = await RoundTripAsync(expected);
+
+            Assert.Equivalent(expected, actual);
+        }
+
+        [Fact]
+        public async Task ClassWithNullableRecordProperties_SimpleProperties()
+        {
+            var expected = new[]
+            {
+                new ClassWithNullableRecordProperties(),
+
+                new ClassWithNullableRecordProperties
+                {
+                    Trivial = new(11, "[11]"),
+                    NonTrivial = new(22, "{22}"),                    
+                },
+            };
+
+            var actual = await RoundTripAsync(expected);
+
+            Assert.Equivalent(expected, actual);
+
+            Assert.Equivalent(expected[1].NonTrivial!.GetG(), actual[1].NonTrivial!.GetG());
+        }
+
+        [Fact]
+        public async Task ClassWithNullableRecordProperties_Lists()
+        {
+            var expected = new[]
+            {
+                new ClassWithNullableRecordProperties(),
+
+                new ClassWithNullableRecordProperties
+                {
+                    ListOfTrivial =
+                    [
+                        new(33, "[33]"),
+                        new(44, "[44]"),
+                    ],
+                    ListOfNonTrivial =
+                    [
+                        new(55, "[55]"),
+                        new(66, "[66]"),
+                    ],
+                },
+            };
+
+            var actual = await RoundTripAsync(expected);
+
+            Assert.Equivalent(expected, actual);
+
+            Assert.Equivalent(
+                expected[1].ListOfNonTrivial!.Select(x => x?.GetG()), 
+                actual[1].ListOfNonTrivial!.Select(x => x?.GetG()));
+        }
+
+        [Fact]
+        public async Task ClassWithNullableRecordProperties_Mixed()
+        {
+            var expected = new[]
+            {
+                new ClassWithNullableRecordProperties(),
+
+                new ClassWithNullableRecordProperties
+                {
+                    Trivial = new(11, "[11]"),
+                    NonTrivial = new(22, "{22}"),
+                    ListOfTrivial =
+                    [
+                        new(33, "[33]"),
+                        new(44, "[44]"),
+                    ],
+                    ListOfNonTrivial =
+                    [
+                        new(55, "[55]"),
+                        new(66, "[66]"),
+                    ],
+                    ListOfNestedList =
+                    [
+                        new RecordWithNestedList(4, "[4]", 
+                        [
+                            new NonTrivialRecord(5, "{5}"),
+                            new NonTrivialRecord(15, "{15}"),
+                            new NonTrivialRecord(25, "{25}"),
+                            new NonTrivialRecord(35, "{35}"),
+                        ]),
+
+                        new RecordWithNestedList(7, "[4]", 
+                        [
+                            new NonTrivialRecord(2, "{2}"),
+                            new NonTrivialRecord(4, "{4}"),
+                            new NonTrivialRecord(8, "{8}"),
+                            new NonTrivialRecord(16, "{16}"),
+                        ]),
+                    ]
+                },
+            };
+
+            var actual = await RoundTripAsync(expected);
+
+            Assert.Equivalent(expected, actual);
+
+            Assert.Equivalent(expected[1].NonTrivial!.GetG(), actual[1].NonTrivial!.GetG());
+
+            Assert.Equivalent(
+                expected[1].ListOfNonTrivial!.Select(x => x?.GetG()), 
+                actual[1].ListOfNonTrivial!.Select(x => x?.GetG()));
+
+            Assert.Equivalent(
+                expected[1].ListOfNestedList!.Select(x => x?.GetC()), 
+                actual[1].ListOfNestedList!.Select(x => x?.GetC()));
+
+            Assert.Equivalent(
+                expected[1].ListOfNestedList!.SelectMany(x => x.NestedList.Select(y => y?.GetG())), 
+                actual[1].ListOfNestedList!.SelectMany(x => x.NestedList.Select(y => y?.GetG())));
+        }
+
+        private static async Task<IList<T>> RoundTripAsync<T>(IList<T> records)
+        {
+            using var ms = new MemoryStream();
+            await ParquetSerializer.SerializeAsync(records, ms);
+            ms.Position = 0;
+            return await ParquetSerializer.DeserializeAsync<T>(ms);
+        }
 #endif
     }
 }

src/Parquet/Serialization/Dremel/FieldAssemblerCompiler.cs

@@ -4,6 +4,8 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
 using Parquet.Data;
 using Parquet.Extensions;
 using Parquet.Schema;
@@ -170,6 +172,9 @@ private Expression TransitionRSM() {
                     _rsmVar.ClearArray(_rlVar)));
         }
 
+        private static Expression AllocateNew(Type type) 
+            => PreConstructor.AllocateNew(type);
+
         private Expression GetCollectionElement(Expression collection, int rlDepth,
             Type collectionType, Type elementType) {
             ParameterExpression indexVar = Expression.Variable(typeof(int), "index");
@@ -185,7 +190,7 @@ private Expression GetCollectionElement(Expression collection, int rlDepth,
                     Expression.LessThanOrEqual(downcastedCollection.CollectionCount(collectionType), indexVar),
 
                     Expression.Block(
-                        Expression.Assign(resultElementVar, Expression.New(elementType)),
+                        Expression.Assign(resultElementVar, AllocateNew(elementType)),
                         downcastedCollection.CollectionAdd(collectionType, resultElementVar, elementType)),
 
                     Expression.Assign(resultElementVar, Expression.Property(downcastedCollection, "Item", indexVar))
@@ -245,7 +250,7 @@ private static Expression CreateInstance(Type t) {
                 return Expression.NewArrayBounds(t.GetElementType()!, Zero);
             }
 
-            return Expression.New(t);
+            return AllocateNew(t);
         }
 
         private static Expression RebuildArray(Expression arrayAccessor, Type arrayType, Expression newElement) {