Regression caused by NH-3904

src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/DoubleStringUserType.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Data;
+using NHibernate.SqlTypes;
+using NHibernate.UserTypes;
+
+namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators
+{
+	public class DoubleStringUserType : IUserType
+	{
+		public SqlType[] SqlTypes
+		{
+			get { return new[] { SqlTypeFactory.GetString(20) }; }
+		}
+
+		public System.Type ReturnedType
+		{
+			get { return typeof(string); }
+		}
+
+		public bool IsMutable
+		{
+			get { return false; }
+		}
+
+		public int GetHashCode(object x)
+		{
+			if (x == null)
+			{
+				return 0;
+			}
+			return x.GetHashCode();
+		}
+
+		public object NullSafeGet(IDataReader rs, string[] names, object owner)
+		{
+			object obj = NHibernateUtil.String.NullSafeGet(rs, names[0]);
+			if (obj == null)
+			{
+				return null;
+			}
+			return Convert.ToDouble((string)obj);
+		}
+
+		public void NullSafeSet(IDbCommand cmd, object value, int index)
+		{
+			if (value == null)
+			{
+				((IDataParameter)cmd.Parameters[index]).Value = DBNull.Value;
+			}
+			else
+			{
+				var doubleValue = (double)value;
+				((IDataParameter)cmd.Parameters[index]).Value = doubleValue.ToString();
+			}
+		}
+
+		public object DeepCopy(object value)
+		{
+			return value;
+		}
+
+		public object Replace(object original, object target, object owner)
+		{
+			return original;
+		}
+
+		public object Assemble(object cached, object owner)
+		{
+			return cached;
+		}
+
+		public object Disassemble(object value)
+		{
+			return value;
+		}
+
+		bool IUserType.Equals(object x, object y)
+		{
+			return object.Equals(x, y);
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/EntityWithUserTypeProperty.cs

@@ -6,6 +6,7 @@ public class EntityWithUserTypeProperty
 		public virtual int Id { get; set; }
 		public virtual string Name { get; set; }
 		public virtual IExample Example { get; set; }
+		public virtual double DoubleStoredAsString { get; set; }
 	}
 
 

src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/Fixture.cs

@@ -4,7 +4,6 @@
 using NHibernate.Linq;
 using NUnit.Framework;
 
-
 namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators
 {
 
@@ -71,7 +70,6 @@ protected override void OnTearDown()
 			}
 		}
 
-
 		[Test]
 		public void EqualityWorksForUserType()
 		{
@@ -80,14 +78,14 @@ public void EqualityWorksForUserType()
 			{
 				var newItem = new BarExample { Value = "Larry" };
 				var entities = session.Query<EntityWithUserTypeProperty>()
-					.Where(x=>x.Example == newItem)
+					.Where(x => x.Example == newItem)
 					.ToList();
 
 				Assert.AreEqual(1, entities.Count);
 			}
 		}
 
-		[Test]
+		[Test, Ignore("Not implemented yet")]
 		public void LinqMethodWorksForUserType()
 		{
 			using (var session = OpenSession())
@@ -102,6 +100,50 @@ public void LinqMethodWorksForUserType()
 			}
 		}
 
