internal static BoundStatement AddSequencePoint(UsingStatementSyntax usingSyntax, BoundStatement rewrittenStatement)
 {
     int start = usingSyntax.Span.Start;
     int end = usingSyntax.CloseParenToken.Span.End;
     TextSpan span = TextSpan.FromBounds(start, end);
     return new BoundSequencePointWithSpan(usingSyntax, rewrittenStatement, span);
 }

 public LockChecks Start(SyntaxNodeAnalysisContext AnalysisContext,DiagnosticDescriptor rule)
 {
     this.analysisContext = AnalysisContext;
     this.usingStatement = (UsingStatementSyntax)analysisContext.Node;
     this.rule = rule;
     reportedIssue = false;
     return this;
 }

        public sealed override void VisitUsingStatement(UsingStatementSyntax node)
        {
            if (node.Expression != null)
            {
                _builder.Add(node);
            }

            base.VisitUsingStatement(node);
        }

        public UsingStatementTranslation(UsingStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
        {
            Declaration = syntax.Declaration.Get<VariableDeclarationTranslation>(this);
            Expression = syntax.Expression.Get<ExpressionTranslation>(this);
            Statement = syntax.Statement.Get<StatementTranslation>(this);

            //if(Expression != null)
            //{
            //    throw new Exception("only support Declaration");
            //}
        }

        public override void VisitUsingStatement(UsingStatementSyntax 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);
        }

        public static string UsingStatement(UsingStatementSyntax statement)
        {
            var output = SyntaxNode(statement.Declaration) + ";" + NewLine;

            output += Block((BlockSyntax)statement.Statement, false);

            //Swift calls deinit when you make a variable nil

            output += string.Join("",
                statement.Declaration.Variables.Select(variable => variable.Identifier.Text + " = nil;" + NewLine));

            return output;
        }

        public static void Go(OutputWriter writer, UsingStatementSyntax usingStatement)
        {
            var expression = usingStatement.Expression;

            writer.WriteLine("//using block ... " + usingStatement.Declaration);
            writer.OpenBrace();
            //Ensure the using statement is a local variable - we can't deal with things we can't reliably repeat in the finally block
            var resource = Utility.TryGetIdentifier(expression);
//            if (resource == null)
//                throw new Exception("Using statements must reference a local variable. " + Utility.Descriptor(usingStatement));

            var variables = new SeparatedSyntaxList<VariableDeclaratorSyntax>();//.Select(o => o.Identifier.ValueText);
            if (usingStatement.Declaration != null)
            {
                Core.Write(writer, usingStatement.Declaration);
                variables = usingStatement.Declaration.Variables;

            }

            writer.WriteLine("try");
            Core.WriteStatementAsBlock(writer, usingStatement.Statement);
            writer.WriteLine("finally");
            writer.OpenBrace();
            foreach (var variable in variables)
            {
                var typeInfo = TypeProcessor.GetTypeInfo(usingStatement.Declaration.Type);
                if (!typeInfo.Type.IsValueType)
                    writer.WriteLine("if(" + variable.Identifier.Text + " !is null)");
                else if (typeInfo.Type.Name == "Nullable")
                    writer.WriteLine("if(" + variable.Identifier.Text + ".HasValue)");


                writer.WriteLine(variable.Identifier.Text + ".Dispose(cast(IDisposable)null);");
            }
            if (resource != null)
            {
                writer.WriteLine("if(" + resource + " !is null)");
                writer.WriteLine(resource + ".Dispose(cast(IDisposable)null);");
            }
            writer.CloseBrace();
            writer.CloseBrace();
        }

        static CodeAction HandleUsingStatement(Document document, Microsoft.CodeAnalysis.Text.TextSpan span, SyntaxNode root, UsingStatementSyntax usingStatement, VariableDeclaratorSyntax variable)
        {
            return CodeActionFactory.Create(
                            span,
                            DiagnosticSeverity.Info,
                            "Iterate via 'foreach'",
                            ct =>
                            {
                                ForEachStatementSyntax foreachStmt = BuildForeach(SyntaxFactory.IdentifierName(variable.Identifier));

                                var innerBlock = usingStatement.Statement.EnsureBlock();

                                var newBlock = innerBlock.WithStatements(innerBlock.Statements.Insert(0, foreachStmt)).WithAdditionalAnnotations(Formatter.Annotation);
                                var newUsing = usingStatement.WithStatement(newBlock);
                                var newRoot = root.ReplaceNode(usingStatement, newUsing.WithTrailingTrivia(usingStatement.GetTrailingTrivia()));

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

        public override void Initialize(AnalysisContext context)
        {

            context.RegisterSyntaxNodeActionInNonGenerated(
(System.Action<SyntaxNodeAnalysisContext>)                (                c =>
{
    reportedIssue = false;
    analysisContext = (SyntaxNodeAnalysisContext)c;
    usingStatement = (UsingStatementSyntax)c.Node;

    var lockChecks = new LockChecks();
    lockChecks.Start(c, Rule);
    if (!lockChecks.isLock())
    {
        return;
    }

    SyntaxNode block = lockChecks.GetUsingBlock(ref c);
    lockChecks.LockCheckinSimpleMemberAccess(block);
    /* IfStatementSyntax firstIfStatement = lockChecks.GetFirstIfStatementInUsingBlock(block);

    lockChecks.CheckExpressionIsNotLockApplied(firstIfStatement);
    SyntaxNode ifAppliedNode = lockChecks.CheckIfStatementNotEmpty(firstIfStatement);
    lockChecks.CheckReturnOrThrow( ifAppliedNode);
    if (!"false".Equals((string)((ReturnStatementSyntax)returnStatement).Expression.ToString()))
    {
        var diagnostic = Diagnostic.Create(Rule, returnStatement.GetLocation(), "does not return literal false");
        c.ReportDiagnostic(diagnostic);
        return;
    }
    */



}),
                SyntaxKind.UsingStatement
             );

        }

 public override SyntaxNode VisitUsingStatement(UsingStatementSyntax node)
 {
     this.AppendCompileIssue(node, IssueType.Error, IssueId.UsingNotSupport);
     return node;
 }

 public UsingStatementBinder(Binder enclosing, UsingStatementSyntax syntax)
     : base(enclosing)
 {
     _syntax = syntax;
 }

        /// <summary>
        /// Handles the given using statement.
        /// </summary>
        /// <param name="stmt">Statement</param>
        /// <param name="successor">Successor</param>
        private void HandleUsingStatement(UsingStatementSyntax stmt, ControlFlowGraphNode successor)
        {
            this.SyntaxNodes.Add(stmt.Declaration);
            this.IsJumpNode = true;

            var usingNode = new ControlFlowGraphNode(this.Summary);
            this.ISuccessors.Add(usingNode);
            usingNode.IPredecessors.Add(this);

            if (stmt.Statement is BlockSyntax)
            {
                usingNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, successor);
            }
            else
            {
                usingNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, successor);
            }
        }

            private IEnumerable<ITypeSymbol> InferTypeInUsingStatement(UsingStatementSyntax usingStatement, SyntaxToken? previousToken = null)
            {
                // If we have a position, it has to be after "using("
                if (previousToken.HasValue && previousToken.Value != usingStatement.OpenParenToken)
                {
                    return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
                }

                return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_IDisposable));
            }

        public void VisitUsingStatement(UsingStatementSyntax node)
        {
            if (node == null)
                throw new ArgumentNullException("node");

            node.Validate();

            WriteLeadingTrivia(node);

            _writer.WriteIndent();
            _writer.WriteKeyword(PrinterKeyword.Using);

            if (_writer.Configuration.Spaces.BeforeParentheses.UsingParentheses)
                _writer.WriteSpace();

            _writer.WriteSyntax(Syntax.OpenParen);

            if (_writer.Configuration.Spaces.WithinParentheses.UsingParentheses)
                _writer.WriteSpace();

            if (node.Expression != null)
                node.Expression.Accept(this);
            if (node.Declaration != null)
                node.Declaration.Accept(this);

            if (_writer.Configuration.Spaces.WithinParentheses.UsingParentheses)
                _writer.WriteSpace();

            _writer.WriteSyntax(Syntax.CloseParen);

            if (
                _writer.Configuration.Other.Other.IndentNestedUsingStatements &&
                node.Statement is UsingStatementSyntax
            ) {
                _writer.WriteLine();
                node.Statement.Accept(this);
            }
            else
            {
                VisitBlockStatement(node.Statement);
            }

            WriteTrailingTrivia(node);
        }

 public UsingStatementBinder(MethodSymbol owner, Binder enclosing, UsingStatementSyntax syntax)
     : base(owner, enclosing)
 {
     this.syntax = syntax;
     this.expressionHandler = syntax.Expression == null ? null : new LockOrUsingStatementExpressionHandler(syntax.Expression, this);
 }

 private BoundStatement BindUsingStatement(UsingStatementSyntax node, DiagnosticBag diagnostics)
 {
     var usingBinder = this.GetBinder(node);
     Debug.Assert(usingBinder != null);
     return usingBinder.BindUsingStatementParts(diagnostics, usingBinder);
 }

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

                AddExpressionTerms(node.Expression, _expressions);
            }

 private static bool AreEquivalentActiveStatements(UsingStatementSyntax oldNode, UsingStatementSyntax newNode)
 {
     // only check the expression/declaration, edits in the body are allowed:
     return AreEquivalentIgnoringLambdaBodies(
         (SyntaxNode)oldNode.Declaration ?? oldNode.Expression,
         (SyntaxNode)newNode.Declaration ?? newNode.Expression);
 }

        public override void VisitUsingStatement(UsingStatementSyntax node)
        {
            Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda);
            var usingBinder = new UsingStatementBinder(_enclosing, node);
            AddToMap(node, usingBinder);

            ExpressionSyntax expressionSyntax = node.Expression;
            VariableDeclarationSyntax declarationSyntax = node.Declaration;

            Debug.Assert((expressionSyntax == null) ^ (declarationSyntax == null)); // Can't have both or neither.

            if (expressionSyntax != null)
            {
                Visit(expressionSyntax, usingBinder);
            }
            else
            {
                foreach (VariableDeclaratorSyntax declarator in declarationSyntax.Variables)
                {
                    Visit(declarator, usingBinder);
                }
            }

            VisitPossibleEmbeddedStatement(node.Statement, usingBinder);
        }

            protected override void VisitUsingStatementDeclarations(UsingStatementSyntax node)
            {
                // Expecting one synthesized local for using statement with no explicit declaration.
                if (node.Declaration == null)
                {
                    Debug.Assert(node.Expression != null);

                    TryGetSlotIndex(SynthesizedLocalKind.Using);
                    this.offset++;
                }
            }