protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
        {
            string propertyName = node.Member.Name;
            string fieldName = DbMetaDataManager.GetFieldName(node.Member.DeclaringType, propertyName);

            if (node.Expression.NodeType == ExpressionType.Call)
            {

                VisitMethodCall((MethodCallExpression)node.Expression,fieldName);
            }
            else if (node.Expression.NodeType == ExpressionType.Convert)
            {
                var ue = node.Expression as UnaryExpression;
                var call = ue.Operand as MethodCallExpression;

                if (call != null)
                    this.VisitMethodCall(call, fieldName);
                else
                    this.MyVisitMember(ue.Operand as MemberExpression,fieldName);
            }
            else
            {
                parameters.Add(fieldName, new Parameter(ParamPrefix + fieldName, null));
                var constant = node.Expression as ConstantExpression;
                if (constant != null)
                    VisitConstant(constant, fieldName);
                else
                {
                    LambdaExpression lambda = Expression.Lambda(node.Expression);
                    var fn = lambda.Compile();
                    VisitConstant(Expression.Constant(fn.DynamicInvoke(null), node.Expression.Type), fieldName);
                }
            }
            return node;
        }

 protected MemberAssignment UpdateMemberAssignment(MemberAssignment assignment, MemberInfo member, Expression expression)
 {
     if (expression != assignment.Expression || member != assignment.Member) {
         return Expression.Bind(member, expression);
     }
     return assignment;
 }

        protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
        {
            var property = assignment.Member as PropertyInfo;
            if (property == null)
            {
                throw new NotSupportedException(
                    String.Format("{0} is not a property.", assignment.Member));
            }

            IPropertyUpdate update;
            var expr = PartialEval(assignment.Expression);
            switch (expr.NodeType)
            {
                case ExpressionType.Constant:
                    update = ConstantUpdate.Create(property, (ConstantExpression)expr);
                    break;
                case ExpressionType.Add:
                case ExpressionType.Subtract:
                    update = BinaryUpdate.Create(property, (BinaryExpression)expr);
                    break;
                case ExpressionType.Call:
                    update = MethodCallUpdate.Create(property, (MethodCallExpression)expr);
                    break;
                default:
                    throw new NotSupportedException();
            }

            this.m_updates.Add(update);

            return assignment;
        }

		protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
		{
			this.output.Append(assignment.Member.Name).Append(" = ");
			this.Visit(assignment.Expression);

			return assignment;
		}

 protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
 {
     var saveMember = this.currentMember;
     this.currentMember = assignment.Member;
     Expression e = this.Visit(assignment.Expression);
     this.currentMember = saveMember;
     return this.UpdateMemberAssignment(assignment, assignment.Member, e);
 }

        protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
        {
            var constantValue = node.Expression as ConstantExpression;
            if (constantValue != null)
            {
                _updateBuilder.Set(String.Join(".", _assigments.Reverse().ToArray()), BsonValue.Create(constantValue.Value));
            }
            else
            {
                return base.VisitMemberAssignment(node);
            }

            return node;
        }

 /// <summary>
 /// Visits a MemberAssignment.
 /// </summary>
 /// <param name="node">The MemberAssignment.</param>
 /// <returns>The MemberAssignment (possibly modified).</returns>
 protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment node)
 {
     Expression e = Visit(node.Expression);
     return UpdateMemberAssignment(node, node.Member, e);
 }

 public MemberAssignmentNode(INodeFactory factory, MemberAssignment memberAssignment)
     : base(factory, memberAssignment.BindingType, memberAssignment.Member)
 {
     this.Expression = this.Factory.Create(memberAssignment.Expression);
 }

 protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
 {
     System.Linq.Expressions.Expression e = Visit(assignment.Expression);
     if(e != assignment.Expression)
     {
         return System.Linq.Expressions.Expression.Bind(assignment.Member, e);
     }
     return assignment;
 }

 protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
 {
     this.Write(assignment.Member.Name);
     this.Write(" = ");
     this.Visit(assignment.Expression);
     return assignment;
 }

        /// <summary>
        /// Visit a member assignment expression.
        /// </summary>
        /// <param name="assignmentExp"></param>
        /// <returns></returns>
        protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignmentExp)
        {
            Expression e = Visit(assignmentExp.Expression);

            return e != assignmentExp.Expression ? Expression.Bind(assignmentExp.Member, e) : assignmentExp;
        }

        /// <summary>
        /// Visit a member assignment expression.
        /// </summary>
        /// <param name="assignmentExp"></param>
        /// <returns></returns>
        protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignmentExp)
        {
            Expression e = Visit(assignmentExp.Expression);

            if (e != assignmentExp.Expression)
            {
                return Expression.Bind(assignmentExp.Member, e);
            }

            return assignmentExp;
        }

 protected virtual bool CompareMemberAssignment(MemberAssignment a, MemberAssignment b)
 {
     return a.Member == b.Member
         && this.Compare(a.Expression, b.Expression);
 }

 protected override MemberBinding VisitMemberAssignment(MemberAssignment memberAssigment)
 {
     CheckAndVisitMemberAssignment (memberAssigment.Member, memberAssigment.Expression);
       return memberAssigment;
 }

 protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment, Stack<string> stack, Stack<IElasticPropertyAttribute> properties)
 {
     Expression e = this.Visit(assignment.Expression, stack, properties);
     if (e != assignment.Expression)
     {
         return Expression.Bind(assignment.Member, e);
     }
     return assignment;
 }

        protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
        {
            this.Visit(assignment.Expression);

            switch (assignment.Member.MemberType)
            {
                case MemberTypes.Field:
                    Console.WriteLine("stfld " + assignment.Member);
                    generator.Emit(OpCodes.Stfld, (FieldInfo)assignment.Member);
                    break;
                case MemberTypes.Property:
                    var method = ((PropertyInfo)assignment.Member).GetSetMethod();
                    Console.WriteLine("callvirt {0} {1}", method.DeclaringType.Name, method.Name);
                    generator.Emit(OpCodes.Callvirt, ((PropertyInfo)assignment.Member).GetSetMethod());
                    break;
                default:
                    throw new NotSupportedException("Unsupported member assignment type: " + assignment.Member.MemberType);
            }

            return assignment;
        }

 public EditableMemberAssignment(MemberAssignment member)
     : base(member.BindingType, member.Member)
 {
     Expression = EditableExpression.Create(member.Expression);
 }

    public virtual bool IsEvaluatableMemberAssignment (MemberAssignment node)
    {
      ArgumentUtility.CheckNotNull ("node", node);

      return true;
    }

 /// <summary>
 /// Visits a MemberAssignment.
 /// </summary>
 /// <param name="node">The MemberAssignment.</param>
 /// <returns>The MemberAssignment.</returns>
 protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
 {
     _sb.Append("<MemberAssignment>");
     return node;
 }

 internal virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
 {
     Expression expression = this.Visit(assignment.Expression);
     if (expression == assignment.Expression)
     {
         return assignment;
     }
     return Expression.Bind(assignment.Member, expression);
 }