order impl complete

neuecc · neuecc · commit 34a7e876d85d · 2022-10-02T08:47:50.000+09:00
diff --git a/README.md b/README.md
@@ -126,7 +126,7 @@ All members must be memorypack-serializable, if not, code generator reports erro
 
 ![image](https://user-images.githubusercontent.com/46207/192413557-8a47d668-5339-46c5-a3da-a77841666f81.png)
 
-MemoryPack has 24 diagnostics rules(`MEMPACK001` to `MEMPACK024`) to be define comfortably.
+MemoryPack has 24 diagnostics rules(`MEMPACK001` to `MEMPACK026`) to be define comfortably.
 
 If target type is defined MemoryPack serialization externally and registered, use `[MemoryPackAllowSerialize]` to silent diagnostics.
 
@@ -141,6 +141,20 @@ public partial class Sample2
 
 Member order is **important**, MemoryPack does not serialize any member-name and other tags, serialize in the declared order. If the type is inherited, serialize in the order of parent → child. Member orders can not change for the deserialization. For the schema evolution, see [Version tolerant](#version-tolerant)  section.
 
+Default order is sequential but you can choose explicit layout with `[MemoryPackable(SerializeLayout.Explicit)]` and `[MemoryPackOrder()]`.
+
+```csharp
+// serialize Prop0 -> Prop1
+[MemoryPackable(SerializeLayout.Explicit)]
+public partial class SampleExplicitOrder
+{
+    [MemoryPackOrder(1)]
+    public int Prop1 { get; set; }
+    [MemoryPackOrder(0)]
+    public int Prop0 { get; set; }
+}
+```
+
 ### Constructor selection
 
 MemoryPack supports parameterized constructor not only parameterless constructor. The selection of the constructor follows these rules. Both class and struct follows same.
diff --git a/sandbox/SandboxConsoleApp/ForReadMe.cs b/sandbox/SandboxConsoleApp/ForReadMe.cs
@@ -140,22 +140,11 @@ public partial class Version2
 }
 
 
-
-[MemoryPackable(GenerateType.Object)]
-public partial class Sonota1
-{
-
-}
-
-[MemoryPackable(SerializeLayout.Sequential)]
-public partial class Sonota2
-{
-
-}
-
-[MemoryPackable(GenerateType.Object, SerializeLayout.Explicit)]
-public partial class Sonota3
+[MemoryPackable(SerializeLayout.Explicit)]
+public partial class SampleExplicitOrder
 {
+    [MemoryPackOrder(1)]
+    public int Prop1 { get; set; }
     [MemoryPackOrder(0)]
-    public int MyProperty { get; set; }
+    public int Prop0 { get; set; }
 }
diff --git a/sandbox/SandboxConsoleApp/Program.cs b/sandbox/SandboxConsoleApp/Program.cs
@@ -20,8 +20,10 @@
 using System.Text;
 using System.Xml.Linq;
 
+var a = int.MaxValue;
+var b = ~a;
+Console.WriteLine(b);
 
-Console.WriteLine("foo");
 
 // ---
 
@@ -43,6 +45,33 @@
 
 
 
+[MemoryPackable(GenerateType.Object)]
+public partial class Sonota1
+{
+    // public NoSerializableObject? MyProperty { get; set; }
+}
+
+public class NoSerializableObject
+{
+
+}
+
+[MemoryPackable(SerializeLayout.Explicit)]
+public partial class Sonota2
+{
+    [MemoryPackOrder(1)]
+    public int MyProperty1 { get; set; }
+    [MemoryPackOrder(0)]
+    public int MyProperty2 { get; set; }
+}
+
+[MemoryPackable(GenerateType.Object, SerializeLayout.Explicit)]
+public partial class Sonota3
+{
+    [MemoryPackOrder(0)]
+    public int MyProperty { get; set; }
+}
+
 
 
 
diff --git a/src/MemoryPack.Core/Attributes.cs b/src/MemoryPack.Core/Attributes.cs
@@ -8,12 +8,16 @@ public sealed class MemoryPackableAttribute : Attribute
     public GenerateType GenerateType { get; }
     public SerializeLayout SerializeLayout { get; }
 
+    // ctor parameter count is used in MemoryPackGenerator.Parser TypeMeta for detect which ctor used.
+    // if modify ctor, be careful.
+
     public MemoryPackableAttribute(GenerateType generateType = GenerateType.Object, SerializeLayout serializeLayout = SerializeLayout.Sequential)
     {
         this.GenerateType = generateType;
         this.SerializeLayout = serializeLayout;
     }
 
+    // set SerializeLayout only allows Object
     public MemoryPackableAttribute(SerializeLayout serializeLayout)
     {
         this.GenerateType = GenerateType.Object;
diff --git a/src/MemoryPack.Generator/CoreEnums.cs b/src/MemoryPack.Generator/CoreEnums.cs
@@ -7,3 +7,9 @@ public enum GenerateType
     Collection,
     NoGenerate
 }
+
+public enum SerializeLayout
+{
+    Sequential, // default
+    Explicit
+}
diff --git a/src/MemoryPack.Generator/DiagnosticDescriptors.cs b/src/MemoryPack.Generator/DiagnosticDescriptors.cs
@@ -204,4 +204,20 @@ internal static class DiagnosticDescriptors
         category: Category,
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true);
+
+    public static readonly DiagnosticDescriptor AllMembersMustAnnotateOrder = new(
+        id: "MEMPACK025",
+        title: "All members must annotate MemoryPackOrder when SerializeLayout.Explicit",
+        messageFormat: "The MemoryPackable object '{0}' member '{1}' is not annotated MemoryPackOrder",
+        category: Category,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
+    public static readonly DiagnosticDescriptor AllMembersMustBeContinuousNumber = new(
+        id: "MEMPACK026",
+        title: "All MemoryPackOrder members must be continuous number from zero",
+        messageFormat: "The MemoryPackable object '{0}' member '{1}' is not continuous number from zero",
+        category: Category,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
 }
diff --git a/src/MemoryPack.Generator/MemoryPackGenerator.Parser.cs b/src/MemoryPack.Generator/MemoryPackGenerator.Parser.cs
@@ -1,6 +1,7 @@
 ﻿using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.ComponentModel;
 using System.Runtime.Serialization;
 using System.Text;
 
@@ -37,6 +38,7 @@ partial class TypeMeta
     readonly ReferenceSymbols reference;
     public INamedTypeSymbol Symbol { get; }
     public GenerateType GenerateType { get; }
+    public SerializeLayout SerializeLayout { get; }
     /// <summary>MinimallyQualifiedFormat(include generics T>)</summary>
     public string TypeName { get; }
     public MemberMeta[] Members { get; }
@@ -63,16 +65,24 @@ public TypeMeta(INamedTypeSymbol symbol, ReferenceSymbols reference)
         if (packableCtorArgs == null)
         {
             this.GenerateType = GenerateType.NoGenerate;
+            this.SerializeLayout = SerializeLayout.Sequential;
         }
         else if (packableCtorArgs.Value.Length != 0)
         {
-            // TODO: MemoryPackable has two attribtue
-            // (SerializeLayout serializeLayout)
-            // (GenerateType generateType = GenerateType.Object, SerializeLayout serializeLayout = SerializeLayout.Sequential)
-            // so check length first and choose which constructor used.
-            var ctorValue = packableCtorArgs.Value[0];
-            var generateType = ctorValue.Value ?? GenerateType.Object;
-            this.GenerateType = (GenerateType)generateType;
+            // MemoryPackable has two attribtue
+            if (packableCtorArgs.Value.Length == 1)
+            {
+                // (SerializeLayout serializeLayout)
+                var ctorValue = packableCtorArgs.Value[0];
+                this.SerializeLayout = (SerializeLayout)(ctorValue.Value ?? SerializeLayout.Sequential);
+                this.GenerateType = GenerateType.Object;
+            }
+            else
+            {
+                // (GenerateType generateType = GenerateType.Object, SerializeLayout serializeLayout = SerializeLayout.Sequential)
+                this.GenerateType = (GenerateType)(packableCtorArgs.Value[0].Value ?? GenerateType.Object);
+                this.SerializeLayout = (SerializeLayout)(packableCtorArgs.Value[1].Value ?? SerializeLayout.Sequential);
+            }
         }
 
         this.TypeName = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
@@ -101,8 +111,10 @@ public TypeMeta(INamedTypeSymbol symbol, ReferenceSymbols reference)
                 }
                 return true;
             })
