public static LockStatementSyntax AddBraces(LockStatementSyntax lockStatement)
        {
            Debug.Assert(lockStatement != null && NeedsBraces(lockStatement));

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

 public static void Go(OutputWriter writer, LockStatementSyntax statement)
 {
     //All d objects implement a lock
     writer.WriteLine("synchronized(" + Core.WriteString(statement.Expression)+")");
     writer.OpenBrace();
     Core.WriteStatementAsBlock(writer, statement.Statement, false);
     writer.CloseBrace();
 }

        public override void VisitLockStatement(LockStatementSyntax node)
        {
            string name = "LOCK_Statement";

            if (ConsultingAnalysisResult.libraryUsage.ContainsKey(name))
                ConsultingAnalysisResult.libraryUsage[name]++;
            else
                ConsultingAnalysisResult.libraryUsage[name] = 1;
            base.VisitLockStatement(node);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 public override sealed void VisitLockStatement(LockStatementSyntax node)
 {
     this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
     base.VisitLockStatement(node);
 }

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

 private BoundStatement BindLockStatement(LockStatementSyntax node, DiagnosticBag diagnostics)
 {
     var lockBinder = this.GetBinder(node);
     Debug.Assert(lockBinder != null);
     return lockBinder.BindLockStatementParts(diagnostics, lockBinder);
 }

 public sealed override void VisitLockStatement(LockStatementSyntax node)
 {
     _builder.Add(node);
     base.VisitLockStatement(node);
 }

            private IEnumerable<ITypeSymbol> InferTypeInLockStatement(LockStatementSyntax lockStatement, SyntaxToken? previousToken = null)
            {
                // If we're position based, then we have to be after the "lock("
                if (previousToken.HasValue && previousToken.Value != lockStatement.OpenParenToken)
                {
                    return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
                }

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

        public override void VisitLockStatement(LockStatementSyntax node)
        {
            string name = "LOCK_Statement";
            var libraryUsage = Result.LibraryUsage;
      
            int temp;
            libraryUsage.TryGetValue(name, out temp);
            libraryUsage[name] = ++temp;

            base.VisitLockStatement(node);
        }

 public override void VisitLockStatement(LockStatementSyntax node)
 {
     Visit(node.Expression);
 }

            protected override void VisitLockStatementDeclarations(LockStatementSyntax node)
            {
                Debug.Assert(node.Expression != null);
               
                 // Expecting one or two locals depending on which overload of Monitor.Enter is used.
                if (TryGetSlotIndex(SynthesizedLocalKind.Lock) != null)
                {
                    // If the next local is LockTaken, then the lock was emitted with the two argument
                    // overload for Monitor.Enter(). Otherwise, the single argument overload was used.
                    if (IsSlotIndex(SynthesizedLocalKind.LockTaken))
                    {
                        AddSynthesizedLocal(SynthesizedLocalKind.LockTaken);
                    }
                }

                this.offset++;
            }

        public static bool NeedsBraces(LockStatementSyntax lockStatement)
        {
            if (lockStatement == null)
            {
                throw new ArgumentNullException("lockStatement");
            }

            return lockStatement.Statement != null
                && !lockStatement.Statement.IsKind(SyntaxKind.Block);
        }

 public override void VisitLockStatement(LockStatementSyntax node)
 {
     AddExpressionTerms(node.Expression, _expressions);
 }

        public void VisitLockStatement(LockStatementSyntax node)
        {
            if (node == null)
                throw new ArgumentNullException("node");

            node.Validate();

            WriteLeadingTrivia(node);

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

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

            _writer.WriteSyntax(Syntax.OpenParen);

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

            node.Expression.Accept(this);

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

            _writer.WriteSyntax(Syntax.CloseParen);

            VisitBlockStatement(node.Statement);

            WriteTrailingTrivia(node);
        }

 public void Flatten(LockStatementSyntax node, List<FlatStatement> instructions)
 {
     /*
     public SyntaxToken CloseParenToken { get; }
     public ExpressionSyntax Expression { get; }
     public SyntaxToken LockKeyword { get; }
     public SyntaxToken OpenParenToken { get; }
     public StatementSyntax Statement { get; }
      */
     throw new NotImplementedException("lock");
 }

 protected abstract void VisitLockStatementDeclarations(LockStatementSyntax node);

 public sealed override void VisitLockStatement(LockStatementSyntax node)
 {
     this.VisitLockStatementDeclarations(node);
     base.VisitLockStatement(node);
 }

 public LockBinder(Binder enclosing, LockStatementSyntax syntax)
     : base(enclosing)
 {
     this.syntax = syntax;
     this.expressionHandler = new LockOrUsingStatementExpressionHandler(syntax.Expression, this);
 }

 public override void VisitLockStatement(LockStatementSyntax node)
 {
     throw new NotSupportedException();
 }

        public override void VisitLockStatement(LockStatementSyntax node)
        {
            var patternBinder = new PatternVariableBinder(node, _enclosing);
            var lockBinder = new LockBinder(patternBinder, node);
            AddToMap(node, lockBinder);

            Visit(node.Expression, lockBinder);

            StatementSyntax statement = node.Statement;
            var statementBinder = lockBinder.WithAdditionalFlags(BinderFlags.InLockBody);
            if (statementBinder != lockBinder)
            {
                AddToMap(statement, statementBinder);
            }

            VisitPossibleEmbeddedStatement(statement, statementBinder);
        }