Add support for generic jsonDerivedAttribute (#32)

* Add generic JsonDerivedTypeAttribute

* Parse generic JsonDerivedTypeAttribute

* Update tests

* Add GenericAttributeWorks

* Use generic JsonDerivedType in Target tests

* Update Readme

README.md

@@ -50,6 +50,7 @@ using Aviationexam.GeneratedJsonConverters.Attributes;
 [JsonPolymorphic] // notice, that attributes are from `Aviationexam.GeneratedJsonConverters.Attributes` namespace, not `System.Text.Json.Serialization`
 [JsonDerivedType(typeof(LeafContract), typeDiscriminator: nameof(LeafContract))]
 [JsonDerivedType(typeof(AnotherLeafContract), typeDiscriminator: 2)]
+[JsonDerivedType<GenericLeafContract>(typeDiscriminator: nameof(GenericLeafContract))]
 public abstract class BaseContract
 {
     public int BaseProperty { get; set; }
@@ -62,6 +63,10 @@ public sealed class AnotherLeafContract : BaseContract
 {
     public int AnotherLeafProperty { get; set; }
 }
+public sealed class GenericLeafContract : BaseContract
+{
+    public int Property { get; set; }
+}
 
 [EnumJsonConverter] // this use project defined configuration
 public enum EMyEnum
@@ -97,6 +102,7 @@ using System.Text.Json.Serialization;
 [JsonSerializable(typeof(BaseContract))] // this line is neccesary, generator searches for JsonSerializableAttribute with argument type decorated by JsonPolymorphicAttribute
 [JsonSerializable(typeof(LeafContract))] // notice, it's necessary to specify leaf types
 [JsonSerializable(typeof(AnotherLeafContract))]
+[JsonSerializable(typeof(GenericLeafContract))]
 
 [JsonSerializable(typeof(EMyEnum))] // only necessary for not referenced enums from other contracts
 [JsonSerializable(typeof(EMyEnumWithExplicitConfiguration))]

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Target.Tests/BaseContractSerializationTests.cs

@@ -30,6 +30,11 @@ public void DeserializeBaseContractWorks(string json, Type targetType)
         {
             Assert.Equal(2, anotherLeafContract.AnotherLeafProperty);
         }
+
+        if (baseContract is GenericLeafContract genericLeafContract)
+        {
+            Assert.Equal(2, genericLeafContract.Property);
+        }
     }
 
     [Theory]
@@ -118,6 +123,18 @@ public static IEnumerable<object[]> BaseJsonContractData()
             """,
             typeof(AnotherLeafContract),
         };
+        yield return new object[]
+        {
+            // language=json
+            """
+            {
+                "baseProperty": 1,
+                "property": 2,
+                "$type": "GenericLeafContract"
+            }
+            """,
+            typeof(GenericLeafContract),
+        };
     }
 
     public static IEnumerable<object[]> LeafContractData()
@@ -154,5 +171,21 @@ public static IEnumerable<object[]> LeafContractData()
             }
             """.Replace("\r\n", Environment.NewLine)
         };
+        yield return new object[]
+        {
+            new GenericLeafContract
+            {
+                BaseProperty = 1,
+                Property = 2
+            },
+            // language=json
+            """
+            {
+              "$type": "GenericLeafContract",
+              "property": 2,
+              "baseProperty": 1
+            }
+            """.Replace("\r\n", Environment.NewLine)
+        };
     }
 }

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Target/Contracts/BaseContract.cs

@@ -5,6 +5,7 @@ namespace Aviationexam.GeneratedJsonConverters.SourceGenerator.Target.Contracts;
 [JsonPolymorphic]
 [JsonDerivedType(typeof(LeafContract), typeDiscriminator: nameof(LeafContract))]
 [JsonDerivedType(typeof(AnotherLeafContract), typeDiscriminator: 2)]