-            .Select(x => new MemberMeta(x, Constructor, reference))
+            .Select((x, i) => new MemberMeta(x, Constructor, reference, i))
+            .OrderBy(x => x.Order)
             .ToArray();
+
         this.IsValueType = symbol.IsValueType;
         this.IsUnmanagedType = symbol.IsUnmanagedType;
         this.IsInterfaceOrAbstract = symbol.IsAbstract;
@@ -112,6 +124,7 @@ public TypeMeta(INamedTypeSymbol symbol, ReferenceSymbols reference)
         this.OnSerialized = CollectMethod(reference.MemoryPackOnSerializedAttribute, IsValueType);
         this.OnDeserializing = CollectMethod(reference.MemoryPackOnDeserializingAttribute, IsValueType);
         this.OnDeserialized = CollectMethod(reference.MemoryPackOnDeserializedAttribute, IsValueType);
+
         if (IsUnion)
         {
             this.UnionTags = symbol.GetAttributes()
@@ -271,7 +284,9 @@ public bool Validate(TypeDeclarationSyntax syntax, SourceProductionContext conte
             var allParameterExists = this.Constructor.Parameters.All(x => nameDict.Contains(x.Name));
             if (!allParameterExists)
             {
-                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.ConstructorHasNoMatchedParameter, syntax.Identifier.GetLocation(), Symbol.Name));
+                var location = Constructor.Locations.FirstOrDefault() ?? syntax.Identifier.GetLocation();
+
+                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.ConstructorHasNoMatchedParameter, location, Symbol.Name));
                 noError = false;
             }
         }
