Fix casting for custom registered types

Author: maca88

src/NHibernate.DomainModel/NHSpecific/NullableInt32.cs

@@ -7,7 +7,7 @@ namespace NHibernate.DomainModel.NHSpecific
 	/// A nullable type that wraps an <see cref="Int32"/> value.
 	/// </summary>
 	[TypeConverter(typeof(NullableInt32Converter)), Serializable()]
-	public struct NullableInt32 : IFormattable, IComparable
+	public struct NullableInt32 : IFormattable, IComparable, IConvertible
 	{
 		public static readonly NullableInt32 Default = new NullableInt32();
 
@@ -234,5 +234,94 @@ public static NullableInt32 Parse(string s)
 		// TODO: implement the rest of the Parse overloads found in Int32
 
 		#endregion
+
+		#region IConvertible
+
+		public TypeCode GetTypeCode()
+		{
+			return _value.GetTypeCode();
+		}
+
+		public bool ToBoolean(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToBoolean(provider);
+		}
+
+		public char ToChar(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToChar(provider);
+		}
+
+		public sbyte ToSByte(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToSByte(provider);
+		}
+
+		public byte ToByte(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToByte(provider);
+		}
+
+		public short ToInt16(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToInt16(provider);
+		}
+
+		public ushort ToUInt16(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToUInt16(provider);
+		}
+
+		public int ToInt32(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToInt32(provider);
+		}
+
+		public uint ToUInt32(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToUInt32(provider);
+		}
+
+		public long ToInt64(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToInt64(provider);
+		}
+
+		public ulong ToUInt64(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToUInt64(provider);
+		}
+
+		public float ToSingle(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToSingle(provider);
+		}
+
+		public double ToDouble(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToDouble(provider);
+		}
+
+		public decimal ToDecimal(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToDecimal(provider);
+		}
+
+		public DateTime ToDateTime(IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToDateTime(provider);
+		}
+
+		public string ToString(IFormatProvider provider)
+		{
+			return _value.ToString(provider);
+		}
+
+		public object ToType(System.Type conversionType, IFormatProvider provider)
+		{
+			return ((IConvertible) _value).ToType(conversionType, provider);
+		}
+
+		#endregion
 	}
 }

src/NHibernate.Test/Async/Linq/SelectionTests.cs

@@ -11,7 +11,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using NHibernate.DomainModel.NHSpecific;
 using NHibernate.DomainModel.Northwind.Entities;
+using NHibernate.Type;
 using NUnit.Framework;
 using NHibernate.Linq;
 
@@ -453,6 +455,23 @@ public async Task CanSelectConditionalObjectAsync()
 			Assert.That(fatherIsKnown, Has.Exactly(1).With.Property("FatherIsKnown").True);
 		}
 
+		[Test]
+		public async Task CanCastToDerivedTypeAsync()
+		{
+			var dogs = await (db.Animals
+			                      .Where(a => ((Dog) a).Pregnant)
+			                      .Select(a => new {a.SerialNumber})
+			                      .ToListAsync());
+			Assert.That(dogs, Has.Exactly(1).With.Property("SerialNumber").Not.Null);
+		}
+
+		[Test]
+		public async Task CanCastToCustomRegisteredTypeAsync()
+		{
+			TypeFactory.RegisterType(typeof(NullableInt32), new NullableInt32Type(), Enumerable.Empty<string>());
+			Assert.That(await (db.Users.Where(o => (NullableInt32) o.Id == 1).ToListAsync()), Has.Count.EqualTo(1));
+		}
+
 		public class Wrapper<T>
 		{
 			public T item;

src/NHibernate.Test/Linq/SelectionTests.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using NHibernate.DomainModel.NHSpecific;
 using NHibernate.DomainModel.Northwind.Entities;
+using NHibernate.Type;
 using NUnit.Framework;
 
 namespace NHibernate.Test.Linq
@@ -492,6 +494,23 @@ public void CanSelectConditionalObject()
 			Assert.That(fatherIsKnown, Has.Exactly(1).With.Property("FatherIsKnown").True);
 		}
 
+		[Test]
+		public void CanCastToDerivedType()
+		{
+			var dogs = db.Animals
+			                      .Where(a => ((Dog) a).Pregnant)
+			                      .Select(a => new {a.SerialNumber})
+			                      .ToList();
+			Assert.That(dogs, Has.Exactly(1).With.Property("SerialNumber").Not.Null);
+		}
+
+		[Test]
+		public void CanCastToCustomRegisteredType()
+		{
+			TypeFactory.RegisterType(typeof(NullableInt32), new NullableInt32Type(), Enumerable.Empty<string>());
+			Assert.That(db.Users.Where(o => (NullableInt32) o.Id == 1).ToList(), Has.Count.EqualTo(1));
+		}
+
 		public class Wrapper<T>
 		{
 			public T item;

src/NHibernate/Hql/Ast/HqlTreeNode.cs

@@ -257,6 +257,30 @@ internal HqlIdent(IASTFactory factory, System.Type type)
 					throw new NotSupportedException(string.Format("Don't currently support idents of type {0}", type.Name));
 			}
 		}
+
+		internal static bool SupportsType(System.Type type)
+		{
+			type = type.UnwrapIfNullable();
+			switch (System.Type.GetTypeCode(type))
+			{
+				case TypeCode.Boolean:
+				case TypeCode.Int16:
+				case TypeCode.Int32:
+				case TypeCode.Int64:
+				case TypeCode.Decimal:
+				case TypeCode.Single:
+				case TypeCode.DateTime:
+				case TypeCode.String:
+				case TypeCode.Double:
+					return true;
+				default:
+					return new[]
+					{
+						typeof(Guid),
+						typeof(DateTimeOffset)
+					}.Contains(type);
+			}
+		}
 	}
 
 	public class HqlRange : HqlStatement

src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs

@@ -488,7 +488,7 @@ protected HqlTreeNode VisitUnaryExpression(UnaryExpression expression)
 					return IsCastRequired(expression.Operand, expression.Type, out var existType)
 						? _hqlTreeBuilder.Cast(VisitExpression(expression.Operand).AsExpression(), expression.Type)
 						// Make a transparent cast when an IType exists, so that it can be used to retrieve the value from the data reader
-						: existType
+						: existType && HqlIdent.SupportsType(expression.Type)
 							? _hqlTreeBuilder.TransparentCast(VisitExpression(expression.Operand).AsExpression(), expression.Type)
 							: VisitExpression(expression.Operand);
 			}