Improve Tuple equality

Let's make clear statement that Tuple can't have null Items and Items
can't change (as well as Tuple's hash code)

Author: DmitryNaumov

src/NHibernate/Linq/NestedSelects/NestedSelectRewriter.cs

@@ -199,9 +199,7 @@ private static LambdaExpression MakePredicate(int index)
 					Expression.Call(typeof(object),
 									"ReferenceEquals",
 									System.Type.EmptyTypes,
-									Expression.ArrayIndex(
-										Expression.MakeMemberAccess(t, Tuple.ItemsField),
-										Expression.Constant(index)),
+									ArrayIndex(Expression.Property(t, Tuple.ItemsProperty), index),
 									Expression.Constant(null))),
 				t);
 		}
@@ -221,18 +219,16 @@ private static LambdaExpression CreateSelector(IEnumerable<ExpressionHolder> exp
 
 			var initializers = expressions.Select((x, index) => new { x.Tuple, index })
 				.Where(x => x.Tuple == tuple)
-				.Select(x => ArrayIndex(x.index, parameter));
+				.Select(x => ArrayIndex(parameter, x.index));
 
 			var newArrayInit = Expression.NewArrayInit(typeof(object), initializers);
 
 			return Expression.Lambda(
-				Expression.MemberInit(
-					Expression.New(typeof(Tuple)),
-					Expression.Bind(Tuple.ItemsField, newArrayInit)),
+				Expression.New(Tuple.Constructor, newArrayInit),
 				parameter);
 		}
 
-		private static Expression ArrayIndex(int value, Expression param)
+		private static Expression ArrayIndex(Expression param, int value)
 		{
 			return Expression.ArrayIndex(param, Expression.Constant(value));
 		}

src/NHibernate/Linq/NestedSelects/SelectClauseRewriter.cs

@@ -54,8 +54,7 @@ private Expression AddAndConvertExpression(Expression expression)
 
 			return Expression.Convert(
 				Expression.ArrayIndex(
-					Expression.MakeMemberAccess(parameter,
-												Tuple.ItemsField),
+					Expression.Property(parameter, Tuple.ItemsProperty),
 					Expression.Constant(expressions.Count - 1)),
 				expression.Type);
 		}

src/NHibernate/Linq/NestedSelects/Tuple.cs

@@ -6,18 +6,30 @@ namespace NHibernate.Linq.NestedSelects
 {
 	internal class Tuple : IEquatable<Tuple>
 	{
-		public static readonly FieldInfo ItemsField = typeof (Tuple).GetField("Items");
+		public static readonly ConstructorInfo Constructor = typeof (Tuple).GetConstructor(new[] { typeof (object[]) });
+		public static readonly PropertyInfo ItemsProperty = typeof (Tuple).GetProperty("Items");
+		private readonly object[] _items;
 
-		public object[] Items;
+		public Tuple(object[] items)
+		{
+			if (items == null) throw new ArgumentNullException("items");
+			_items = items;
+		}
+
+		public object[] Items
+		{
+			get { return _items; }
+		}
 
 		public bool Equals(Tuple other)
 		{
 			if (other == null) return false;
+			if (ReferenceEquals(this, other)) return true;
 
-			if (other.Items.Length != Items.Length)
+			if (other._items.Length != _items.Length)
 				return false;
 
-			return !other.Items.Where((t, index) => !Equals(t, Items[index])).Any();
+			return _items.SequenceEqual(other._items);
 		}
 
 		public override bool Equals(object obj)
@@ -27,7 +39,19 @@ public override bool Equals(object obj)
 
 		public override int GetHashCode()
 		{
-			return (Items != null ? Items.Length.GetHashCode() : 0);
+			unchecked
+			{
+				var length = _items.Length;
+				if (length == 0)
+					return 0;
+
+				var lengthCode = length;
+				var firstElement = _items[0];
+				if (ReferenceEquals(firstElement, null))
+					return lengthCode;
+
+				return firstElement.GetHashCode() * 397 ^ lengthCode;
+			}
 		}
 	}
 }