Throw TomlException for invalid polymorphism configuration

Author: xoofx

src/Tomlyn.Tests/NewApiPolymorphismValidationTests.cs

@@ -0,0 +1,53 @@
+using NUnit.Framework;
+using Tomlyn.Serialization;
+
+namespace Tomlyn.Tests;
+
+public sealed class NewApiPolymorphismValidationTests
+{
+    [TomlPolymorphic]
+    [TomlDerivedType(typeof(DerivedEmptyDiscriminator), "")]
+    private abstract class BaseEmptyDiscriminator
+    {
+    }
+
+    private sealed class DerivedEmptyDiscriminator : BaseEmptyDiscriminator
+    {
+        public int Value { get; set; } = 1;
+    }
+
+    [TomlPolymorphic]
+    [TomlDerivedType(typeof(string), "x")]
+    private abstract class BaseNotAssignable
+    {
+    }
+
+    private sealed class DerivedNotAssignable : BaseNotAssignable
+    {
+        public int Value { get; set; } = 1;
+    }
+
+    [Test]
+    public void TomlDerivedType_EmptyDiscriminator_ThrowsTomlException()
+    {
+        Assert.Throws<TomlException>(() => TomlSerializer.Serialize<BaseEmptyDiscriminator>(new DerivedEmptyDiscriminator()));
+    }
+
+    [Test]
+    public void TomlDerivedType_NotAssignable_ThrowsTomlException()
+    {
+        Assert.Throws<TomlException>(() => TomlSerializer.Serialize<BaseNotAssignable>(new DerivedNotAssignable()));
+    }
+
+    [Test]
+    public void PolymorphismOptions_EmptyDiscriminatorPropertyName_ThrowsTomlException()
+    {
+        var options = TomlSerializerOptions.Default with
+        {
+            PolymorphismOptions = new TomlPolymorphismOptions { TypeDiscriminatorPropertyName = "" },
+        };
+
+        Assert.Throws<TomlException>(() => TomlSerializer.Serialize<BaseNotAssignable>(new DerivedNotAssignable(), options));
+    }
+}
+

src/Tomlyn/Serialization/Internal/TomlPolymorphicTypeInfo.cs

@@ -74,7 +74,7 @@ public static TomlTypeInfo TryWrap(TomlTypeInfo typeInfo)
 
         if (string.IsNullOrEmpty(discriminatorPropertyName))
         {
-            throw new InvalidOperationException($"Polymorphic type '{type.FullName}' must specify a discriminator property name.");
+            throw new TomlException($"Polymorphic type '{type.FullName}' must specify a discriminator property name.");
         }
 
         var derivedByDiscriminator = new Dictionary<string, Type>(StringComparer.Ordinal);
@@ -131,22 +131,22 @@ private static void AddDerivedType(
 
         if (discriminator.Length == 0)
         {
-            throw new InvalidOperationException($"Derived type discriminator for base '{baseType.FullName}' cannot be empty.");
+            throw new TomlException($"Derived type discriminator for base '{baseType.FullName}' cannot be empty.");
         }
 
         if (!baseType.IsAssignableFrom(derivedType))
         {
-            throw new InvalidOperationException($"Derived type '{derivedType.FullName}' is not assignable to base type '{baseType.FullName}'.");
+            throw new TomlException($"Derived type '{derivedType.FullName}' is not assignable to base type '{baseType.FullName}'.");
         }
 
         if (derivedTypeByDiscriminator.ContainsKey(discriminator))
         {
-            throw new InvalidOperationException($"Multiple derived types are registered with discriminator '{discriminator}' for base '{baseType.FullName}'.");
+            throw new TomlException($"Multiple derived types are registered with discriminator '{discriminator}' for base '{baseType.FullName}'.");
         }
 
         if (discriminatorByDerivedType.ContainsKey(derivedType))
         {
-            throw new InvalidOperationException($"Derived type '{derivedType.FullName}' is registered multiple times for base '{baseType.FullName}'.");
+            throw new TomlException($"Derived type '{derivedType.FullName}' is registered multiple times for base '{baseType.FullName}'.");
         }
 
         derivedTypeByDiscriminator.Add(discriminator, derivedType);