@@ -283,12 +298,12 @@ public bool Validate(TypeDeclarationSyntax syntax, SourceProductionContext conte
             {
                 // diagnostics location should be method identifier
                 // however methodsymbol -> methodsyntax is slightly hard so use type identifier instead.
-                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.OnMethodHasParameter, syntax.Identifier.GetLocation(), Symbol.Name, item.Name));
+                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.OnMethodHasParameter, item.GetLocation(syntax), Symbol.Name, item.Name));
                 noError = false;
             }
             if (IsUnmanagedType)
             {
-                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.OnMethodInUnamannagedType, syntax.Identifier.GetLocation(), Symbol.Name, item.Name));
+                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.OnMethodInUnamannagedType, item.GetLocation(syntax), Symbol.Name, item.Name));
                 noError = false;
             }
         }
@@ -304,8 +319,10 @@ public bool Validate(TypeDeclarationSyntax syntax, SourceProductionContext conte
                     var ignore = item.ContainsAttribute(reference.MemoryPackIgnoreAttribute);
                     if (include || ignore)
                     {
+                        var location = item.Locations.FirstOrDefault() ?? syntax.Identifier.GetLocation();
+
                         var attr = include ? "MemoryPackInclude" : "MemoryPackIgnore";
-                        context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.OverrideMemberCantAddAnnotation, syntax.Identifier.GetLocation(), Symbol.Name, item.Name, attr));
+                        context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.OverrideMemberCantAddAnnotation, location, Symbol.Name, item.Name, attr));
                         noError = false;
                     }
                 }
@@ -322,26 +339,57 @@ public bool Validate(TypeDeclarationSyntax syntax, SourceProductionContext conte
         // exists can't serialize member
         foreach (var item in Members)
         {
+
             if (item.Kind == MemberKind.NonSerializable)
             {
                 if (item.MemberType.SpecialType is SpecialType.System_Object or SpecialType.System_Array or SpecialType.System_Delegate or SpecialType.System_MulticastDelegate || item.MemberType.TypeKind == TypeKind.Delegate)
                 {
-                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.MemberCantSerializeType, syntax.Identifier.GetLocation(), Symbol.Name, item.Name, item.MemberType.FullyQualifiedToString()));
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.MemberCantSerializeType, item.GetLocation(syntax), Symbol.Name, item.Name, item.MemberType.FullyQualifiedToString()));
                     noError = false;
                 }
                 else
                 {
-                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.MemberIsNotMemoryPackable, syntax.Identifier.GetLocation(), Symbol.Name, item.Name, item.MemberType.FullyQualifiedToString()));
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.MemberIsNotMemoryPackable, item.GetLocation(syntax), Symbol.Name, item.Name, item.MemberType.FullyQualifiedToString()));
                     noError = false;
                 }
             }
             else if (item.Kind == MemberKind.RefLike)
             {
-                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.MemberIsRefStruct, syntax.Identifier.GetLocation(), Symbol.Name, item.Name, item.MemberType.FullyQualifiedToString()));
+                context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.MemberIsRefStruct, item.GetLocation(syntax), Symbol.Name, item.Name, item.MemberType.FullyQualifiedToString()));
                 noError = false;
             }
         }
 
