fix: handle empty root-level collections with flow style in serialization (#4)

Author: glucaci

src/Yamlify.SourceGenerator/YamlSourceGenerator.cs

@@ -2900,14 +2900,48 @@ private static void GenerateRootDictionaryRead(StringBuilder sb, ITypeSymbol dic
     /// </summary>
     private static void GenerateRootCollectionWrite(StringBuilder sb, ITypeSymbol collectionType, ITypeSymbol elementType, IReadOnlyList<TypeToGenerate> allTypes)
     {
-        sb.AppendLine("            writer.WriteSequenceStart();");
-        sb.AppendLine("            foreach (var item in value)");
+        // Use flow style for empty collections to output [] instead of nothing.
+        // For IEnumerable<T> that doesn't implement ICollection, we use TryGetNonEnumeratedCount or enumerate.
+        // Since we need to enumerate anyway for writing, we just check ICollection first for efficiency.
+        sb.AppendLine("            var hasItems = false;");
+        sb.AppendLine("            if (value is System.Collections.ICollection collection)");
         sb.AppendLine("            {");
+        sb.AppendLine("                hasItems = collection.Count > 0;");
+        sb.AppendLine("            }");
+        sb.AppendLine("            else");
+        sb.AppendLine("            {");
+        sb.AppendLine("                // For pure IEnumerable, we need to start iterating to know if it's empty");
+        sb.AppendLine("                using var enumerator = value.GetEnumerator();");
+        sb.AppendLine("                hasItems = enumerator.MoveNext();");
+        sb.AppendLine("                if (hasItems)");
+        sb.AppendLine("                {");
+        sb.AppendLine("                    // Non-empty IEnumerable - write sequence with first item, then rest");
+        sb.AppendLine("                    writer.WriteSequenceStart();");
+        sb.AppendLine("                    do");
+        sb.AppendLine("                    {");
+        GenerateElementWrite(sb, "enumerator.Current", elementType, allTypes, "                        ");
+        sb.AppendLine("                    } while (enumerator.MoveNext());");
+        sb.AppendLine("                    writer.WriteSequenceEnd();");
+        sb.AppendLine("                    return;");
+        sb.AppendLine("                }");
+        sb.AppendLine("            }");
+        sb.AppendLine();
+        sb.AppendLine("            if (!hasItems)");
+        sb.AppendLine("            {");
+        sb.AppendLine("                writer.WriteSequenceStart(Yamlify.CollectionStyle.Flow);");
+        sb.AppendLine("                writer.WriteSequenceEnd();");
+        sb.AppendLine("            }");
+        sb.AppendLine("            else");
+        sb.AppendLine("            {");
+        sb.AppendLine("                writer.WriteSequenceStart();");
+        sb.AppendLine("                foreach (var item in value)");
+        sb.AppendLine("                {");
 
-        GenerateElementWrite(sb, "item", elementType, allTypes, "                ");
+        GenerateElementWrite(sb, "item", elementType, allTypes, "                    ");
 
+        sb.AppendLine("                }");
+        sb.AppendLine("                writer.WriteSequenceEnd();");
         sb.AppendLine("            }");
-        sb.AppendLine("            writer.WriteSequenceEnd();");
         sb.AppendLine("        }");
     }
 

test/Yamlify.Tests/Serialization/CollectionSerializationTests.cs

@@ -779,6 +779,43 @@ public void RoundTripRootLevelList()
         }
     }
 
+    [Fact]
+    public void SerializeEmptyRootLevelList_ProducesFlowStyleEmptySequence()
+    {
+        var list = new List<SimpleClass>();
+
+        var yaml = YamlSerializer.Serialize(list, TestSerializerContext.Default.ListSimpleClass);
+
+        // Empty root-level list should produce flow-style empty sequence []
+        Assert.Equal("[]", yaml.Trim());
+    }
+
+    [Fact]
+    public void SerializeEmptyRootLevelIEnumerable_ProducesFlowStyleEmptySequence()
+    {
+        IEnumerable<SimpleClass> items = Array.Empty<SimpleClass>();
+
+        var yaml = YamlSerializer.Serialize(items, TestSerializerContext.Default.IEnumerableSimpleClass);
+
+        // Empty root-level IEnumerable should produce flow-style empty sequence []
+        Assert.Equal("[]", yaml.Trim());
+    }
+
+    [Fact]
+    public void SerializeRootLevelIEnumerable_WithItems_ProducesBlockStyleSequence()
+    {
+        IEnumerable<SimpleClass> items = new[]
+        {
+            new SimpleClass { Name = "First", Value = 1, IsActive = true },
+            new SimpleClass { Name = "Second", Value = 2, IsActive = false }
+        };
+
+        var yaml = YamlSerializer.Serialize(items, TestSerializerContext.Default.IEnumerableSimpleClass);
+
+        Assert.Contains("name: First", yaml);
+        Assert.Contains("name: Second", yaml);
+    }
+
     [Fact]
     public void SerializeRootLevelDictionary()
     {

test/Yamlify.Tests/Serialization/TestSerializerContext.cs

@@ -95,6 +95,7 @@ namespace Yamlify.Tests.Serialization;
 [YamlSerializable(typeof(TypeCollision.NamespaceB.Config))]
 // Root-level collection types
 [YamlSerializable(typeof(List<SimpleClass>))]
+[YamlSerializable(typeof(IEnumerable<SimpleClass>))]
 [YamlSerializable(typeof(Dictionary<string, SimpleClass>))]
 // Default value preservation test types
 [YamlSerializable(typeof(ClassWithPropertyDefaults))]