Avoid lambda compilation for member access expressions in LINQ

continuation of nhibernate#2948

Author: gokhanabatay

src/NHibernate/Engine/Query/QueryPlanCache.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.Serialization;
 using NHibernate.Engine.Query.Sql;
@@ -66,12 +67,14 @@ public IQueryExpressionPlan GetHQLQueryPlan(IQueryExpression queryExpression, bo
 				{
 					log.Debug("unable to locate HQL query plan in cache; generating ({0})", queryExpression.Key);
 				}
+				Stopwatch stopwatch = log.IsWarnEnabled() ? Stopwatch.StartNew() : null;
 				plan = new QueryExpressionPlan(queryExpression, shallow, enabledFilters, factory);
+				stopwatch?.Stop();
 				// 6.0 TODO: add "CanCachePlan { get; }" to IQueryExpression interface
 				if (!(queryExpression is ICacheableQueryExpression linqExpression) || linqExpression.CanCachePlan)
 					planCache.Put(key, plan);
 				else
-					log.Debug("Query plan not cacheable");
+					log.Warn("Query plan is not cacheable QueryKey:{0}, ElapsedMilliseconds:{1}", queryExpression.Key, stopwatch.ElapsedMilliseconds);
 			}
 			else
 			{

src/NHibernate/Impl/ExpressionProcessor.cs

@@ -248,7 +248,7 @@ private static ICriterion Le(ProjectionInfo property, object value)
 		}
 
 		/// <summary>
-		/// Invoke the expression to extract its runtime value
+		/// Walk on expression extract its runtime value
 		/// </summary>
 		public static object FindValue(Expression expression)
 		{
@@ -258,10 +258,10 @@ public static object FindValue(Expression expression)
 			if (expression.NodeType == ExpressionType.MemberAccess)
 			{
 				var memberAccess = (MemberExpression) expression;
+				var member = memberAccess.Member;
 				if (memberAccess.Expression == null || memberAccess.Expression.NodeType == ExpressionType.Constant)
 				{
 					var constantValue = ((ConstantExpression) memberAccess.Expression)?.Value;
-					var member = memberAccess.Member;
 					switch (member.MemberType)
 					{
 						case MemberTypes.Field:
@@ -270,11 +270,90 @@ public static object FindValue(Expression expression)
 							return ((PropertyInfo) member).GetValue(constantValue);
 					}
 				}
+				else
+				{
+					switch (member.MemberType)
+					{
+						case MemberTypes.Field:
+							return ((FieldInfo) member).GetValue(FindValue(memberAccess.Expression));
+						case MemberTypes.Property:
+							return ((PropertyInfo) member).GetValue(FindValue(memberAccess.Expression));
+					}
+				}
+			}
+
+			if (expression.NodeType == ExpressionType.Call)
+			{
+				var methodCall = (MethodCallExpression) expression;
+
+				var args = new object[methodCall.Arguments.Count];
+				for (int i = 0; i < args.Length; i++)
+					args[i] = FindValue(methodCall.Arguments[i]);
+
+				if (methodCall.Object == null) //extension or static method
+				{
+					if (args.Length > 0 && args[0] != null)
+					{
+						return methodCall.Method.Invoke(args[0].GetType(), args);
+					}
+					else
+					{
+						return methodCall.Method.Invoke(methodCall.Method.DeclaringType, args);
+					}
+				}
+				else
+				{
+					var callingObject = FindValue(methodCall.Object);
+
+					return methodCall.Method.Invoke(callingObject, args);
+				}
+			}
+
+			if (expression.NodeType == ExpressionType.Convert)
+			{
+				var convert = (UnaryExpression) expression;
+				var value = FindValue(convert.Operand);
+				if (value != null)
+				{
+					var type = Nullable.GetUnderlyingType(convert.Type) ?? convert.Type;
+					if (type != convert.Operand.Type)
+					{
+						return convert.Method != null
+							? convert.Method.Invoke(null, new[] { value })
+							: Convert.ChangeType(value, type);
+					}
+				}
+
+				return value;
+			}
+
+			if (expression is BinaryExpression binary)
+			{
+				dynamic left = FindValue(binary.Left);
+				dynamic right = FindValue(binary.Right);
+				if (binary.Method != null)
+				{
+					return binary.Method.Invoke(null, new[] { left, right });
+				}
+				else
+				{
+					switch (expression.NodeType)
+					{
+						case ExpressionType.Multiply:
+							return left * right;
+						case ExpressionType.Divide:
+							return left / right;
+						case ExpressionType.Modulo:
+							return left % right;
+						case ExpressionType.Add:
+							return left + right;
+						case ExpressionType.Subtract:
+							return left - right;
+					}
+				}
 			}
 
-			var valueExpression = Expression.Lambda(expression).Compile();
-			object value = valueExpression.DynamicInvoke();
-			return value;
+			return Expression.Lambda(expression).Compile().DynamicInvoke();
 		}
 
 		/// <summary>