+[JsonDerivedType<GenericLeafContract>(typeDiscriminator: nameof(GenericLeafContract))]
 public abstract class BaseContract
 {
     public int BaseProperty { get; set; }

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Target/Contracts/GenericLeafContract.cs

@@ -0,0 +1,6 @@
+namespace Aviationexam.GeneratedJsonConverters.SourceGenerator.Target.Contracts;
+
+public sealed class GenericLeafContract : BaseContract
+{
+    public int Property { get; set; }
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Target/MyJsonSerializerContext.cs

@@ -13,6 +13,7 @@ namespace Aviationexam.GeneratedJsonConverters.SourceGenerator.Target;
 [JsonSerializable(typeof(BaseContract))]
 [JsonSerializable(typeof(LeafContract))]
 [JsonSerializable(typeof(AnotherLeafContract))]
+[JsonSerializable(typeof(GenericLeafContract))]
 [JsonSerializable(typeof(BaseContractWithCustomDelimiter))]
 [JsonSerializable(typeof(LeafContractWithCustomDelimiter))]
 [JsonSerializable(typeof(EBackingEnum))]

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.CustomDiscriminatorWorks#JsonDerivedTypeAttribute.g.verified.cs

@@ -53,3 +53,33 @@ public JsonDerivedTypeAttribute(System.Type derivedType, int typeDiscriminator)
     /// </summary>
     public object? TypeDiscriminator { get; }
 }
+
+[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
+internal class JsonDerivedTypeAttribute<TDerivedType> : JsonDerivedTypeAttribute
+{
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared based type.</param>
+    public JsonDerivedTypeAttribute() : base(typeof(TDerivedType))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(string typeDiscriminator) : base(typeof(TDerivedType), typeDiscriminator)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(int typeDiscriminator) : base(typeof(TDerivedType), typeDiscriminator)
+    {
+    }
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.EmptyWorks#JsonDerivedTypeAttribute.g.verified.cs

@@ -53,3 +53,33 @@ public JsonDerivedTypeAttribute(System.Type derivedType, int typeDiscriminator)
     /// </summary>
     public object? TypeDiscriminator { get; }
 }
+
+[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
+internal class JsonDerivedTypeAttribute<TDerivedType> : JsonDerivedTypeAttribute
+{
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared based type.</param>
+    public JsonDerivedTypeAttribute() : base(typeof(TDerivedType))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(string typeDiscriminator) : base(typeof(TDerivedType), typeDiscriminator)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(int typeDiscriminator) : base(typeof(TDerivedType), typeDiscriminator)
+    {
+    }
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.GenericAttributeWorks#BaseContractOfInt32JsonPolymorphicConverter.g.verified.cs

@@ -0,0 +1,35 @@
+//HintName: BaseContractOfInt32JsonPolymorphicConverter.g.cs
+#nullable enable
+
+namespace ApplicationNamespace;
+
+internal class BaseContractOfInt32JsonPolymorphicConverter : Aviationexam.GeneratedJsonConverters.PolymorphicJsonConvertor<ApplicationNamespace.Contracts.BaseContract<System.Int32>>
+{
+    protected override System.ReadOnlySpan<byte> GetDiscriminatorPropertyName() => "myCustomDiscriminator"u8;
+
+    protected override System.Type GetTypeForDiscriminator(
+        Aviationexam.GeneratedJsonConverters.IDiscriminatorStruct discriminator
+    ) => discriminator switch
+    {
+        Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string> { Value: "IntLeafContract" } => typeof(ApplicationNamespace.Contracts.IntLeafContract),
+        Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string> { Value: "StringLeafContract" } => typeof(ApplicationNamespace.Contracts.StringLeafContract),
+
+        _ => throw new System.ArgumentOutOfRangeException(nameof(discriminator), discriminator, null),
+    };
+
+    protected override Aviationexam.GeneratedJsonConverters.IDiscriminatorStruct GetDiscriminatorForType(
+        System.Type type
+    )
+    {
+        if (type == typeof(ApplicationNamespace.Contracts.IntLeafContract))
+        {
+            return new Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string>("IntLeafContract");
+        }
+        if (type == typeof(ApplicationNamespace.Contracts.StringLeafContract))
+        {
+            return new Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string>("StringLeafContract");
+        }
+
+        throw new System.ArgumentOutOfRangeException(nameof(type), type, null);
+    }
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.GenericAttributeWorks#BaseContractOfStringJsonPolymorphicConverter.g.verified.cs

@@ -0,0 +1,35 @@
+//HintName: BaseContractOfStringJsonPolymorphicConverter.g.cs
+#nullable enable
+
+namespace ApplicationNamespace;
+
+internal class BaseContractOfStringJsonPolymorphicConverter : Aviationexam.GeneratedJsonConverters.PolymorphicJsonConvertor<ApplicationNamespace.Contracts.BaseContract<System.String>>
+{
+    protected override System.ReadOnlySpan<byte> GetDiscriminatorPropertyName() => "myCustomDiscriminator"u8;
+
+    protected override System.Type GetTypeForDiscriminator(
+        Aviationexam.GeneratedJsonConverters.IDiscriminatorStruct discriminator
+    ) => discriminator switch
+    {
+        Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string> { Value: "IntLeafContract" } => typeof(ApplicationNamespace.Contracts.IntLeafContract),
+        Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string> { Value: "StringLeafContract" } => typeof(ApplicationNamespace.Contracts.StringLeafContract),
+
+        _ => throw new System.ArgumentOutOfRangeException(nameof(discriminator), discriminator, null),
+    };
+
+    protected override Aviationexam.GeneratedJsonConverters.IDiscriminatorStruct GetDiscriminatorForType(
+        System.Type type
+    )
+    {
+        if (type == typeof(ApplicationNamespace.Contracts.IntLeafContract))
+        {
+            return new Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string>("IntLeafContract");
+        }
+        if (type == typeof(ApplicationNamespace.Contracts.StringLeafContract))
+        {
+            return new Aviationexam.GeneratedJsonConverters.DiscriminatorStruct<string>("StringLeafContract");
+        }
+
+        throw new System.ArgumentOutOfRangeException(nameof(type), type, null);
+    }
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.GenericAttributeWorks#DiscriminatorStruct.g.verified.cs

@@ -0,0 +1,16 @@
+//HintName: DiscriminatorStruct.g.cs
+// ReSharper disable once RedundantNullableDirective
+
+#nullable enable
+
+namespace Aviationexam.GeneratedJsonConverters;
+
+internal readonly struct DiscriminatorStruct<T> : IDiscriminatorStruct
+{
+    public T Value { get; init; }
+
+    public DiscriminatorStruct(T value)
+    {
+        Value = value;
+    }
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.GenericAttributeWorks#IDiscriminatorStruct.g.verified.cs

@@ -0,0 +1,10 @@
+//HintName: IDiscriminatorStruct.g.cs
+// ReSharper disable once RedundantNullableDirective
+
+#nullable enable
+
+namespace Aviationexam.GeneratedJsonConverters;
+
+internal interface IDiscriminatorStruct
+{
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.GenericAttributeWorks#JsonDerivedTypeAttribute.g.verified.cs

@@ -0,0 +1,85 @@
+//HintName: JsonDerivedTypeAttribute.g.cs
+#nullable enable
+
+namespace Aviationexam.GeneratedJsonConverters.Attributes;
+
+/// <summary>
+/// This is a copy of System.Text.Json.Serialization.JsonDerivedTypeAttribute.
+/// It's purpose is to replace this attribute to silence System.Text.Json.Serialization.Metadata.PolymorphicTypeResolver{ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata}
+///
+/// When placed on a type declaration, indicates that the specified subtype should be opted into polymorphic serialization.
+/// </summary>
+[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
+internal class JsonDerivedTypeAttribute : System.Text.Json.Serialization.JsonAttribute
+{
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared based type.</param>
+    public JsonDerivedTypeAttribute(System.Type derivedType)
+    {
+        DerivedType = derivedType;
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(System.Type derivedType, string typeDiscriminator)
+    {
+        DerivedType = derivedType;
+        TypeDiscriminator = typeDiscriminator;
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(System.Type derivedType, int typeDiscriminator)
+    {
+        DerivedType = derivedType;
+        TypeDiscriminator = typeDiscriminator;
+    }
+
+    /// <summary>
+    /// A derived type that should be supported in polymorphic serialization of the declared base type.
+    /// </summary>
+    public System.Type DerivedType { get; }
+
+    /// <summary>
+    /// The type discriminator identifier to be used for the serialization of the subtype.
+    /// </summary>
+    public object? TypeDiscriminator { get; }
+}
+
+[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
+internal class JsonDerivedTypeAttribute<TDerivedType> : JsonDerivedTypeAttribute
+{
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared based type.</param>
+    public JsonDerivedTypeAttribute() : base(typeof(TDerivedType))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(string typeDiscriminator) : base(typeof(TDerivedType), typeDiscriminator)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new attribute with specified parameters.
+    /// </summary>
+    /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
+    /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
+    public JsonDerivedTypeAttribute(int typeDiscriminator) : base(typeof(TDerivedType), typeDiscriminator)
+    {
+    }
+}

src/Aviationexam.GeneratedJsonConverters.SourceGenerator.Tests/JsonPolymorphicConverterGeneratorSnapshotTests.GenericAttributeWorks#JsonPolymorphicAttribute.g.verified.cs

@@ -0,0 +1,32 @@
+//HintName: JsonPolymorphicAttribute.g.cs
+#nullable enable
+
+namespace Aviationexam.GeneratedJsonConverters.Attributes;
+
+/// <summary>
+/// This is a copy of System.Text.Json.Serialization.JsonPolymorphicAttribute.
+/// It's purpose is to replace this attribute to silence System.Text.Json.Serialization.Metadata.PolymorphicTypeResolver{ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata}
+///
+/// When placed on a type, indicates that the type should be serialized polymorphically.
+/// </summary>
+[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple = false, Inherited = false)]
+internal sealed class JsonPolymorphicAttribute : System.Text.Json.Serialization.JsonAttribute
+{
+    /// <summary>
+    /// Gets or sets a custom type discriminator property name for the polymorhic type.
+    /// Uses the default '$type' property name if left unset.
+    /// </summary>
+    public string? TypeDiscriminatorPropertyName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the behavior when serializing an undeclared derived runtime type.
+    /// </summary>
+    public System.Text.Json.Serialization.JsonUnknownDerivedTypeHandling UnknownDerivedTypeHandling { get; set; }
+
+    /// <summary>
+    /// When set to <see langword="true"/>, instructs the deserializer to ignore any
+    /// unrecognized type discriminator id's and reverts to the contract of the base type.
+    /// Otherwise, it will fail the deserialization.
+    /// </summary>
+    public bool IgnoreUnrecognizedTypeDiscriminators { get; set; }
+}