/// <summary>
        /// Transforms a call to <code>entity.Mixin&lt;T&gt;()</code> to <code>new MixinType { Properties, ... }</code>
        /// </summary>
        /// <param name="method">The method call expression.</param>
        /// <returns>The</returns>
        public Expression TransformMixinMethodExpression(MethodCallExpression method)
        {
            var mixinType = method.Type;
            var entityType = method.Object.Type;
            string prefix = $"{mixinType.Name}_";

            // Get the available properties of the mixin.
            var entity = _model.GetEntityType(entityType);
            var properties = entity
                .GetProperties()
                .Where(p => p.Name.StartsWith(prefix))
                .ToArray();

            // Create an object initializer expression.
            var ctor = Expression.New(mixinType);
            var memberBindings = new MemberBinding[properties.Length];
            for (int i = 0; i < properties.Length; i++)
            {
                var property = properties[i];
                string propertyName = property.Name.Replace(prefix, "");
                var member = mixinType.GetProperty(propertyName);
                var value = Expression.Call(
                    EntityQueryModelVisitor.PropertyMethodInfo.MakeGenericMethod(member.PropertyType),
                    method.Object,
                    Expression.Constant(property.Name));

                memberBindings[i] = Expression.Bind(member, value);
            }

            return Expression.MemberInit(ctor, memberBindings);
        }

        public static CreateInstance CreateConstructorExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor,
            ResolutionMember[] members = null)
        {
            var strategyParameter = Expression.Constant(containerContext.ResolutionStrategy, typeof(IResolutionStrategy));
            var resolutionInfoParameter = Expression.Parameter(typeof(ResolutionInfo), "resolutionInfo");

            var arguments = CreateExpressionFromResolutionTargets(resolutionConstructor.Parameters, strategyParameter, resolutionInfoParameter);

            var newExpression = Expression.New(resolutionConstructor.Constructor, arguments);

            if (members == null || members.Length == 0)
                return Expression.Lambda<CreateInstance>(newExpression, resolutionInfoParameter).Compile();

            var length = members.Length;
            var propertyExpressions = new MemberBinding[length];
            for (var i = 0; i < length; i++)
            {
                var member = members[i];
                var propertyExpression = Expression.Bind(member.MemberInfo,
                    CreateResolutionTargetExpression(member.ResolutionTarget, strategyParameter,
                        resolutionInfoParameter));
                propertyExpressions[i] = propertyExpression;

            }

            var initExpression = Expression.MemberInit(newExpression, propertyExpressions);
            return Expression.Lambda<CreateInstance>(initExpression, resolutionInfoParameter).Compile();
        }

 public static EditableMemberBinding CreateEditableMemberBinding(MemberBinding member)
 {
     if (member is MemberAssignment) return new EditableMemberAssignment(member as MemberAssignment);
     else if (member is MemberListBinding) return new EditableMemberListBinding(member as MemberListBinding);
     else if (member is MemberMemberBinding) return new EditableMemberMemberBinding(member as MemberMemberBinding);
     else return null;
 }

 private static void BindToProjectedWrapperMany(Expression[] bindingExpressions, int expressionStartIndex, MemberBinding[] bindings, int bindingStartIndex)
 {
     int propertyIndex = 0;
     while ((propertyIndex < (precreatedProjectedWrapperTypes.Length - 1)) && ((propertyIndex + expressionStartIndex) < bindingExpressions.Length))
     {
         bindings[bindingStartIndex + propertyIndex] = BindToProjectedProperty(typeof(ProjectedWrapperMany), propertyIndex, bindingExpressions[expressionStartIndex + propertyIndex]);
         propertyIndex++;
     }
     if (bindingExpressions.Length <= ((precreatedProjectedWrapperTypes.Length - 1) + expressionStartIndex))
     {
         while (propertyIndex < (precreatedProjectedWrapperTypes.Length - 1))
         {
             bindings[bindingStartIndex + propertyIndex] = BindToProjectedProperty(typeof(ProjectedWrapperMany), propertyIndex, Expression.Constant(string.Empty, typeof(string)));
             propertyIndex++;
         }
         bindings[(bindingStartIndex + precreatedProjectedWrapperTypes.Length) - 1] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("Next"), Expression.MemberInit(Expression.New(typeof(ProjectedWrapperManyEnd)), new MemberBinding[] { Expression.Bind(typeof(ProjectedWrapperManyEnd).GetProperty("ResourceTypeName"), Expression.Constant(string.Empty, typeof(string))) }));
     }
     else
     {
         int length = bindingExpressions.Length - ((precreatedProjectedWrapperTypes.Length - 1) + expressionStartIndex);
         if (length > (precreatedProjectedWrapperTypes.Length - 1))
         {
             length = precreatedProjectedWrapperTypes.Length;
         }
         MemberBinding[] bindingArray = new MemberBinding[precreatedProjectedWrapperTypes.Length + 2];
         bindingArray[0] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("ResourceTypeName"), Expression.Constant(string.Empty, typeof(string)));
         bindingArray[1] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("PropertyNameList"), Expression.Constant(string.Empty, typeof(string)));
         BindToProjectedWrapperMany(bindingExpressions, (expressionStartIndex + precreatedProjectedWrapperTypes.Length) - 1, bindingArray, 2);
         Expression expression = Expression.MemberInit(Expression.New(typeof(ProjectedWrapperMany)), bindingArray);
         bindings[(bindingStartIndex + precreatedProjectedWrapperTypes.Length) - 1] = Expression.Bind(typeof(ProjectedWrapperMany).GetProperty("Next"), expression);
     }
 }

        public static Expression CreateExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor, ResolutionInfo resolutionInfo,
            Expression resolutionInfoExpression, ResolutionMember[] members = null)
        {
            var length = resolutionConstructor.Parameters.Length;
            var arguments = new Expression[length];

            for (var i = 0; i < length; i++)
            {
                var parameter = resolutionConstructor.Parameters[i];
                arguments[i] = containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(parameter, resolutionInfo, resolutionInfoExpression);
            }

            var newExpression = Expression.New(resolutionConstructor.Constructor, arguments);

            if (members == null || members.Length == 0) return newExpression;
            {
                var propLength = members.Length;
                var propertyExpressions = new MemberBinding[propLength];
                for (var i = 0; i < propLength; i++)
                {
                    var member = members[i];
                    var propertyExpression = Expression.Bind(member.MemberInfo,
                        containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(member.ResolutionTarget, resolutionInfo, resolutionInfoExpression));
                    propertyExpressions[i] = propertyExpression;
                }

                return Expression.MemberInit(newExpression, propertyExpressions);
            }
        }

        protected override MemberBinding VisitMemberBinding(MemberBinding memberBinding)
        {
            if(memberBinding.BindingType == MemberBindingType.Assignment)
            {
#if PORTABLE
                var propertyInfo = memberBinding.Member as PropertyInfo;
                var assignment = memberBinding as MemberAssignment;
                if (propertyInfo != null 
                    && assignment != null 
                    && assignment.Expression.Type.IsValueType 
                    && !propertyInfo.PropertyType.IsValueType)
                {
                    var valueExpression = Expression.TypeAs(VisitExpression(assignment.Expression), propertyInfo.PropertyType);
                    return Expression.Bind(memberBinding.Member, valueExpression);
                }
#else
                if (memberBinding.Member.MemberType == MemberTypes.Property)
                {
                    var propertyInfo = memberBinding.Member as PropertyInfo;
                    var assignment = memberBinding as MemberAssignment;
                    if (assignment.Expression.Type.IsValueType && !propertyInfo.PropertyType.IsValueType)
                    {
                        var valueExpression = Expression.TypeAs(VisitExpression(assignment.Expression), propertyInfo.PropertyType);
                        return Expression.Bind(memberBinding.Member, valueExpression);
                    }
                }
#endif
            }
            return base.VisitMemberBinding(memberBinding);
        }

 protected override MemberBinding VisitBinding(MemberBinding binding)
 {
     var save = receivingMember;
     receivingMember = binding.Member;
     var result = base.VisitBinding(binding);
     receivingMember = save;
     return result;
 }

        protected override MemberBinding VisitBinding(MemberBinding node)
        {
            var elementName = BsonClassMap.LookupClassMap(_classes.Peek()).GetMemberMap(node.Member.Name).ElementName;
            _assigments.Push(elementName);

            MemberBinding visitMemberBinding = base.VisitBinding(node);
            _assigments.Pop();
            return visitMemberBinding;
        }

 public MemberBinding[] Decode(ref byte* data, ref int remainingBytes, bool doNotCheckBounds)
 {
     int count = intCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
     if (count == -1)
         return null;
     var result = new MemberBinding[count];
     for (int i = 0; i < count; i++)
         result[i] = memberBindingCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
     return result;
 }

 public static IMemberBindingMutator GetMutator(MemberBinding memberBinding)
 {
     if (memberBinding is MemberAssignment)
         return new MemberAssignmentMutator((MemberAssignment)memberBinding);
     if (memberBinding is MemberMemberBinding)
         return new MemberMemberBindingMutator((MemberMemberBinding)memberBinding);
     if (memberBinding is MemberListBinding)
         return new MemberListBindingMutator((MemberListBinding)memberBinding);
     throw Error.BadArgument("S0040: Unknown Expression Type '{0}'", memberBinding.GetType());
 }

		protected virtual MemberBinding VisitBinding (MemberBinding binding)
		{
			switch (binding.BindingType)
			{
				case MemberBindingType.Assignment:
					return VisitMemberAssignment ((MemberAssignment)binding);
				default:
					throw new ArgumentException (string.Format ("Unhandled binding type '{0}'", binding.BindingType));
			}
		}

 internal static Expression ReduceMemberBinding(ParameterExpression objVar, MemberBinding binding) {
     MemberExpression member = Expression.MakeMemberAccess(objVar, binding.Member);
     switch (binding.BindingType) {
         case MemberBindingType.Assignment:
             return Expression.Assign(member, ((MemberAssignment)binding).Expression);
         case MemberBindingType.ListBinding:
             return ReduceListInit(member, ((MemberListBinding)binding).Initializers, false);
         case MemberBindingType.MemberBinding:
             return ReduceMemberInit(member, ((MemberMemberBinding)binding).Bindings, false);
         default: throw Assert.Unreachable;
     }
 }

		internal virtual MemberBinding VisitBinding(MemberBinding binding) {
			switch (binding.BindingType) {
				case MemberBindingType.Assignment:
					return this.VisitMemberAssignment((MemberAssignment)binding);
				case MemberBindingType.MemberBinding:
					return this.VisitMemberMemberBinding((MemberMemberBinding)binding);
				case MemberBindingType.ListBinding:
					return this.VisitMemberListBinding((MemberListBinding)binding);
				default:
					throw Error.UnhandledBindingType(binding.BindingType);
			}
		}

 protected virtual MemberBinding VisitBinding(MemberBinding binding)
 {
     switch (binding.BindingType)
     {
         case MemberBindingType.Assignment:
             return this.VisitMemberAssignment((MemberAssignment)binding);
         case MemberBindingType.MemberBinding:
             return this.VisitMemberMemberBinding((MemberMemberBinding)binding);
         case MemberBindingType.ListBinding:
             return this.VisitMemberListBinding((MemberListBinding)binding);
         default:
             throw new Exception($"Unhandled binding type '{binding.BindingType}'");
     }
 }

		protected virtual MemberBinding VisitBinding(MemberBinding binding, Stack<string> stack, Stack<IElasticPropertyAttribute> properties)
		{
			switch (binding.BindingType)
			{
				case MemberBindingType.Assignment:
					return this.VisitMemberAssignment((MemberAssignment)binding, stack, properties);
				case MemberBindingType.MemberBinding:
					return this.VisitMemberMemberBinding((MemberMemberBinding)binding, stack, properties);
				case MemberBindingType.ListBinding:
					return this.VisitMemberListBinding((MemberListBinding)binding, stack, properties);
				default:
					throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));
			}
		}

        internal static MemberBindingNode Create(INodeFactory factory, MemberBinding memberBinding)
        {
            MemberBindingNode memberBindingNode = null;

            if (memberBinding is MemberAssignment)
                memberBindingNode = new MemberAssignmentNode(factory, (MemberAssignment)memberBinding);
            else if (memberBinding is MemberListBinding)
                memberBindingNode = new MemberListBindingNode(factory, (MemberListBinding)memberBinding);
            else if (memberBinding is MemberMemberBinding)
                memberBindingNode = new MemberMemberBindingNode(factory, (MemberMemberBinding)memberBinding);
            else if (memberBinding != null)
                throw new ArgumentException("Unknown member binding of type " + memberBinding.GetType(), "memberBinding");

            return memberBindingNode;
        }

        internal static Expression ReduceMemberBinding(ParameterExpression objVar, MemberBinding binding)
        {
            MemberExpression left = Expression.MakeMemberAccess(objVar, binding.Member);
            switch (binding.BindingType)
            {
                case MemberBindingType.Assignment:
                    return Expression.Assign(left, ((MemberAssignment) binding).Expression);

                case MemberBindingType.MemberBinding:
                    return ReduceMemberInit(left, ((MemberMemberBinding) binding).Bindings, false);

                case MemberBindingType.ListBinding:
                    return ReduceListInit(left, ((MemberListBinding) binding).Initializers, false);
            }
            throw ContractUtils.Unreachable;
        }

 protected virtual bool AreEqualBinding(MemberBinding x, MemberBinding y)
 {
     if (x.BindingType != y.BindingType)
         return false;
     
     switch (x.BindingType)
     {
         case MemberBindingType.Assignment:
             return this.AreEqualMemberAssignment((MemberAssignment)x, (MemberAssignment)y);                    
         case MemberBindingType.MemberBinding:
             return this.AreEqualMemberMemberBinding((MemberMemberBinding)x, (MemberMemberBinding)y);                    
         case MemberBindingType.ListBinding:
             return this.AreEqualMemberListBinding((MemberListBinding)x, (MemberListBinding)y);                                        
         default:
             throw new Exception(string.Format("Unhandled binding type '{0}'", y.BindingType));
     }
 }

 internal static MemberBinding[] Bind(Expression[] bindingExpressions, Type projectedWrapperType)
 {
     MemberBinding[] bindingArray;
     int length = bindingExpressions.Length;
     if (length <= (precreatedProjectedWrapperTypes.Length + 1))
     {
         bindingArray = new MemberBinding[length];
         BindResourceTypeAndPropertyNameList(projectedWrapperType, bindingArray, bindingExpressions);
         for (int i = 0; i < (length - 2); i++)
         {
             bindingArray[i + 2] = BindToProjectedProperty(projectedWrapperType, i, bindingExpressions[i + 2]);
         }
         return bindingArray;
     }
     bindingArray = new MemberBinding[precreatedProjectedWrapperTypes.Length + 2];
     BindResourceTypeAndPropertyNameList(projectedWrapperType, bindingArray, bindingExpressions);
     BindToProjectedWrapperMany(bindingExpressions, 2, bindingArray, 2);
     return bindingArray;
 }

		protected object Visit(object obj, MemberBinding binding)
		{
			switch (binding.BindingType)
			{
			case MemberBindingType.Assignment:
				var assignment = ((MemberAssignment)binding);

				var value = this.Visit(assignment.Expression);

				if (value == InterpretFailed)
				{
					return value;
				}

				var fieldInfo = assignment.Member as FieldInfo;

				if (fieldInfo != null)
				{
					fieldInfo.SetValue(obj, value);

					return binding;
				}

				var propertyInfo = assignment.Member as PropertyInfo;

				if (propertyInfo != null)
				{
					propertyInfo.SetValue(obj, value, null);

					return binding;
				}

				return InterpretFailed;
			}

			return InterpretFailed;
		}