static bool HasAcceptableIncrementors(ForStatementSyntax @for)
 {
     if (@for.Incrementors.Count != 1) return false;
     var unary = @for.Incrementors[0] as PostfixUnaryExpressionSyntax;
     if (unary == null) return false;
     return unary.IsKind(SyntaxKind.PostIncrementExpression) || unary.IsKind(SyntaxKind.PostDecrementExpression);
 }

        static bool AreDeclarationConditionAndIncrementorUsingTheSameVariable(ForStatementSyntax @for)
        {
            SyntaxToken reference;

            if (@for.Declaration != null)
            {
                reference = @for.Declaration.Variables[0].Identifier;
            }
            else
            {
                var initializer = @for.Initializers[0] as AssignmentExpressionSyntax;
                if (initializer == null) return false;
                var name = initializer.Left as IdentifierNameSyntax;
                if (name == null) return false;
                reference = name.Identifier;
            }

            var condition = @for.Condition as BinaryExpressionSyntax;
            var incrementor = @for.Incrementors[0] as PostfixUnaryExpressionSyntax;

            if (!(condition.Left is IdentifierNameSyntax)) return false;
            if (!(incrementor.Operand is IdentifierNameSyntax)) return false;

            var conditionVariableIdentifier = (condition.Left as IdentifierNameSyntax).Identifier;
            var incrementorVariableIdentifier = (incrementor.Operand as IdentifierNameSyntax).Identifier;

            return reference.Text == conditionVariableIdentifier.Text
                && reference.Text == incrementorVariableIdentifier.Text;
        }

        private BoundForStatement BindForParts(ForStatementSyntax node, Binder originalBinder, DiagnosticBag diagnostics)
        {
            BoundStatement initializer;
            if (node.Declaration != null)
            {
                Debug.Assert(node.Initializers.Count == 0);
                if (node.Declaration.IsDeconstructionDeclaration)
                {
                    initializer = originalBinder.BindDeconstructionDeclaration(node.Declaration, node.Declaration, diagnostics);
                }
                else
                {
                    ImmutableArray<BoundLocalDeclaration> unused;
                    initializer = originalBinder.BindForOrUsingOrFixedDeclarations(node.Declaration, LocalDeclarationKind.ForInitializerVariable, diagnostics, out unused);
                }
            }
            else
            {
                initializer = originalBinder.BindStatementExpressionList(node.Initializers, diagnostics);
            }

            var condition = (node.Condition != null) ? originalBinder.BindBooleanExpression(node.Condition, diagnostics) : null;
            var increment = originalBinder.BindStatementExpressionList(node.Incrementors, diagnostics);
            var body = originalBinder.BindPossibleEmbeddedStatement(node.Statement, diagnostics);

            Debug.Assert(this.Locals == this.GetDeclaredLocalsForScope(node));
            return new BoundForStatement(node,
                                         this.Locals,
                                         initializer,
                                         condition,
                                         increment,
                                         body,
                                         this.BreakLabel,
                                         this.ContinueLabel);
        }

        public static ForStatementSyntax AddBraces(ForStatementSyntax forStatement)
        {
            Debug.Assert(forStatement != null && NeedsBraces(forStatement));

            return forStatement
                .WithStatement(SyntaxFactory.Block(forStatement.Statement))
                .WithAdditionalAnnotations(Formatter.Annotation);
        }

        public override void VisitForStatement(ForStatementSyntax node)
        {
            if (node.Condition != null)
            {
                _builder.Add(node);
            }

            base.VisitForStatement(node);
        }

        public override void VisitForStatement(ForStatementSyntax node)
        {
            if (!(node.Statement is BlockSyntax))
            {
                CreateAuditVariable(node.Statement);
            }

            base.VisitForStatement(node);
        }

 static bool HasConditionCompatibleWithTheIncrementor(ForStatementSyntax @for)
 {
     var condition = @for.Condition as BinaryExpressionSyntax;
     var postIncrement = IsPostIncrement(@for.Incrementors[0]);
     return condition != null &&
         (
             (postIncrement && condition.OperatorToken.IsKind(SyntaxKind.LessThanToken)) ||
             (!postIncrement && condition.OperatorToken.IsKind(SyntaxKind.GreaterThanEqualsToken))
         );
 }

        internal ForInitializerBlock(ForStatementSyntax forNode, Block successor)
            : base(successor)
        {
            if (forNode == null)
            {
                throw new ArgumentNullException(nameof(forNode));
            }

            ForNode = forNode;
        }

        public static string ForStatement(ForStatementSyntax statement)
        {
            var output = "for ";

            output += SyntaxNode(statement.Declaration) + "; " + SyntaxNode(statement.Condition) + "; " + //TODO: these semicolons should be handled in their syntaxParsers
                      SyntaxNode(statement.Incrementors.First()).TrimEnd(); //TODO: handle multiple incrementors

            output += " " + SyntaxNode(statement.Statement);
            return output;
        }

            public override void VisitForStatement(ForStatementSyntax node)
            {
                if (node.Declaration != null)
                {
                    AddVariableExpressions(node.Declaration.Variables, _expressions);
                }

                node.Initializers.Do(i => AddExpressionTerms(i, _expressions));
                AddExpressionTerms(node.Condition, _expressions);
                node.Incrementors.Do(i => AddExpressionTerms(i, _expressions));
            }

        public override void VisitForStatement(ForStatementSyntax forStatement)
        {
            var initializers = string.Join(" ", forStatement.Initializers.Select(o => o.ToString()));
            var condition = forStatement.Condition?.ToString();
            var interator = string.Join(" ", forStatement.Incrementors.Select(o => o.ToString()));
            var expression = $"for ({initializers}; {condition}; {interator})";

            var token = CreateBlock(expression, SDNodeRole.ForLoop);
            _tokenList.Add(token);

            VisitChildren(token.Statements, forStatement.Statement);
        }

            public override SyntaxNode VisitForStatement(ForStatementSyntax node)
            {
                node = (ForStatementSyntax)base.VisitForStatement(node);

                if (!node.Statement.IsKind(SyntaxKind.Block))
                {
                    this.addedAnnotations = true;
                    node = node.WithStatement(SyntaxFactory.Block(node.Statement));
                }

                return node;
            }

        public ForStatementTranslation(ForStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
        {
            //KeyValuePair<int, string>? a = null;            
            //var b = ((bool?)null)?.Equals(false) ?? true ? false ? true : false :true;

            //string str = "\{ ("\{( "(\{ "{}" })" )}") }";

            Condition = syntax.Condition.Get<ExpressionTranslation>(this);
            Declaration = syntax.Declaration.Get<VariableDeclarationTranslation>(this);
            Incrementors = syntax.Incrementors.Get<ExpressionSyntax, ExpressionTranslation>(this);
            Initializers = syntax.Initializers.Get<ExpressionSyntax, ExpressionTranslation>(this);
            Statement = syntax.Statement.Get<StatementTranslation>(this);
        }

        public override void VisitForStatement(ForStatementSyntax node)
        {
            var tokens = new List<SyntaxToken>();

            if (node.Declaration != null)
            {
                tokens.AddRange(node.Declaration.Variables.Select(v => v.Identifier));
            }

            tracker.AddIdentifiers(tokens);
            Visit(node.Statement);
            tracker.RemoveIdentifiers(tokens);
        }

        private BoundForStatement BindForParts(ForStatementSyntax node, Binder originalBinder, DiagnosticBag diagnostics)
        {
            BoundStatement initializer;
            // Declaration and Initializers are mutually exclusive.
            if (_syntax.Declaration != null)
            {
                ImmutableArray<BoundLocalDeclaration> unused;
                initializer = originalBinder.BindForOrUsingOrFixedDeclarations(node.Declaration, LocalDeclarationKind.RegularVariable, diagnostics, out unused);
            }
            else
            {
                initializer = originalBinder.BindStatementExpressionList(node.Initializers, diagnostics);
            }

            BoundExpression condition = null;
            var innerLocals = ImmutableArray<LocalSymbol>.Empty;
            ExpressionSyntax conditionSyntax = node.Condition;
            if (conditionSyntax != null)
            {
                originalBinder = originalBinder.GetBinder(conditionSyntax);
                condition = originalBinder.BindBooleanExpression(conditionSyntax, diagnostics);
                innerLocals = originalBinder.GetDeclaredLocalsForScope(conditionSyntax);
            }

            BoundStatement increment = null;
            SeparatedSyntaxList<ExpressionSyntax> incrementors = node.Incrementors;
            if (incrementors.Count > 0)
            {
                var scopeDesignator = incrementors.First();
                var incrementBinder = originalBinder.GetBinder(scopeDesignator);
                increment = incrementBinder.WrapWithVariablesIfAny(scopeDesignator, incrementBinder.BindStatementExpressionList(incrementors, diagnostics));
            }

            var body = originalBinder.BindPossibleEmbeddedStatement(node.Statement, diagnostics);

            Debug.Assert(this.Locals == this.GetDeclaredLocalsForScope(node));
            return new BoundForStatement(node,
                                         this.Locals,
                                         initializer,
                                         innerLocals,
                                         condition,
                                         increment,
                                         body,
                                         this.BreakLabel,
                                         this.ContinueLabel);
        }

 private static async Task<Document> ConvertToDecrementingCounterForLoopAsync(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
 {
     var condition = (BinaryExpressionSyntax)@for.Condition;
     var newEndValue = @for.Declaration != null
         ? @for.Declaration.Variables[0].Initializer.Value
         : (@for.Initializers[0] as AssignmentExpressionSyntax).Right;
     var newStartValue = SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, condition.Right, One);
     var newDeclaration = ReplaceStartValue(@for.Declaration, newStartValue);
     var newInitializers = ReplaceStartValue(@for.Initializers, newStartValue);
     var newCondition = condition
         .WithOperatorToken(SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken))
         .WithRight(newEndValue);
     return await ReplaceForAsync(document, @for,
         newDeclaration,
         newInitializers,
         newCondition,
         cancellationToken);
 }

        public override void VisitForStatement(ForStatementSyntax node)
        {
            foreach (var invocation in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
            {
                var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(invocation).Symbol;
                if (symbol!=null && symbol.IsTaskCreationMethod())
                {
                    Logs.TempLog.Info("{0}{1}--------------------------", Document.FilePath, node.Parent.ToLog());
                    break;
                }
                if (symbol != null && symbol.IsThreadStart())
                {
                    Logs.TempLog4.Info("{0}{1}--------------------------", Document.FilePath, node.Parent.ToLog());
                    break;
                }
            }

            base.VisitForStatement(node);
        }

 public BoundForStatement BindFor(ForStatementSyntax node, DiagnosticBag diagnostics)
 {
     var loopBinder = this.GetBinder(node);
     Debug.Assert(loopBinder != null);
     return loopBinder.BindForParts(diagnostics, loopBinder);
 }

 public ForLoopBinder(Binder enclosing, ForStatementSyntax syntax)
     : base(enclosing)
 {
     Debug.Assert(syntax != null);
     _syntax = syntax;
 }

        public override void VisitForStatement(ForStatementSyntax node)
        {
            Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda);
            Binder binder = new ForLoopBinder(_enclosing, node);
            AddToMap(node, binder);

            var declaration = node.Declaration;
            if (declaration != null)
            {
                foreach (var variable in declaration.Variables)
                {
                    Visit(variable, binder);
                }
            }
            else
            {
                foreach (var initializer in node.Initializers)
                {
                    Visit(initializer, binder);
                } 
            }

            ExpressionSyntax condition = node.Condition;
            if (condition != null)
            {
                binder = new ExpressionVariableBinder(condition, binder);
                AddToMap(condition, binder);
                Visit(condition, binder);
            }

            SeparatedSyntaxList<ExpressionSyntax> incrementors = node.Incrementors;
            if (incrementors.Count > 0)
            {
                var incrementorsBinder = new ExpressionListVariableBinder(incrementors, binder);
                AddToMap(incrementors.First(), incrementorsBinder);
                foreach (var incrementor in incrementors)
                {
                    Visit(incrementor, incrementorsBinder);
                }
            }

            VisitPossibleEmbeddedStatement(node.Statement, binder);
        }