+        // order
+        if (SerializeLayout == SerializeLayout.Explicit)
+        {
+            // All members must annotate MemoryPackOrder
+            foreach (var item in Members)
+            {
+                if (!item.HasExplicitOrder)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.AllMembersMustAnnotateOrder, item.GetLocation(syntax), Symbol.Name, item.Name));
+                    noError = false;
+                }
+            }
+
+            // Annotated MemoryPackOrder must be continuous number from zero.
+            if (noError)
+            {
+                var expectedOrder = 0;
+                foreach (var item in Members)
+                {
+                    if (item.Order != expectedOrder)
+                    {
+                        context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.AllMembersMustBeContinuousNumber, item.GetLocation(syntax), Symbol.Name, item.Name));
+                        noError = false;
+                        break;
+                    }
+                    expectedOrder++;
+                }
+            }
+        }
+
         // Union validations
         if (IsUnion)
         {
@@ -422,12 +470,26 @@ partial class MemberMeta
     public bool IsSettable { get; }
     public bool IsAssignable { get; }
     public bool IsConstructorParameter { get; }
+    public int Order { get; }
+    public bool HasExplicitOrder { get; }
     public MemberKind Kind { get; }
 
-    public MemberMeta(ISymbol symbol, IMethodSymbol? constructor, ReferenceSymbols references)
+    public MemberMeta(ISymbol symbol, IMethodSymbol? constructor, ReferenceSymbols references, int sequentialOrder)
     {
         this.Symbol = symbol;
         this.Name = symbol.Name;
+        this.Order = sequentialOrder;
+        var orderAttr = symbol.GetAttribute(references.MemoryPackOrderAttribute);
+        if (orderAttr != null)
+        {
+            this.Order = (int)(orderAttr.ConstructorArguments[0].Value ?? sequentialOrder);
+            this.HasExplicitOrder = true;
+
+        }
+        else
+        {
+            this.HasExplicitOrder = false;
+        }
 
         if (constructor != null)
         {
@@ -465,6 +527,12 @@ public MemberMeta(ISymbol symbol, IMethodSymbol? constructor, ReferenceSymbols r
         Kind = ParseMemberKind(symbol, MemberType, references);
     }
 
+    public Location GetLocation(TypeDeclarationSyntax fallback)
+    {
+        var location = Symbol.Locations.FirstOrDefault() ?? fallback.Identifier.GetLocation();
+        return location;
+    }
+
     static MemberKind ParseMemberKind(ISymbol? memberSymbol, ITypeSymbol memberType, ReferenceSymbols references)
     {
         if (memberType.SpecialType is SpecialType.System_Object or SpecialType.System_Array or SpecialType.System_Delegate or SpecialType.System_MulticastDelegate || memberType.TypeKind == TypeKind.Delegate)
@@ -587,4 +655,10 @@ public MethodMeta(IMethodSymbol symbol, bool isValueType)
         this.IsStatic = symbol.IsStatic;
         this.IsValueType = isValueType;
     }
+
+    public Location GetLocation(TypeDeclarationSyntax fallback)
+    {
+        var location = Symbol.Locations.FirstOrDefault() ?? fallback.Identifier.GetLocation();
+        return location;
+    }
 }
diff --git a/tests/MemoryPack.Tests/GeneratorDiagnosticsTest.cs b/tests/MemoryPack.Tests/GeneratorDiagnosticsTest.cs

Original file line number	Diff line number	Diff line change
`@@ -8,12 +8,16 @@ public sealed class MemoryPackableAttribute : Attribute`
`8`	`8`	`public GenerateType GenerateType { get; }`
`9`	`9`	`public SerializeLayout SerializeLayout { get; }`
`10`	`10`
	`11`	`+ // ctor parameter count is used in MemoryPackGenerator.Parser TypeMeta for detect which ctor used.`
	`12`	`+ // if modify ctor, be careful.`
	`13`	`+`
`11`	`14`	`public MemoryPackableAttribute(GenerateType generateType = GenerateType.Object, SerializeLayout serializeLayout = SerializeLayout.Sequential)`
`12`	`15`	`{`
`13`	`16`	`this.GenerateType = generateType;`
`14`	`17`	`this.SerializeLayout = serializeLayout;`
`15`	`18`	`}`
`16`	`19`
	`20`	`+ // set SerializeLayout only allows Object`
`17`	`21`	`public MemoryPackableAttribute(SerializeLayout serializeLayout)`
`18`	`22`	`{`
`19`	`23`	`this.GenerateType = GenerateType.Object;`