public override void LeaveBinaryExpression(BinaryExpression node)
 {
     if (IsAssignmentToSpecialMember(node))
     {
         ProcessAssignmentToSpecialMember(node);
     }
 }

 public static Expression ComparisonFor(Expression local, IEnumerable<Expression> expressions)
 {
     BinaryExpression expression;
     IEnumerator<Expression> enumerator = expressions.GetEnumerator();
     if (!enumerator.MoveNext())
     {
         throw new AssertionFailedException("e.MoveNext()");
     }
     BinaryExpression expression1 = expression = new BinaryExpression(LexicalInfo.Empty);
     expression.set_Operator(11);
     expression.set_Left(Expression.Lift(local));
     expression.set_Right(Expression.Lift(enumerator.Current));
     Expression expression2 = expression;
     while (enumerator.MoveNext())
     {
         BinaryExpression expression3;
         BinaryExpression expression4;
         BinaryExpression expression11 = expression4 = new BinaryExpression(LexicalInfo.Empty);
         expression4.set_Operator(0x1c);
         expression4.set_Left(Expression.Lift(expression2));
         BinaryExpression expression12 = expression3 = new BinaryExpression(LexicalInfo.Empty);
         expression3.set_Operator(11);
         expression3.set_Left(Expression.Lift(local));
         expression3.set_Right(Expression.Lift(enumerator.Current));
         expression4.set_Right(expression3);
         expression2 = expression4;
     }
     return expression2;
 }

        protected virtual void AddDependency(ArrayLiteralExpression dependencies, BinaryExpression binaryExpression)
        {
            StringLiteralExpression dependency;

            //HACK: replace with proper AST method invocation
            if (binaryExpression.Left is StringLiteralExpression)
            {
                dependency = new StringLiteralExpression(string.Format("{0}|{1}",
                                                    binaryExpression.Left.ToString().Trim('\''),
                                                    binaryExpression.Right.ToString().Trim('\'')));
            }
            else if(binaryExpression.Left is BinaryExpression)
            {

                var left = (BinaryExpression) binaryExpression.Left;

                var package = left.Left.ToString().Trim('\'');
                var version = left.Right.ToString().Trim('\'');
                var dll = binaryExpression.Right.ToString().Trim('\'');

                dependency = new StringLiteralExpression(string.Format("{0}|{1}|{2}",
                                                    package,
                                                    dll,
                                                    version));
            }
            else
                throw new ArgumentOutOfRangeException(string.Format("Unknown Expression type {0} passed to RightShiftToMethodCompilerStep.AddDependency", binaryExpression.Left.GetType().Name));

            dependencies.Items.Add(dependency);
        }

        protected override Statement ExpandImpl(MacroStatement macro){
            var result = new Block();
            foreach (Statement st in macro.Body.Statements){
                var decl = st as DeclarationStatement;
                var refer = st as ExpressionStatement;
                if(null==decl){
                    var ex = refer.Expression;
                    if (ex is MethodInvocationExpression){
                        decl =
                            new DeclarationStatement(
                                new Declaration(((MethodInvocationExpression) refer.Expression).Target.ToCodeString(),
                                                null), null);
                    }
                    if(ex is BinaryExpression){
                        var b = ex as BinaryExpression;
                        decl = new DeclarationStatement(
                            new Declaration(b.Left.ToCodeString(),null),b.Right
                            );
                    }
                }

                var bin = new BinaryExpression(BinaryOperatorType.Assign,
                                               new TryCastExpression(new ReferenceExpression(decl.Declaration.Name),
                                                                     decl.Declaration.Type),
                                               decl.Initializer);
                var def = new MacroStatement("definebrailproperty");
                def.Arguments.Add(bin);
                result.Add(def);
            }
            return result;
        }

        public override void LeaveBinaryExpression(BinaryExpression node)
        {
            if (CheckExpressionType(node.Right))
                CheckExpressionType(node.Left);

            if (BinaryOperatorType.ReferenceEquality == node.Operator)
            {
                if (IsTypeReference(node.Right))
                {
                    Warnings.Add(
                        CompilerWarningFactory.IsInsteadOfIsa(node));
                }
            }

            //check that the assignment or comparison is meaningful
            if (BinaryOperatorType.Assign == node.Operator
                || AstUtil.GetBinaryOperatorKind(node) == BinaryOperatorKind.Comparison)
            {
                if (AreSameExpressions(node.Left, node.Right))
                {
                    Warnings.Add(
                        (BinaryOperatorType.Assign == node.Operator)
                        ? CompilerWarningFactory.AssignmentToSameVariable(node)
                        : CompilerWarningFactory.ComparisonWithSameVariable(node)
                    );
                }
                else if (BinaryOperatorType.Assign != node.Operator
                         && AreConstantExpressions(node.Left, node.Right))
                {
                    WarnAboutConstantExpression(node);
                }
            }
        }

		override protected void ProcessAssignment(BinaryExpression node)
		{
			if (TypeSystemServices.IsQuackBuiltin(node.Left.Entity))
				BindDuck(node);
			else
				ProcessStaticallyTypedAssignment(node);
		}

 public override void LeaveBinaryExpression(BinaryExpression node)
 {
     if (BinaryOperatorType.Assign == node.Operator
         && (node.Right.NodeType != NodeType.TryCastExpression)
         && (IsTopLevelOfConditional(node)))
     {
         Warnings.Add(CompilerWarningFactory.EqualsInsteadOfAssign(node));
     }
 }

        public override void LeaveBinaryExpression(BinaryExpression node)
        {
            if (BinaryOperatorType.Assign != node.Operator)
                return;

            Expression newRight = Convert(node.Left.ExpressionType, node.Right);
            if (null != newRight)
                node.Right = newRight;
        }

        private MethodInvocationExpression MethodInvocationForEventSubscription(BinaryExpression node, IMethod method)
        {
            var methodTarget = CodeBuilder.CreateMemberReference(node.Left.LexicalInfo,
                ((MemberReferenceExpression)node.Left).Target, method);

            var mie = new MethodInvocationExpression(methodTarget);
            mie.Arguments.Add(node.Right);
            BindExpressionType(mie, method.ReturnType);
            return mie;
        }

 public override void LeaveBinaryExpression(BinaryExpression node)
 {
     switch (node.Operator)
     {
     case BinaryOperatorType.And:
     case BinaryOperatorType.Or:
         BindLogicalOperator(node);
         break;
     }
 }

 public override void OnBinaryExpression(BinaryExpression node)
 {
     var lhs = node.Left.ExpressionType;
     var rhs = node.Right.ExpressionType;
     base.OnBinaryExpression(node);
     var expression = GetLinqExpressionForOperator(node.Operator);
     ReplaceCurrentNode(new MethodInvocationExpression(
         ReferenceExpression.Lift(expression),
         AddOptionalConvert(rhs, lhs, node.Left),
         AddOptionalConvert(lhs, rhs, node.Right)));
 }

 public override void OnBinaryExpression(BinaryExpression node)
 {
     base.OnBinaryExpression(node);
     BinaryOperatorType type = node.get_Operator();
     if (((type == 0x1f) || (type == 30)) && (this.IsBoolean(node.get_Left()) && this.IsBoolean(node.get_Right())))
     {
         string[] strArray = (node.get_Operator() != 0x1f) ? new string[] { "||", "|" } : new string[] { "&&", "&" };
         string expectedOperator = strArray[0];
         string actualOperator = strArray[1];
         this.get_Warnings().Add(UnityScriptWarnings.BitwiseOperatorWithBooleanOperands(node.get_LexicalInfo(), expectedOperator, actualOperator));
     }
 }

 protected bool IsAssignmentToSpecialMember(BinaryExpression node)
 {
     if (BinaryOperatorType.Assign == node.Operator &&
         NodeType.MemberReferenceExpression == node.Left.NodeType)
     {
         MemberReferenceExpression memberRef = node.Left as MemberReferenceExpression;
         Expression target = memberRef.Target;
         return !IsTerminalReferenceNode(target)
             && IsSpecialMemberTarget(target);
     }
     return false;
 }

		public override void OnBinaryExpression(BinaryExpression node)
		{
			if (acceptImplicit) {
				ReferenceExpression reference = node.Left as ReferenceExpression;
				if (node.Operator == BinaryOperatorType.Assign && reference != null) {
					if (!(reference is MemberReferenceExpression)) {
						DeclarationFound(reference.Name, null, node.Right, reference.LexicalInfo);
					}
				}
			}
			base.OnBinaryExpression(node);
		}

 public override void LeaveBinaryExpression(BinaryExpression node)
 {
     CheckExpressionType(node.Right);
     if (BinaryOperatorType.ReferenceEquality == node.Operator)
     {
         if (IsTypeReference(node.Right))
         {
             Warnings.Add(
                 CompilerWarningFactory.IsInsteadOfIsa(node));
         }
     }
 }

 public void ApplyImplicitArrayConversion(BinaryExpression node)
 {
     IType expressionType = this.GetExpressionType(node.get_Left());
     if (expressionType.get_IsArray())
     {
         IType type2 = this.GetExpressionType(node.get_Right());
         if (type2 == this.UnityScriptLangArray())
         {
             node.set_Right(this.get_CodeBuilder().CreateCast(expressionType, this.get_CodeBuilder().CreateMethodInvocation(node.get_Right(), this.ResolveMethod(type2, "ToBuiltin"), this.get_CodeBuilder().CreateTypeofExpression(expressionType.get_ElementType()))));
         }
     }
 }

 void BindLogicalOperator(BinaryExpression node)
 {
     if (InjectImplicitBooleanConversions.IsLogicalCondition(node))
     {
     BindLogicalOperatorCondition(node);
     }
     else
     {
     node.Left = ExplicitBooleanContext(node.Left);
     node.Right = ExplicitBooleanContext(node.Right);
     }
 }

        public override void LeaveBinaryExpression(BinaryExpression node)
        {
            if (node.Operator != BinaryOperatorType.Assign
                || node.Right.NodeType != NodeType.IntegerLiteralExpression)
                return;

            IType expectedType = GetExpressionType(node.Left);
            if (!TypeSystemServices.IsPrimitiveNumber(expectedType))
                return;

            AssertLiteralInRange((IntegerLiteralExpression) node.Right, expectedType);
        }

 private void CheckEventUnsubscribe(BinaryExpression node, IEvent eventInfo)
 {
     CallableSignature expected = ((ICallableType) eventInfo.Type).GetSignature();
     CallableSignature actual = GetCallableSignature(node.Right);
     if (expected != actual)
     {
         Warnings.Add(
             CompilerWarningFactory.InvalidEventUnsubscribe(
                 node,
                 eventInfo.FullName,
                 expected));
     }
 }

        /// <summary>
        /// Perform the actual expansion of the macro
        /// </summary>
        /// <param name="macro">The macro.</param>
        /// <returns></returns>
        protected override Statement DoExpand(MacroStatement macro)
        {
            Block body = (Block)macro.GetAncestor(NodeType.Block);
            MacroStatement macroParent = (MacroStatement)macro.GetAncestor(NodeType.MacroStatement);
           
            if (macro.Body.Statements.Count < 1 && parent.Name=="join")
            {
                Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo, "Join " + name + " section must contain at least a single expression statement"));
                return null;
            }

            if (macro.Arguments.Count == 0 && parent.Name!="join")
            {
                Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo, "Join " + name + " section must contain at least one key column"));
                return null;
            }

            if (macro.Arguments.Count > 0)
            {
                ArrayLiteralExpression ale = new ArrayLiteralExpression(macro.LexicalInfo);
                ale.Type = new ArrayTypeReference(CodeBuilder.CreateTypeReference(typeof(string)));
                foreach (Expression argument in macro.Arguments)
                {
                    ReferenceExpression expr = argument as ReferenceExpression;
                    if (expr == null)
                    {
                        Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo,"Join " + name +" section arguments must be reference expressions. Example: " + name + " name, surname"));
                        return null;
                    }
                    ale.Items.Add(new StringLiteralExpression(expr.Name));
                }
                var keyExpr = new BinaryExpression(BinaryOperatorType.Assign, new ReferenceExpression(name+"KeyColumns"), ale);
                macroParent.Arguments.Add(keyExpr);
            }

            foreach (Statement statement in macro.Body.Statements)
            {
                ExpressionStatement exprStmt = statement as ExpressionStatement;
                if(exprStmt==null)
                {
                    Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo, "Join " + name + " section can only contain expressions"));
                    return null;
                }
                Expression expr = exprStmt.Expression;
                parent.Arguments.Add(new MethodInvocationExpression(new ReferenceExpression(name), expr));
            }

            return null;
            
        }