Fixed bug in generated TypeDef IConvertible.ToType method

Author: dahall

CodeGen/Generator/TypeDefTemplate.cs

@@ -313,7 +313,7 @@ public readonly bool TryFormat(Span<char> destination, out int charsWritten, Rea
 	readonly float IConvertible.ToSingle(IFormatProvider? provider) => ((IConvertible)Value).ToSingle(provider);
 
 	/// <inheritdoc/>
-	readonly object IConvertible.ToType(Type conversionType, IFormatProvider? provider) => ((IConvertible)Value).ToType(conversionType, provider);
+	readonly object IConvertible.ToType(Type conversionType, IFormatProvider? provider) => conversionType == typeof(__TYPENAME__) ? this : ((IConvertible)Value).ToType(conversionType, provider);
 
 	/// <inheritdoc/>
 	readonly ushort IConvertible.ToUInt16(IFormatProvider? provider) => ((IConvertible)Value).ToUInt16(provider);

Core/ForwardDeclarations/WinDef/BOOL.cs

@@ -1,10 +1,9 @@
-using Vanara.Marshaler;
-using Vanara.PInvoke;
+using Vanara.PInvoke;
 
 namespace Vanara;
 
 /// <summary>Managed instance of the four-byte BOOL type.</summary>
-[TypeDef(typeof(uint), ConvertTo = typeof(bool), Excludes = ExcludeOptions.Numerics)]
+[TypeDef(typeof(uint), ConvertTo = typeof(bool), Excludes = ExcludeOptions.Numerics, GetConvValue = "value != 0", SetConvValue = "value ? True : False")]
 public partial struct BOOL
 {
 	internal const uint True = 1U;

UnitTests/Core/WinDef/BOOLTest.cs

@@ -1,10 +1,41 @@
 using NUnit.Framework;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Reflection;
 
 namespace Vanara.PInvoke.Tests;
 
 [TestFixture]
 public class BOOLTests
 {
+	private static readonly ConcurrentDictionary<Type, bool> cachedTypes = [];
+	private static bool IsUnmanagedType(Type t)
+	{
+		var result = false;
+		if (cachedTypes.TryGetValue(t, out bool value))
+			return value;
+		else if (t.IsPrimitive || t.IsPointer || t.IsEnum)
+			result = true;
+		else if (t.IsGenericType || !t.IsValueType)
+			result = false;
+		else
+			result = t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).All(x => IsUnmanagedType(x.FieldType));
+		cachedTypes[t] = result;
+		return result;
+	}
+
+	[Test]
+	public void IsUnmanagedTypeTest()
+	{
+		byte[] buffer = new byte[4];
+		Assert.That(IsUnmanagedType(typeof(BOOL)));
+		Assert.That(() => Marshal.StructureToPtr((object)new BOOL(true), Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0), false), Throws.Nothing);
+		Assert.That(buffer[0], Is.EqualTo(1));
+
+		Assert.That(IsUnmanagedType(typeof(BOOLEAN)));
+		Assert.That(IsUnmanagedType(typeof(VARIANT_BOOL)));
+	}
+
 	[Test]
 	public void BOOLTest()
 	{
@@ -74,6 +105,24 @@ public void BOOLIConvertibleTest()
 		Assert.That(Convert.ChangeType(b, typeof(bool)), Is.EqualTo(true));
 	}
 
+	[Test]
+	public void BOOLMemTest()
+	{
+		using SafeCoTaskMemStruct<BOOL> mem = (BOOL)true;
+	}
+
+	[Test]
+	public void BOOLEANMemTest()
+	{
+		using SafeCoTaskMemStruct<BOOLEAN> mem = (BOOLEAN)true;
+	}
+
+	[Test]
+	public void VARIANT_BOOLMemTest()
+	{
+		using SafeCoTaskMemStruct<VARIANT_BOOL> mem = (VARIANT_BOOL)true;
+	}
+
 	[Test]
 	public void BOOLEANTest()
 	{