internal static BoundNode Rewrite(CSharpCompilation compilation, EENamedTypeSymbol container, HashSet<LocalSymbol> declaredLocals, BoundNode node)
        {
            var builder = ArrayBuilder<BoundStatement>.GetInstance();
            bool hasChanged;

            // Rewrite top-level declarations only.
            switch (node.Kind)
            {
                case BoundKind.LocalDeclaration:
                    RewriteLocalDeclaration(compilation, container, declaredLocals, builder, (BoundLocalDeclaration)node);
                    hasChanged = true;
                    break;
                case BoundKind.MultipleLocalDeclarations:
                    foreach (var declaration in ((BoundMultipleLocalDeclarations)node).LocalDeclarations)
                    {
                        RewriteLocalDeclaration(compilation, container, declaredLocals, builder, declaration);
                    }
                    hasChanged = true;
                    break;
                default:
                    hasChanged = false;
                    break;
            }

            if (hasChanged)
            {
                node = new BoundBlock(node.Syntax, ImmutableArray<LocalSymbol>.Empty, builder.ToImmutable()) { WasCompilerGenerated = true };
            }

            builder.Free();
            return node;
        }

 public override BoundNode Visit(BoundNode node)
 {
     if (_mayHaveSideEffects)
     {
         return null;
     }
     return base.Visit(node);
 }

 public override BoundNode Visit(BoundNode node)
 {
     var expression = node as BoundExpression;
     if (expression != null)
     {
         _typeParameterChecker.Visit(expression.ExpressionSymbol);
     }
     return base.Visit(node);
 }

        protected override void Visit(BoundNode node)
        {
            if (node != null && node.Syntax != null)
            {
                NoteLocation(node.Syntax.Span);
            }

            base.Visit(node);
        }

 internal static BoundNode Rewrite(
     ParameterSymbol targetMethodThisParameter,
     Conversions conversions,
     ImmutableDictionary<string, DisplayClassVariable> displayClassVariables,
     BoundNode node,
     DiagnosticBag diagnostics)
 {
     var rewriter = new CapturedVariableRewriter(targetMethodThisParameter, conversions, displayClassVariables, diagnostics);
     return rewriter.Visit(node);
 }

 public override BoundNode Visit(BoundNode node)
 {
     var expression = node as BoundExpression;
     if (expression != null)
     {
         var constantValue = expression.ConstantValue;
         if (constantValue != null && constantValue.IsDecimal)
         {
             return RewriteConstant(expression);
         }
     }
     return base.Visit(node);
 }

		/// <summary>
		///     Classifies the operations performed on the <paramref name="variable" /> within the <paramref name="node" />.
		/// </summary>
		/// <param name="node">The node of a bound tree the <paramref name="variable" /> should be classified for.</param>
		/// <param name="variable">The variable that should be classified.</param>
		public static VariableOperations Classify(BoundNode node, VariableMetadata variable)
		{
			Requires.NotNull(node, () => node);
			Requires.NotNull(variable, () => variable);

			_instance._writeContext = 0;
			_instance._operations = VariableOperations.None;
			_instance._variable = variable;
			_instance.Visit(node);

			Assert.That(_instance._writeContext == 0, "Unbalanced write context operations.");
			return _instance._operations;
		}

 internal static IEnumerable<StatementSyntax> Analyze(Compilation compilation, MethodSymbol sourceMethod, BoundNode node, BoundNode firstInRegion, BoundNode lastInRegion)
 {
     var walker = new ReturnStatementsWalker(compilation, sourceMethod, node, firstInRegion, lastInRegion);
     try
     {
         bool badRegion = false;
         walker.Analyze(ref badRegion);
         return badRegion ? Enumerable.Empty<StatementSyntax>() : walker.returnStatements.ToArray();
     }
     finally
     {
         walker.Free();
     }
 }

 public override BoundNode Visit(BoundNode node)
 {
     if (found == null)
     {
         if (node != null && !node.WasCompilerGenerated && node.Syntax == syntax)
         {
             found = node;
         }
         else
         {
             base.Visit(node);
         }
     }
     return null;
 }

 public override BoundNode Visit(BoundNode node)
 {
     if (node != null) //e.g. static method invocations have null receivers
     {
         _list.Add(node);
     }
     return base.Visit(node);
 }

 public static IEnumerable<BoundNode> GetNodes(BoundNode root)
 {
     var s = new BoundTreeSequencer();
     s.Visit(root);
     foreach (var node in s._list)
         yield return node;
 }

        public BoundNode VisitStatement(BoundNode node)
        {
            Debug.Assert(node == null || EvalStackIsEmpty());

            var origStack = StackDepth();
            var prevContext = _context;

            var result = base.Visit(node);

            _context = prevContext;
            SetStackDepth(origStack);
            _counter += 1;

            return result;
        }

            public override BoundNode Visit(BoundNode node)
            {
                if (!_found)
                {
                    return base.Visit(node);
                }

                return null;
            }

        // here we have a case of indirect assignment:  *t1 = expr;
        // normally we would need to push t1 and that will cause spilling of t2
        //
        // TODO: an interesting case arises in unused x[i]++  and ++x[i] :
        //       we have trees that look like:
        //
        //  t1 = &(x[0])
        //  t2 = *t1
        //  *t1 = t2 + 1
        //
        //  t1 = &(x[0])
        //  t2 = *t1 + 1
        //  *t1 = t2
        //
        //  in these cases, we could keep t2 on stack (dev10 does).
        //  we are dealing with exactly 2 locals and access them in strict order 
        //  t1, t2, t1, t2  and we are not using t2 after that.
        //  We may consider detecting exactly these cases and pretend that we do not need 
        //  to push either t1 or t2 in this case.
        //
        private bool LhsUsesStackWhenAssignedTo(BoundNode node, ExprContext context)
        {
            Debug.Assert(context == ExprContext.AssignmentTarget);

            switch (node.Kind)
            {
                case BoundKind.Parameter:
                case BoundKind.Local:
                    return false;

                case BoundKind.FieldAccess:
                    return !((BoundFieldAccess)node).FieldSymbol.IsStatic;

                case BoundKind.Sequence:
                    return LhsUsesStackWhenAssignedTo(((BoundSequence)node).Value, context);
            }

            return true;
        }

 public static void Check(BoundNode node, ImmutableArray<TypeParameterSymbol> acceptableTypeParameters)
 {
     new BlockChecker(new TypeParameterChecker(acceptableTypeParameters)).Visit(node);
 }

 // Adds every syntax/bound pair in a tree rooted at the given bound node to the map, and the
 // performs a lookup of the given syntax node in the map. 
 private BoundNode AddBoundTreeAndGetBoundNodeFromMap(SyntaxNode syntax, BoundNode bound)
 {
     using (nodeMapLock.DisposableWrite())
     {
         NodeMapBuilder.AddToMap(bound, this.guardedNodeMap);
         BoundNode result;
         this.guardedNodeMap.TryGetValue(syntax, out result);
         return result;
     }
 }

 // Simply add a syntax/bound pair to the map.
 private void AddBoundNodeToMap(SyntaxNode syntax, BoundNode bound)
 {
     using (nodeMapLock.DisposableWrite())
     {
         // Suppose we have bound a subexpression, say "x", and have cached the result in the
         // map. Later on, we bind the parent expression, "x + y" and end up re-binding x. In
         // this situation we do not want to clobber the existing "x" in the map because x
         // might be a complex expression that contains lambda symbols (or, equivalently,
         // lambda parameter symbols). We want to make sure we always get the same symbols
         // out of the cache every time we ask.
         if (!this.guardedNodeMap.ContainsKey(syntax))
         {
             this.guardedNodeMap.Add(syntax, bound);
         }
     }
 }

            public override BoundNode Visit(BoundNode node)
            {
                var expression = node as BoundExpression;
                if (expression != null && _resultExpressions.Contains(expression))
                {
                    // Create a temporary to hold the result.

                    var temporary = new BoundTemporary(
                        --_lastTemporaryIndex,
                        _typeManager.CreateType(null, BoundTypeKind.Temporary)
                    );

                    var nodes = new ReadOnlyArray<BoundStatement>.Builder();

                    // Initialize the temporary with the expression.

                    nodes.Add(new BoundSetVariable(
                        temporary,
                        expression,
                        SourceLocation.Missing
                    ));

                    // Copy the temporary to the result.

                    nodes.Add(new BoundSetVariable(
                        _resultTemporary,
                        new BoundGetVariable(temporary),
                        SourceLocation.Missing
                    ));

                    // Return an expression block.

                    return new BoundExpressionBlock(
                        temporary,
                        new BoundBlock(
                            ReadOnlyArray<BoundTemporary>.CreateFrom(temporary),
                            nodes.ToReadOnly(),
                            SourceLocation.Missing
                        )
                    );
                }

                return base.Visit(node);
            }

 internal static BoundNode Rewrite(CSharpCompilation compilation, EENamedTypeSymbol container, HashSet<LocalSymbol> declaredLocals, BoundNode node, DiagnosticBag diagnostics)
 {
     var rewriter = new PlaceholderLocalRewriter(compilation, container, declaredLocals, diagnostics);
     return rewriter.Visit(node);
 }

 private void LoadDataSourceFields()
 {
     this.EnterLoadingMode();
     IDataSourceFieldSchema[] fieldSchemas = this.GetFieldSchemas();
     if ((fieldSchemas != null) && (fieldSchemas.Length > 0))
     {
         DataFieldNode node = new DataFieldNode(this);
         this._availableFieldsTree.Nodes.Insert(0, node);
         foreach (IDataSourceFieldSchema schema in fieldSchemas)
         {
             BoundNode node2 = new BoundNode(this, schema);
             this._selectedDataSourceNode.Nodes.Add(node2);
         }
         this._selectedDataSourceNode.Expand();
         foreach (IDataSourceFieldSchema schema2 in fieldSchemas)
         {
             if ((schema2.DataType == typeof(bool)) || (schema2.DataType == typeof(bool?)))
             {
                 CheckBoxNode node3 = new CheckBoxNode(this, schema2);
                 this._selectedCheckBoxDataSourceNode.Nodes.Add(node3);
             }
         }
         this._selectedCheckBoxDataSourceNode.Expand();
         this._availableFieldsTree.SelectedNode = node;
         node.EnsureVisible();
     }
     else
     {
         BoundNode node4 = new BoundNode(this, null);
         this._availableFieldsTree.Nodes.Insert(0, node4);
         node4.EnsureVisible();
         CheckBoxNode node5 = new CheckBoxNode(this, null);
         this._availableFieldsTree.Nodes.Insert(1, node5);
         node5.EnsureVisible();
         this._availableFieldsTree.SelectedNode = node4;
     }
     this.ExitLoadingMode();
 }