Rewritten NhPartialEvaluatingExpressionVisitor

Author: gliljas

src/NHibernate.Test/Linq/WhereTests.cs

@@ -812,6 +812,16 @@ public void SelectOnCollectionReturnsResult()
 			Assert.That(result.Children, Is.Not.Empty);
 		}
 
+		[Test(Description = "GH-1556")]
+		public void ContainsOnCollection()
+		{
+			var animal = session.Get<Animal>(1);
+
+			Assert.DoesNotThrow(() => session.Query<Animal>()
+			                                 .Where(e => animal.Children.Contains(e.Father))
+			                                 .FirstOrDefault());
+		}
+
 
 		private static List<object[]> CanUseCompareInQueryDataSource()
 		{

src/NHibernate/Linq/Visitors/NhPartialEvaluatingExpressionVisitor.cs

@@ -1,15 +1,110 @@
 using System;
 using System.Linq;
 using System.Linq.Expressions;
+using NHibernate.Collection;
 using Remotion.Linq.Clauses.Expressions;
 using Remotion.Linq.Parsing;
-using Remotion.Linq.Parsing.ExpressionVisitors;
 using Remotion.Linq.Parsing.ExpressionVisitors.TreeEvaluation;
 
 namespace NHibernate.Linq.Visitors
 {
+	//Modified version of PartialEvaluatingExpressionVisitor from Relinq (https://github.com/re-motion/Relinq)
+	//Copyright (c) rubicon IT GmbH, www.rubicon.eu
+	//
+	//Used under the Apache Software License 2.0
 	internal class NhPartialEvaluatingExpressionVisitor : RelinqExpressionVisitor, IPartialEvaluationExceptionExpressionVisitor
 	{
+		public static Expression EvaluateIndependentSubtrees(Expression expression)
+		{
+			return EvaluateIndependentSubtrees(expression, new NhEvaluatableExpressionFilter());
+		}
+		/// <summary>
+		/// Takes an expression tree and finds and evaluates all its evaluatable subtrees.
+		/// </summary>
+		public static Expression EvaluateIndependentSubtrees(Expression expressionTree, IEvaluatableExpressionFilter evaluatableExpressionFilter)
+		{
+			if (expressionTree == null) throw new ArgumentNullException(nameof(expressionTree));
+			if (evaluatableExpressionFilter == null) throw new ArgumentNullException(nameof(evaluatableExpressionFilter));
+			
+			var partialEvaluationInfo = EvaluatableTreeFindingExpressionVisitor.Analyze(expressionTree, evaluatableExpressionFilter);
+
+			var visitor = new NhPartialEvaluatingExpressionVisitor(partialEvaluationInfo, evaluatableExpressionFilter);
+			return visitor.Visit(expressionTree);
+		}
+
+		// _partialEvaluationInfo contains a list of the expressions that are safe to be evaluated.
+		private readonly PartialEvaluationInfo _partialEvaluationInfo;
+		private readonly IEvaluatableExpressionFilter _evaluatableExpressionFilter;
+
+		private NhPartialEvaluatingExpressionVisitor(
+			PartialEvaluationInfo partialEvaluationInfo,
+			IEvaluatableExpressionFilter evaluatableExpressionFilter)
+		{
+			_partialEvaluationInfo = partialEvaluationInfo ?? throw new ArgumentNullException(nameof(partialEvaluationInfo));
+			_evaluatableExpressionFilter = evaluatableExpressionFilter ?? throw new ArgumentNullException(nameof(evaluatableExpressionFilter));
+		}
+
+		public override Expression Visit(Expression expression)
+		{
+			// Only evaluate expressions which do not use any of the surrounding parameter expressions. Don't evaluate
+			// lambda expressions (even if you could), we want to analyze those later on.
+			if (expression == null)
+				return null;
+
+			if (expression.NodeType == ExpressionType.Lambda || !_partialEvaluationInfo.IsEvaluatableExpression(expression))
+				return base.Visit(expression);
+
+			Expression evaluatedExpression;
+			try
+			{
+				evaluatedExpression = EvaluateSubtree(expression);
+			}
+			catch (Exception ex)
+			{
+				// Evaluation caused an exception. Skip evaluation of this expression and proceed as if it weren't evaluable.
+				var baseVisitedExpression = base.Visit(expression);
+				// Then wrap the result to capture the exception for the back-end.
+				return new PartialEvaluationExceptionExpression(ex, baseVisitedExpression);
+			}
+
+			if (evaluatedExpression != expression)
+				return EvaluateIndependentSubtrees(evaluatedExpression, _evaluatableExpressionFilter);
+
+			return evaluatedExpression;
+		}
+
+		/// <summary>
+		/// Evaluates an evaluatable <see cref="Expression"/> subtree, i.e. an independent expression tree that is compilable and executable
+		/// without any data being passed in. The result of the evaluation is returned as a <see cref="ConstantExpression"/>; if the subtree
+		/// is already a <see cref="ConstantExpression"/>, no evaluation is performed.
+		/// </summary>
+		/// <param name="subtree">The subtree to be evaluated.</param>
+		/// <returns>A <see cref="ConstantExpression"/> holding the result of the evaluation.</returns>
+		private Expression EvaluateSubtree(Expression subtree)
+		{
+			if (subtree == null) throw new ArgumentNullException(nameof(subtree));
+
+			if (subtree.NodeType == ExpressionType.Constant)
+			{
+				var constantExpression = (ConstantExpression) subtree;
+				var valueAsIQueryable = constantExpression.Value as IQueryable;
+				if (valueAsIQueryable != null && !IsEvaluatedQueryable(constantExpression.Value) && valueAsIQueryable.Expression != constantExpression)
+					return valueAsIQueryable.Expression;
+
+				return constantExpression;
+			}
+			Expression<Func<object>> lambdaWithoutParameters = Expression.Lambda<Func<object>>(Expression.Convert(subtree, typeof(object)));
+			var compiledLambda = lambdaWithoutParameters.Compile();
+
+			object value = compiledLambda();
+			return Expression.Constant(value, subtree.Type);
+		}
+
+		protected virtual bool IsEvaluatedQueryable(object queryable)
+		{
+			return queryable is IPersistentCollection;
+		}
+
 		protected override Expression VisitConstant(ConstantExpression expression)
 		{
 			var value = expression.Value as Expression;
@@ -21,12 +116,6 @@ protected override Expression VisitConstant(ConstantExpression expression)
 			return EvaluateIndependentSubtrees(value);
 		}
 
-		public static Expression EvaluateIndependentSubtrees(Expression expression)
-		{
-			var evaluatedExpression = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new NhEvaluatableExpressionFilter());
-			return new NhPartialEvaluatingExpressionVisitor().Visit(evaluatedExpression);
-		}
-
 		public Expression VisitPartialEvaluationException(PartialEvaluationExceptionExpression partialEvaluationExceptionExpression)
 		{
 			throw new HibernateException(
@@ -35,6 +124,8 @@ public Expression VisitPartialEvaluationException(PartialEvaluationExceptionExpr
 		}
 	}
 
+
+
 	internal class NhEvaluatableExpressionFilter : EvaluatableExpressionFilterBase
 	{
 		public override bool IsEvaluatableMethodCall(MethodCallExpression node)