JSON: refactor metadata about types and member to use Flags instead a set of booleans

- user a single Flags enum to store most boolean properties on the type itself - add a "SoruceGenerated" flag to detect dynamic vs generated types

Author: KrzysFR

Doxense.Core/Serialization/JSON/CrystalJsonParser.cs

@@ -442,7 +442,7 @@ internal static bool TryParseMicrosoftDateTime(ReadOnlySpan<char> value, out Dat
 throw JsonBindingException.CannotDeserializeCustomTypeNoTypeDefinition(data, type);
 }
 
-if (typeDef.IsPolymorphic())
+if (typeDef.IsPolymorphic)
 {
 var discriminator = data[typeDef.TypeDiscriminatorProperty?.Value ?? "$type"];
 
@@ -506,7 +506,7 @@ internal static bool TryParseMicrosoftDateTime(ReadOnlySpan<char> value, out Dat
 foreach (var member in typeDef.Members)
 {
 // skip readonly members
-if (member.ReadOnly) continue;
+if (member.IsReadOnly) continue;
 
 // do we have a value for this field?
 if (!data.TryGetValue(member.Name, out var child) 

Doxense.Core/Serialization/JSON/CrystalJsonSettings.cs

@@ -26,6 +26,7 @@
 
 namespace Doxense.Serialization.Json
 {
+using System.Collections.Frozen;
 using System.Text;
 using Doxense.Collections.Caching;
 
@@ -740,7 +741,7 @@ static CrystalJsonSettings()
 var s2 = new CrystalJsonSettings(s.Flags | OptionFlags.EnumsAsString);
 defaults[(int) s2.Flags] = s2;
 }
-Cached = new(defaults, valueFactory: (v) => new((OptionFlags) v));
+Cached = new(defaults.ToFrozenDictionary(), valueFactory: (v) => new((OptionFlags) v));
 }
 
 internal static CrystalJsonSettings Create(OptionFlags flags) => Cached.GetOrAdd((int) flags);

Doxense.Core/Serialization/JSON/Reflection/CrystalJsonMemberDefinition.cs

@@ -26,7 +26,18 @@
 
 namespace Doxense.Serialization.Json
 {
-using System.Reflection;
+[Flags]
+public enum CrystalJsonMemberFlags
+{
+None = 0,
+SourceGenerated = 1 << 0,
+NotNull = 1 << 1,
+NonZeroDefault = 1 << 2,
+ReadOnly = 1 << 3,
+InitOnly = 1 << 4,
+Required = 1 << 5,
+Key = 1 << 6,
+}
 
 /// <summary>Structure that holds the cached serialization metadata for a field or property of a class or struct</summary>
 [DebuggerDisplay("Name={Name}, Type={Type}")]
@@ -44,22 +55,22 @@ public sealed record CrystalJsonMemberDefinition
 /// <remarks>Represent the original name in the c# code, while <see cref="Name"/> is the name in the JSON object</remarks>
 public required string OriginalName { get; init; }
 
+/// <summary>Flags for this member</summary>
+/// <returns>The flags are used by the various helper properties like <see cref="IsReadOnly"/>, <see cref="IsReadOnly"/> and so on</returns>
+public required CrystalJsonMemberFlags Flags { get; init; }
+
 /// <summary>Optional <see cref="JsonPropertyAttribute"/> attribute that was applied to this member</summary>
 public JsonPropertyAttribute? Attributes { get; init; }
-
-/// <summary>Original <see cref="PropertyInfo"/> or <see cref="FieldInfo"/> of the member in its declaring type</summary>
-public required MemberInfo Member { get; init; }
+//REVIEW: this is only used by the writer to "remember" how to format enums inside a Dictionary (attribute set on the property that holds the dictionary)
+//TODO: get rid of this, and expose the settings directly on this type?
 
 /// <summary>If <see langword="true"/>, the field has a <see cref="DefaultValue"/> that is not the default for this type.</summary>
 /// <remarks>This is <see langword="false"/> if the default is <see langword="null"/>, <see langword="false"/>, <see langword="0"/>, etc...</remarks>
-public bool HasDefaultValue { get; init; }
+public bool HasDefaultValue => this.Flags.HasFlag(CrystalJsonMemberFlags.NonZeroDefault);
 
 /// <summary>Default value for this member (when it is missing)</summary>
 public object? DefaultValue { get; init; }
 
-/// <summary>Flag set to <see langword="true"/> when the member is read-only or init-only</summary>
-public bool ReadOnly { get; init; }
-
 /// <summary>Func that can return the value of this member in an instance of the containing type</summary>
 public required Func<object, object?> Getter { get; init; }
 
@@ -86,34 +97,8 @@ public sealed record CrystalJsonMemberDefinition
 /// </code></remarks>
 public Type? NullableOfType { get; init; }
 
-/// <summary>The member cannot be null, or is annotated with <see cref="System.Diagnostics.CodeAnalysis.NotNullAttribute"/></summary>
-/// <remarks>Examples: <code>
-/// int Foo { get; ... } // IsNotNull == true
-/// int? Foo { get; ... } // IsNotNull == false
-/// string Foo { get; ... } // IsNotNull == true
-/// string? Foo { get; ... } // IsNotNull == false
-/// </code></remarks>
-public bool IsNotNull { get; init; }
-
-/// <summary>The member if a reference type that is declared as nullable in its parent type</summary>
-/// <remarks>Examples: <code>
-/// int Foo { get; ... } // IsNullableRefType == false
-/// int? Foo { get; ... } // IsNullableRefType == false
-/// string Foo { get; ... } // IsNullableRefType == false
-/// string? Foo { get; ... } // IsNullableRefType == true
-/// </code></remarks>
-public bool IsNullableRefType => !this.IsNotNull && this.NullableOfType == null;
-
-/// <summary>The member if a nullable value type</summary>
-/// <remarks>Examples: <code>
-/// int Foo { get; ... } // IsNullableValueType == false
-/// int? Foo { get; ... } // IsNullableValueType == true
-/// string Foo { get; ... } // IsNullableValueType == false
-/// string? Foo { get; ... } // IsNullableValueType == false
-/// </code></remarks>
-public bool IsNullableValueType => this.NullableOfType != null;
-
-public bool IsNonNullableValueType => this.NullableOfType == null && this.Type.IsValueType;
+/// <summary>Flag set to <see langword="true"/> when the member is read-only or init-only</summary>
+public bool IsReadOnly => this.Flags.HasFlag(CrystalJsonMemberFlags.ReadOnly);
 
 /// <summary>The member has the required keyword and cannot be null</summary>
 /// <remarks>Examples: <code>
@@ -124,7 +109,7 @@ public sealed record CrystalJsonMemberDefinition
 /// required int Foo { get; ... } // IsRequired == true
 /// required string Foo { get; ... } // IsRequired == true
 /// </code></remarks>
-public bool IsRequired { get; init; }
+public bool IsRequired => this.Flags.HasFlag(CrystalJsonMemberFlags.Required);
 
 /// <summary>The member has the <see cref="System.ComponentModel.DataAnnotations.KeyAttribute"/> attribute</summary>
 /// <remarks>Examples: <code>
@@ -133,7 +118,7 @@ public sealed record CrystalJsonMemberDefinition
 /// [Key]
 /// int Id { get; ... } // IsKey == true
 /// </code></remarks>
-public bool IsKey { get; init; }
+public bool IsKey => this.Flags.HasFlag(CrystalJsonMemberFlags.Key);
 
 /// <summary>The member is a read-only field, or a property with an init-only setter</summary>
 /// <remarks>Examples: <code>
@@ -144,7 +129,36 @@ public sealed record CrystalJsonMemberDefinition
 /// readonly int Id; // IsInitOnly == true
 /// int Id { get; init; } // IsInitOnly == true
 /// </code></remarks>
-public bool IsInitOnly { get; init; }
+public bool IsInitOnly => this.Flags.HasFlag(CrystalJsonMemberFlags.InitOnly);
+
+/// <summary>The member cannot be null, or is annotated with <see cref="System.Diagnostics.CodeAnalysis.NotNullAttribute"/></summary>
+/// <remarks>Examples: <code>
+/// int Foo { get; ... } // IsNotNull == true
+/// int? Foo { get; ... } // IsNotNull == false
+/// string Foo { get; ... } // IsNotNull == true
+/// string? Foo { get; ... } // IsNotNull == false
+/// </code></remarks>
+public bool IsNotNull => this.Flags.HasFlag(CrystalJsonMemberFlags.NotNull);
+
+/// <summary>The member if a reference type that is declared as nullable in its parent type</summary>
+/// <remarks>Examples: <code>
+/// int Foo { get; ... } // IsNullableRefType == false
+/// int? Foo { get; ... } // IsNullableRefType == false
+/// string Foo { get; ... } // IsNullableRefType == false
+/// string? Foo { get; ... } // IsNullableRefType == true
+/// </code></remarks>
+public bool IsNullableRefType => !this.IsNotNull && this.NullableOfType == null;
+
+/// <summary>The member if a nullable value type</summary>
+/// <remarks>Examples: <code>
+/// int Foo { get; ... } // IsNullableValueType == false
+/// int? Foo { get; ... } // IsNullableValueType == true
+/// string Foo { get; ... } // IsNullableValueType == false
+/// string? Foo { get; ... } // IsNullableValueType == false
+/// </code></remarks>
+public bool IsNullableValueType => this.NullableOfType != null;
+
+public bool IsNonNullableValueType => this.NullableOfType == null && this.Type.IsValueType;
 
 }
 

Doxense.Core/Serialization/JSON/Reflection/CrystalJsonTypeDefinition.cs

@@ -28,14 +28,28 @@ namespace Doxense.Serialization.Json
 {
 using System.Collections.Frozen;
 
-[DebuggerDisplay("Type={Type.Name}, ReqClass={RequiresClassAttribute}, IsAnonymousType={IsAnonymousType}, ClassId={ClassId}")]
+[Flags]
+public enum CrystalJsonTypeFlags
+{
+None = 0,
+SourceGenerated = 1 << 0,
+DefaultIsNull = 1 << 1,
+Polymorphic = 1 << 2,
+NonConstructible = 1 << 3,
+Sealed = 1 << 4,
+Anonymous = 1 << 5,
+}
+
+[DebuggerDisplay("Type={Type.FullName}")]
 [PublicAPI]
 public sealed record CrystalJsonTypeDefinition
 {
 
 /// <summary>Type of the object</summary>
 public Type Type { get; init; }
 
+public CrystalJsonTypeFlags Flags { get; init; }
+
 public Type? BaseType { get; init; }
 
 public JsonEncodedPropertyName? TypeDiscriminatorProperty { get; init; }
@@ -46,18 +60,6 @@ public sealed record CrystalJsonTypeDefinition
 /// <summary>Custom ClassId for this type</summary>
 public FrozenDictionary<JsonValue, Type>? DerivedTypeMap { get; init; }
 
-/// <summary>Specifies if this is an anonymous type that does not have a valid name</summary>
-/// <remarks>ex: <c>CrystalJson.Serialize(new { "Hello": "World" })</c></remarks>
-public bool IsAnonymousType { get; init; }
-
-/// <summary>Specifies if the type cannot possibly be derived (sealed class, or value type)</summary>
-/// <remarks>If <see langword="false"/>, a type-check will have to be performed during serialization, which add some overhead</remarks>
-public bool IsSealed { get; init; }
-
-/// <summary>Types with a default value that is <see langword="null"/></summary>
-/// <remarks><see langword="true"/> for Reference Types, or for <see cref="Nullable{T}"/>.</remarks>
-public bool DefaultIsNull { get; init; }
-
 /// <summary>Specifies if the type can have a value of <see langword="null"/> (ref types, or <see cref="Nullable{T}"/>)</summary>
 public Type? NullableOfType { get; init; }
 
@@ -70,30 +72,48 @@ public sealed record CrystalJsonTypeDefinition
 /// <summary>Definitions of the fields and properties of this type</summary>
 public CrystalJsonMemberDefinition[] Members { get; init; }
 
-public CrystalJsonTypeDefinition(Type type, CrystalJsonTypeBinder? customBinder, Func<object>? generator, CrystalJsonMemberDefinition[] members, Type? baseType, JsonEncodedPropertyName? typeDiscriminatorProperty, JsonValue? typeDiscriminatorValue, FrozenDictionary<JsonValue, Type>? derivedTypeMap)
+public CrystalJsonTypeDefinition(Type type, CrystalJsonTypeFlags flags, CrystalJsonTypeBinder? customBinder, Func<object>? generator, CrystalJsonMemberDefinition[] members, Type? baseType, JsonEncodedPropertyName? typeDiscriminatorProperty, JsonValue? typeDiscriminatorValue, IReadOnlyDictionary<JsonValue, Type>? derivedTypeMap)
 {
 Contract.NotNull(type);
 Contract.NotNull(members);
 
-//// If not provided, generate a type name that looks like "Namespace.ClassName, AssemblyName", which is the format expected by Type.GetType(..)
-//classId ??= type.GetAssemblyName();
+var nullableOfType = CrystalJsonTypeResolver.GetNullableType(type);
+
+if (type.IsAnonymousType()) flags |= CrystalJsonTypeFlags.Anonymous;
+if (type.IsSealed) flags |= CrystalJsonTypeFlags.Sealed;
+if (!type.IsValueType || nullableOfType != null) flags |= CrystalJsonTypeFlags.Sealed;
+if (type.IsInterface || type.IsAbstract) flags |= CrystalJsonTypeFlags.NonConstructible;
+if (typeDiscriminatorProperty != null) flags |= CrystalJsonTypeFlags.Polymorphic;
 
 this.Type = type;
+this.Flags = flags;
 this.BaseType = baseType;
 this.TypeDiscriminatorProperty = typeDiscriminatorProperty;
 this.TypeDiscriminatorValue = typeDiscriminatorValue;
-this.DerivedTypeMap = derivedTypeMap;
-this.IsAnonymousType = type.IsAnonymousType();
-this.IsSealed = CrystalJsonTypeResolver.IsSealedType(type);
-this.NullableOfType = CrystalJsonTypeResolver.GetNullableType(type);
-this.DefaultIsNull = !type.IsValueType || this.NullableOfType != null;
-//this.RequiresClassAttribute = (type.IsInterface || type.IsAbstract) && !this.IsAnonymousType;
+this.DerivedTypeMap = derivedTypeMap?.ToFrozenDictionary();
+this.NullableOfType = nullableOfType;
 this.CustomBinder = customBinder;
 this.Generator = generator;
 this.Members = members;
 }
 
-public bool IsPolymorphic() => this.TypeDiscriminatorProperty != null;
+public bool IsPolymorphic => this.Flags.HasFlag(CrystalJsonTypeFlags.Polymorphic);
+
+/// <summary>Specifies if this is an anonymous type that does not have a valid name</summary>
+/// <remarks>ex: <c>CrystalJson.Serialize(new { "Hello": "World" })</c></remarks>
+public bool IsAnonymousType => this.Flags.HasFlag(CrystalJsonTypeFlags.Anonymous);
+
+/// <summary>Specifies if the type cannot possibly be derived (sealed class, or value type)</summary>
+/// <remarks>If <see langword="false"/>, a type-check will have to be performed during serialization, which add some overhead</remarks>
+public bool IsSealed => this.Flags.HasFlag(CrystalJsonTypeFlags.Sealed);
+
+/// <summary>Types with a default value that is <see langword="null"/></summary>
+/// <remarks><see langword="true"/> for Reference Types, or for <see cref="Nullable{T}"/>.</remarks>
+public bool DefaultIsNull => this.Flags.HasFlag(CrystalJsonTypeFlags.DefaultIsNull);
+
+/// <summary>Specifies if the type cannot be constructed directly (interface, abstract class, no public ctor, ...)</summary>
+/// <remarks><see langword="true"/> for interfaces or abstract types</remarks>
+public bool IsNonConstructible => this.Flags.HasFlag(CrystalJsonTypeFlags.NonConstructible);
 
 }