static CodeAction AddIsNaNIssue(Document document, SemanticModel semanticModel, SyntaxNode root, BinaryExpressionSyntax node, ExpressionSyntax argExpr, string floatType)
 {
     return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Warning, string.Format(node.IsKind(SyntaxKind.EqualsExpression) ? "Replace with '{0}.IsNaN(...)' call" : "Replace with '!{0}.IsNaN(...)' call", floatType), token =>
     {
         SyntaxNode newRoot;
         ExpressionSyntax expr;
         var arguments = new SeparatedSyntaxList<ArgumentSyntax>();
         arguments = arguments.Add(SyntaxFactory.Argument(argExpr));
         expr = SyntaxFactory.InvocationExpression(
             SyntaxFactory.MemberAccessExpression(
                 SyntaxKind.SimpleMemberAccessExpression,
                 SyntaxFactory.ParseExpression(floatType),
                 SyntaxFactory.IdentifierName("IsNaN")
             ),
             SyntaxFactory.ArgumentList(
                 arguments
             )
         );
         if (node.IsKind(SyntaxKind.NotEqualsExpression))
             expr = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, expr);
         expr = expr.WithAdditionalAnnotations(Formatter.Annotation);
         newRoot = root.ReplaceNode((SyntaxNode)node, expr);
         return Task.FromResult(document.WithSyntaxRoot(newRoot));
     });
 }

 internal static ExpressionSyntax GetOuterLeft(BinaryExpressionSyntax bop)
 {
     var leftBop = bop.Left as BinaryExpressionSyntax;
     if (leftBop != null && bop.OperatorToken.IsKind(leftBop.OperatorToken.Kind()))
         return GetOuterLeft(leftBop);
     return bop.Left;
 }

        public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
        {
            var based = base.VisitBinaryExpression (node);

            if (node.Left.FindIdentifierName() == null)
                return node;

            switch (node.Kind)
            {
                case SyntaxKind.AddAssignExpression:
                case SyntaxKind.OrAssignExpression:
                case SyntaxKind.SubtractAssignExpression:
                case SyntaxKind.MultiplyAssignExpression:
                case SyntaxKind.DivideAssignExpression:
                case SyntaxKind.ModuloAssignExpression:
                case SyntaxKind.RightShiftAssignExpression:
                case SyntaxKind.LeftShiftAssignExpression:
                case SyntaxKind.AndAssignExpression:
                case SyntaxKind.ExclusiveOrAssignExpression:
                case SyntaxKind.AssignExpression:
                    return based.WithTrailingTrivia (based.GetTrailingTrivia().Prepend (GetIdComment()));

                default:
                    return node;
            }
        }

        protected override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
        {
            var nameSyntax = FindIdentifierName (node.Left);
            if (nameSyntax == null)
                return base.VisitBinaryExpression (node);

            switch (node.Kind)
            {
                case SyntaxKind.AddAssignExpression:
                case SyntaxKind.OrAssignExpression:
                case SyntaxKind.SubtractAssignExpression:
                case SyntaxKind.MultiplyAssignExpression:
                case SyntaxKind.DivideAssignExpression:
                case SyntaxKind.ModuloAssignExpression:
                case SyntaxKind.RightShiftAssignExpression:
                case SyntaxKind.LeftShiftAssignExpression:
                case SyntaxKind.AndAssignExpression:
                case SyntaxKind.ExclusiveOrAssignExpression:
                    var token = Syntax.Token (GetComplexAssignOperator (node.Kind));

                    ExpressionSyntax expr = Syntax.ParseExpression (nameSyntax.PlainName + token + node.Right);

                    return node.Update (node.Left, AssignToken, GetLogExpression (nameSyntax.PlainName, expr));

                case SyntaxKind.AssignExpression:
                    return node.Update (node.Left, node.OperatorToken, GetLogExpression (nameSyntax.PlainName, node.Right));

                default:
                    return base.VisitBinaryExpression (node);
            }
        }

 static bool TryFlip(BinaryExpressionSyntax expr, out SyntaxKind flippedKind, out string operatorText)
 {
     switch (expr.Kind())
     {
         case SyntaxKind.LessThanExpression:
             flippedKind = SyntaxKind.GreaterThanExpression;
             operatorText = ">";
             return true;
         case SyntaxKind.LessThanOrEqualExpression:
             flippedKind = SyntaxKind.GreaterThanOrEqualExpression;
             operatorText = ">=";
             return true;
         case SyntaxKind.GreaterThanExpression:
             flippedKind = SyntaxKind.LessThanExpression;
             operatorText = "<";
             return true;
         case SyntaxKind.GreaterThanOrEqualExpression:
             flippedKind = SyntaxKind.LessThanOrEqualExpression;
             operatorText = "<=";
             return true;
     }
     flippedKind = SyntaxKind.None;
     operatorText = null;
     return false;
 }

 public BoundBinaryExpression(BoundExpression left, BoundExpression right, BinaryOperators @operator, BinaryExpressionSyntax binaryExpressionSyntax, IType type)
     : base(binaryExpressionSyntax, type)
 {
     Left = left;
     Right = right;
     Operator = @operator;
 }

 ExpressionSyntax GenerateTarget(SemanticModel model, BinaryExpressionSyntax node)
 {
     var symbols = model.LookupSymbols(node.SpanStart).OfType<IMethodSymbol>();
     if (!symbols.Any() || HasDifferentEqualsMethod(symbols))
         return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseExpression("object"), SyntaxFactory.IdentifierName("Equals"));
     else
         return SyntaxFactory.IdentifierName("Equals");
 }

        static Document PerformAction(Document document, SyntaxNode root, BinaryExpressionSyntax bop)
        {
            var nodeToReplace = bop.IsParentKind(SyntaxKind.ParenthesizedExpression) ? bop.Parent : bop;
            var castExpr = (ExpressionSyntax)SyntaxFactory.CastExpression(bop.Right as TypeSyntax, CSharpUtil.AddParensIfRequired(bop.Left.WithoutLeadingTrivia().WithoutTrailingTrivia())).WithLeadingTrivia(bop.GetLeadingTrivia()).WithTrailingTrivia(bop.GetTrailingTrivia());

            var newRoot = root.ReplaceNode((SyntaxNode)nodeToReplace, castExpr);
            return document.WithSyntaxRoot(newRoot);
        }

 public BoundBinaryExpression(BinaryExpressionSyntax syntax, BinaryOperatorKind operatorKind, BoundExpression left, BoundExpression right, TypeSymbol type)
     : base(BoundNodeKind.BinaryExpression, syntax)
 {
     OperatorKind = operatorKind;
     Left = left;
     Right = right;
     Type = type;
 }

 internal static SyntaxNode ComputeExpression(SyntaxNode nodeToReplace, BinaryExpressionSyntax expression, SyntaxNode root, SemanticModel semanticModel)
 {
     var result = semanticModel.GetConstantValue(expression);
     if (!result.HasValue) return null;
     var newExpression = SyntaxFactory.ParseExpression(System.Convert.ToString(result.Value, System.Globalization.CultureInfo.InvariantCulture));
     var newRoot = root.ReplaceNode(nodeToReplace, newExpression);
     return newRoot;
 }

 private static SyntaxNode CalculateNewRoot(SyntaxNode root, BinaryExpressionSyntax currentAsBinary)
 {
     return root.ReplaceNode(currentAsBinary,
         SyntaxFactory.ConcatenateExpression(
             currentAsBinary.Left,
             SyntaxFactory.Token(SyntaxKind.AmpersandToken).WithTriviaFrom(currentAsBinary.OperatorToken),
             currentAsBinary.Right));
 }

		/// <summary>
		///   Normalizes the <paramref name="binaryExpression" />.
		/// </summary>
		public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax binaryExpression)
		{
			if (!IsFormulaType(binaryExpression))
				return base.VisitBinaryExpression(binaryExpression);

			var left = ReplaceImplicitConversion(binaryExpression.Left);
			var right = ReplaceImplicitConversion(binaryExpression.Right);
			return binaryExpression.Update(left, binaryExpression.OperatorToken, right);
		}

 private static BinaryExpressionSyntax ChangeOperator(BinaryExpressionSyntax binary)
 {
     return
         SyntaxFactory.BinaryExpression(
             OppositeExpressionKinds[binary.Kind()],
             binary.Left,
             binary.Right)
         .WithTriviaFrom(binary);
 }

 private static void AnalyzeBinaryExpression(BinaryExpressionSyntax node, SemanticModel model, Action<Diagnostic> addDiagnostic)
 {
     var leftType = model.GetTypeInfo(node.Left).Type;
     var rightType = model.GetTypeInfo(node.Right).Type;
     if (leftType != null && rightType != null && leftType.SpecialType == SpecialType.System_String && rightType.SpecialType == SpecialType.System_String)
     {
         addDiagnostic(node.OperatorToken.GetLocation().CreateDiagnostic(Rule));
     }
 }

        public static void Go(OutputWriter writer, BinaryExpressionSyntax expression)
        {
            var leftExpression = expression.Left;
            var rightExpression = expression.Right;

            var operatorToken = expression.OperatorToken;
             
            WriteIt(writer, operatorToken, rightExpression, leftExpression);
        }

        public static IEnumerable<ReplaceAction> GetSimplifications(BinaryExpressionSyntax b, ISemanticModel model, Assumptions assume, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (!b.Left.DefinitelyHasBooleanType(model)) yield break;
            if (!b.Right.DefinitelyHasBooleanType(model)) yield break;

            // prep basic analysis
            var leftEffects = b.Left.HasSideEffects(model, assume) != false;
            var rightEffects = b.Right.HasSideEffects(model, assume) != false;
            var lv = b.Left.TryGetConstBoolValue();
            var rv = b.Right.TryGetConstBoolValue();
            var cmp = b.Left.TryEvalAlternativeComparison(b.Right, model, assume);

            // prep utility funcs for adding simplifications
            var actions = new List<ReplaceAction>();
            Action<String, ExpressionSyntax> include = (desc, rep) =>
                actions.Add(new ReplaceAction(desc, b, rep));
            Action<bool> useRight = v => {
                if (!leftEffects)
                    include(v ? "rhs" : "!rhs", b.Right.MaybeInverted(!v));
            };
            Action<bool> useLeft = v => {
                if (!rightEffects)
                    include(v ? "lhs" : "!lhs", b.Left.MaybeInverted(!v));
            };
            Action<bool> useBool = v => {
                if (!leftEffects && !rightEffects) {
                    actions.Clear(); // override left/right
                    include(v + "", v.AsLiteral());
                }
            };

            // try to simplify equality operators ==, !=, ^
            bool? equality = null;
            if (b.Kind == SyntaxKind.EqualsExpression) equality = true;
            if (b.Kind == SyntaxKind.ExclusiveOrExpression || b.Kind == SyntaxKind.NotEqualsExpression) equality = false;
            if (equality != null) {
                if (lv != null) useRight(lv == equality);
                if (rv != null) useLeft(rv == equality);
                if (cmp != null) useBool(cmp == equality);
            }

            // try to simplify and/or operators &&, &, ||, |
            var sticky = b.Kind.IsAndBL() ? false
                       : b.Kind.IsOrBL() ? true
                       : (bool?)null;
            if (sticky != null) {
                if (b.Kind.IsShortCircuitingLogic() && lv == sticky) rightEffects = false; // short-circuit prevents effects
                if (cmp == true || lv == !sticky) useRight(true);
                if (cmp == true || rv == !sticky) useLeft(true);
                if (cmp == false || lv == sticky || rv == sticky) useBool(sticky.Value);
            }

            // expose simplifications as code issues/actions
            foreach (var action in actions)
                yield return action;
        }

		/// <summary>
		///     Normalizes the <paramref name="binaryExpression" />.
		/// </summary>
		public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax binaryExpression)
		{
			var expressionType = DetermineType(binaryExpression);
			if (expressionType == ExpressionType.Other)
				return base.VisitBinaryExpression(binaryExpression);

			var left = ReplaceImplicitConversion(expressionType, binaryExpression.Left);
			var right = ReplaceImplicitConversion(expressionType, binaryExpression.Right);
			return binaryExpression.Update(left, binaryExpression.OperatorToken, right);
		}

        private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, BinaryExpressionSyntax syntax)
        {
            var newNode = SyntaxFactory.ParenthesizedExpression(syntax.WithoutTrivia())
                .WithTriviaFrom(syntax)
                .WithoutFormatting();

            var newSyntaxRoot = root.ReplaceNode(syntax, newNode);

            return Task.FromResult(document.WithSyntaxRoot(newSyntaxRoot));
        }

 internal static SyntaxNode CreateNestedIf(BinaryExpressionSyntax condition, SyntaxNode root)
 {
     var ifStatement = condition.FirstAncestorOfType<IfStatementSyntax>();
     var nestedIf = SyntaxFactory.IfStatement(condition.Right, ifStatement.Statement);
     var newStatement = ifStatement.Statement.IsKind(SyntaxKind.Block) ? (StatementSyntax)SyntaxFactory.Block(nestedIf) : nestedIf;
     var newIf = ifStatement.WithCondition(condition.Left)
         .WithStatement(newStatement)
         .WithAdditionalAnnotations(Formatter.Annotation);
     var newRoot = root.ReplaceNode(ifStatement, newIf);
     return newRoot;
 }

        private async Task<Document> IntegrateStringsAsync(Document document, BinaryExpressionSyntax addExpression, CancellationToken cancellationToken)
        {
            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

            var newExpression = ToIntegratedString(addExpression.Left, addExpression.Right);

            var newRoot = root.ReplaceNode(addExpression, newExpression);

            var newDocument = document.WithSyntaxRoot(newRoot);

            return newDocument;
        }