+		[Test]
+		public void EqualityWorksForExplicitUserType()
+		{
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var newItem = new BarExample { Value = "Larry" };
+				var entities = session.Query<EntityWithUserTypeProperty>()
+					.Where(x => x.Example == newItem.MappedAs(NHibernateUtil.Custom(typeof(ExampleUserType))))
+					.ToList();
+
+				Assert.AreEqual(1, entities.Count);
+			}
+		}
+
+		[Test]
+		public void LinqMethodWorksForExplicitUserType()
+		{
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var newItem = new BarExample { Value = "Larry" };
+				var entities = session.Query<EntityWithUserTypeProperty>()
+					.Where(x => x.Example.IsEquivalentTo(newItem.MappedAs(NHibernateUtil.Custom(typeof(ExampleUserType)))))
+					.ToList();
+
+				Assert.AreEqual(2, entities.Count);
+			}
+		}
+
+		[Test]
+		public void LinqMethodWorksForStandardStringProperty()
+		{
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var entities = session.Query<EntityWithUserTypeProperty>()
+					.Where(x => x.Name == "Bob")
+					.ToList();
+
+				Assert.AreEqual(1, entities.Count);
+			}
+		}
+
 		[Test]
 		public void CanQueryWithHql()
 		{

src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/Mappings.hbm.xml

@@ -6,5 +6,6 @@
 	</id>
 	<property name="Name" />
 	<property name="Example" type="NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators.ExampleUserType, NHibernate.Test" />
+	<property name="DoubleStoredAsString" type="NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators.DoubleStringUserType, NHibernate.Test" />
   </class>
-</hibernate-mapping>
+</hibernate-mapping>

src/NHibernate.Test/NHibernate.Test.csproj

@@ -725,6 +725,7 @@
     <Compile Include="Linq\ByMethod\DistinctTests.cs" />
     <Compile Include="Component\Basic\ComponentWithUniqueConstraintTests.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\BarExample.cs" />
+    <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\DoubleStringUserType.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\EntityWithUserTypeProperty.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\EntityWithUserTypePropertyIsEquivalentGenerator.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\EntityWithUserTypePropertyGeneratorsRegistry.cs" />

src/NHibernate/Linq/NhLinqExpression.cs

@@ -31,14 +31,13 @@ public class NhLinqExpression : IQueryExpression
 		public NhLinqExpression(Expression expression, ISessionFactoryImplementor sessionFactory)
 		{
 			_expression = NhPartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(expression);
-
 			// We want logging to be as close as possible to the original expression sent from the
 			// application. But if we log before partial evaluation, the log won't include e.g.
 			// subquery expressions if those are defined by the application in a variable referenced
 			// from the main query.
 			LinqLogging.LogExpression("Expression (partially evaluated)", _expression);
 
-			_constantToParameterMap = ExpressionParameterVisitor.Visit(_expression, sessionFactory);
+			_constantToParameterMap = ExpressionParameterVisitor.Visit(ref _expression, sessionFactory);
 
 			ParameterValuesByName = _constantToParameterMap.Values.ToDictionary(p => p.Name,
 																				p => System.Tuple.Create(p.Value, p.Type));
@@ -77,4 +76,4 @@ internal void CopyExpressionTranslation(NhLinqExpression other)
 			ParameterDescriptors = other.ParameterDescriptors;
 		}
 	}
-}
+}

src/NHibernate/Linq/Visitors/ExpressionParameterVisitor.cs

@@ -26,21 +26,21 @@ public class ExpressionParameterVisitor : ExpressionTreeVisitor
 				ReflectionHelper.GetMethodDefinition(() => Enumerable.Take<object>(null, 0)),
 			};
 
-		private readonly List<CustomType> _allMappedCustomTypes;
-
 		public ExpressionParameterVisitor(ISessionFactoryImplementor sessionFactory)
 		{
 			_sessionFactory = sessionFactory;
-			_allMappedCustomTypes = _sessionFactory.GetAllClassMetadata().Values
-												.SelectMany(c => c.PropertyTypes)
-												.OfType<CustomType>().ToList();
 		}
 
 		public static IDictionary<ConstantExpression, NamedParameter> Visit(Expression expression, ISessionFactoryImplementor sessionFactory)
+		{
+			return Visit(ref expression, sessionFactory);
+		}
+
+		internal static IDictionary<ConstantExpression, NamedParameter> Visit(ref Expression expression, ISessionFactoryImplementor sessionFactory)
 		{
 			var visitor = new ExpressionParameterVisitor(sessionFactory);
-			
-			visitor.VisitExpression(expression);
+
+			expression = visitor.VisitExpression(expression);
 
 			return visitor._parameters;
 		}
@@ -49,10 +49,10 @@ protected override Expression VisitMethodCallExpression(MethodCallExpression exp
 		{
 			if (expression.Method.Name == "MappedAs" && expression.Method.DeclaringType == typeof(LinqExtensionMethods))
 			{
-				var parameter = (ConstantExpression) VisitExpression(expression.Arguments[0]);
-				var type = (ConstantExpression) expression.Arguments[1];
+				var parameter = (ConstantExpression)VisitExpression(expression.Arguments[0]);
+				var type = (ConstantExpression)expression.Arguments[1];
 
-				_parameters[parameter].Type = (IType) type.Value;
+				_parameters[parameter].Type = (IType)type.Value;
 
 				return parameter;
 			}
@@ -94,16 +94,6 @@ protected override Expression VisitConstantExpression(ConstantExpression express
 				if (expression.Value == null)
 					type = NHibernateUtil.GuessType(expression.Type);
 
-				if (type == null)
-				{
-					var customType =
-						_allMappedCustomTypes.FirstOrDefault(ct => ct.UserType.ReturnedType.IsAssignableFrom(expression.Type));
-					if (customType != null)
-					{
-						type = customType;
-					}
-				}
-
 				// Constant characters should be sent as strings
 				if (expression.Type == typeof(char))
 				{