Support [SuppressDefaultInitialization] with VersionTolerant, and add validation

Author: hadashiA

src/MemoryPack.Generator/DiagnosticDescriptors.cs

@@ -324,4 +324,12 @@ internal static class DiagnosticDescriptors
         category: Category,
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true);
+
+    public static readonly DiagnosticDescriptor SuppressDefaultInitializationMustBeSettable = new(
+        id: "MEMPACK040",
+        title: "Readonly member cannot specify [SuppressDefaultInitialization]",
+        messageFormat: "The MemoryPackable object '{0}' member '{1}' has [SuppressDefaultInitialization], it cannot be readonly, init-only and required.",
+        category: Category,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
 }

src/MemoryPack.Generator/MemoryPackGenerator.Emitter.cs

@@ -547,7 +547,7 @@ private string EmitDeserializeBody()
         {
 {{EmitDeserializeConstruction("            ")}}
         };
-{{Members.Select((x, i) => (x, i)).Where(v => v.x.SkipOverwriteByDefault && v.x.IsAssignable).Select(v => $"        if ({v.i + 1} <= count) value.@{v.x.Name} = __{v.x.Name};").NewLine()}}
+{{EmitDeserializeConstructionWithBranching("        ")}}
     READ_END:
 {{readEndBody}}
 """;
@@ -917,10 +917,28 @@ string EmitDeserializeConstruction(string indent)
     {
         // all value is deserialized, __Name is exsits.
         return string.Join("," + Environment.NewLine, Members
-            .Where(x => x is { IsSettable: true, IsConstructorParameter: false, SkipOverwriteByDefault: false })
+            .Where(x => x is { IsSettable: true, IsConstructorParameter: false, SuppressDefaultInitialization: false })
             .Select(x => $"{indent}@{x.Name} = __{x.Name}"));
     }
 
+    string EmitDeserializeConstructionWithBranching(string indent)
+    {
+        var members = Members
+            .Select((x, i) => (x, i))
+            .Where(v => v.x.SuppressDefaultInitialization);
+
+        if (GenerateType is GenerateType.VersionTolerant or GenerateType.CircularReference)
+        {
+            return members
+                .Select(v => $"{indent}if (deltas[{v.i}] != 0) value.@{v.x.Name} = __{v.x.Name};")
+                .NewLine();
+        }
+
+        return members
+            .Select(v => $"{indent}if ({v.i + 1} <= count) value.@{v.x.Name} = __{v.x.Name};")
+            .NewLine();
+    }
+
     string EmitUnionTemplate(IGeneratorContext context)
     {
         var classOrInterfaceOrRecord = IsRecord ? "record" : (Symbol.TypeKind == TypeKind.Interface) ? "interface" : "class";

src/MemoryPack.Generator/MemoryPackGenerator.Parser.cs

@@ -375,6 +375,11 @@ public bool Validate(TypeDeclarationSyntax syntax, IGeneratorContext context, bo
                     context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.ReadOnlyFieldMustBeConstructorMember, item.GetLocation(syntax), Symbol.Name, item.Name));
                     noError = false;
                 }
+                else if (item is { SuppressDefaultInitialization: true, IsAssignable: false })
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SuppressDefaultInitializationMustBeSettable, item.GetLocation(syntax), Symbol.Name, item.Name));
+                    noError = false;
+                }
             }
         }
 
@@ -615,7 +620,7 @@ partial class MemberMeta
     public int Order { get; }
     public bool HasExplicitOrder { get; }
     public MemberKind Kind { get; }
-    public bool SkipOverwriteByDefault { get; }
+    public bool SuppressDefaultInitialization { get; }
 
     MemberMeta(int order)
     {
@@ -631,7 +636,7 @@ public MemberMeta(ISymbol symbol, IMethodSymbol? constructor, ReferenceSymbols r
         this.Symbol = symbol;
         this.Name = symbol.Name;
         this.Order = sequentialOrder;
-        this.SkipOverwriteByDefault = symbol.ContainsAttribute(references.SkipOverwriteDefaultAttribute);
+        this.SuppressDefaultInitialization = symbol.ContainsAttribute(references.SkipOverwriteDefaultAttribute);
         var orderAttr = symbol.GetAttribute(references.MemoryPackOrderAttribute);
         if (orderAttr != null)
         {

tests/MemoryPack.Tests/DefaultValueTest.cs

@@ -5,24 +5,26 @@ namespace MemoryPack.Tests;
 public class DefaultValueTest
 {
     [Fact]
-    public void FieldDefaultValue()
+    public void SuppressDefaultInitialization()
     {
         var bin = MemoryPackSerializer.Serialize(new DefaultValuePlaceholder { X = 1 });
-        var expected = new FieldDefaultValue();
-        var deserializedValue = MemoryPackSerializer.Deserialize<FieldDefaultValue>(bin)!;
+        var expected = new HasDefaultValue();
+        var deserializedValue = MemoryPackSerializer.Deserialize<HasDefaultValue>(bin)!;
         deserializedValue.Y.Should().Be(default);
-        deserializedValue.Z.Should().Be(expected.Z);
-        deserializedValue.FromMethod.Should().Be(expected.FromMethod);
+        deserializedValue.Z.Should().Be(default);
+        deserializedValue.Y2.Should().Be(expected.Y2);
+        deserializedValue.Z2.Should().Be(expected.Z2);
     }
 
     [Fact]
-    public void PropertyDefaultValue()
+    public void SuppressDefaultInitialization_VersionTolerant()
     {
         var bin = MemoryPackSerializer.Serialize(new DefaultValuePlaceholder { X = 1 });
-        var expected = new PropertyDefaultValue();
-        var deserializedValue = MemoryPackSerializer.Deserialize<PropertyDefaultValue>(bin)!;
+        var expected = new HasDefaultValueWithVersionTolerant();
+        var deserializedValue = MemoryPackSerializer.Deserialize<HasDefaultValueWithVersionTolerant>(bin)!;
         deserializedValue.Y.Should().Be(default);
         deserializedValue.Z.Should().Be(expected.Z);
-        deserializedValue.FromMethod.Should().Be(expected.FromMethod);
+        deserializedValue.Y2.Should().Be(expected.Y2);
+        deserializedValue.Z2.Should().Be(expected.Z2);
     }
 }

tests/MemoryPack.Tests/GeneratorDiagnosticsTest.cs

@@ -640,6 +640,22 @@ public partial class Tester
     public bool B1 { get; set; }
 }
 
+""");
+    }
+
+    [Fact]
+    public void MEMPACK040_SuppressDefaultInitializationMustBeSettable()
+    {
+        Compile(40, """
+using MemoryPack;
+
+[MemoryPackable]
+public partial class Tester
+{
+    [SuppressDefaultInitialization]
+    public required int I1 { get; init; }
+}
+
 """);
     }
 }

tests/MemoryPack.Tests/Models/DefaultValues.cs

@@ -6,42 +6,32 @@ partial class DefaultValuePlaceholder
     public int X { get; set; }
 }
 
-static class StaticMethod
-{
-    public static int GetNumberCalls;
-
-    public static int GetNumber()
-    {
-        GetNumberCalls++;
-        return 100;
-    }
-}
-
-[MemoryPackable]
-partial class FieldDefaultValue
+[MemoryPackable(GenerateType.VersionTolerant, SerializeLayout.Sequential)]
+partial class HasDefaultValueWithVersionTolerant
 {
     public int X;
+
     public int Y = 12345;
+    public float Z { get; set; } = 678.9f;
 
     [SuppressDefaultInitialization]
-    public float Z = 678.9f;
+    public int Y2 = 12345;
 
     [SuppressDefaultInitialization]
-    public int FromMethod = StaticMethod.GetNumber();
+    public float Z2 { get; set; } = 678.9f;
 }
 
 [MemoryPackable]
-partial class PropertyDefaultValue
+partial class HasDefaultValue
 {
-    public int X { get; init; }
-    public int Y { get; set; } = 12345;
+    public int X;
 
-    [SuppressDefaultInitialization]
+    public int Y = 12345;
     public float Z { get; set; } = 678.9f;
 
     [SuppressDefaultInitialization]
-    public float W { get; init; } = 678.9f;
+    public int Y2 = 12345;
 
     [SuppressDefaultInitialization]
-    public int FromMethod { get; set; } = StaticMethod.GetNumber();
+    public float Z2 { get; set; } = 678.9f;
 }