VM: Re-format to use at most one newline between functions

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
+#include "vm/class_finalizer.h"
 #include "vm/compiler.h"
-#include "vm/class_finalizer.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/heap.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 46 matching lines @@
 uword FlowGraphBuilder::FindDoubleConstant(double value) {
   intptr_t len = sizeof(kCommonDoubleConstants) / sizeof(double);  // NOLINT
   for (intptr_t i = 0; i < len; i++) {
     if (Utils::DoublesBitEqual(value, kCommonDoubleConstants[i])) {
       return reinterpret_cast<uword>(&kCommonDoubleConstants[i]);
     }
   }
   return 0;
 }
 
-
 #define RECOGNIZE_FACTORY(symbol, class_name, constructor_name, cid, fp)       \
   {Symbols::k##symbol##Id, cid, fp, #symbol ", " #cid},  // NOLINT
 
 static struct {
   intptr_t symbol_id;
   intptr_t cid;
   intptr_t finger_print;
   const char* name;
 } factory_recognizer_list[] = {RECOGNIZED_LIST_FACTORY_LIST(RECOGNIZE_FACTORY){
     Symbols::kIllegal, -1, -1, NULL}};
@@ skipping 11 matching lines @@
        factory_recognizer_list[i].symbol_id != Symbols::kIllegal; i++) {
     if (String::EqualsIgnoringPrivateKey(
             factory_name,
             Symbols::Symbol(factory_recognizer_list[i].symbol_id))) {
       return factory_recognizer_list[i].cid;
     }
   }
   return kDynamicCid;
 }
 
-
 // Base class for a stack of enclosing statements of interest (e.g.,
 // blocks (breakable) and loops (continuable)).
 class NestedStatement : public ValueObject {
  public:
   FlowGraphBuilder* owner() const { return owner_; }
   const SourceLabel* label() const { return label_; }
   NestedStatement* outer() const { return outer_; }
   JoinEntryInstr* break_target() const { return break_target_; }
 
   virtual intptr_t ContextLevel() const;
@@ skipping 23 matching lines @@
 
  private:
   FlowGraphBuilder* owner_;
   const SourceLabel* label_;
   NestedStatement* outer_;
 
   JoinEntryInstr* break_target_;
   const intptr_t try_index_;
 };
 
-
 intptr_t NestedStatement::ContextLevel() const {
   // Context level is determined by the innermost nested statement having one.
   return (outer() == NULL) ? 0 : outer()->ContextLevel();
 }
 
-
 void NestedStatement::AdjustContextLevel(intptr_t context_level) {
   // There must be a NestedContextAdjustment on the nesting stack.
   ASSERT(outer() != NULL);
   outer()->AdjustContextLevel(context_level);
 }
 
-
 intptr_t FlowGraphBuilder::GetNextDeoptId() const {
   intptr_t deopt_id = thread()->GetNextDeoptId();
   if (context_level_array_ != NULL) {
     intptr_t level = context_level();
     context_level_array_->Add(deopt_id);
     context_level_array_->Add(level);
   }
   return deopt_id;
 }
 
-
 intptr_t FlowGraphBuilder::context_level() const {
   return (nesting_stack() == NULL) ? 0 : nesting_stack()->ContextLevel();
 }
 
-
 JoinEntryInstr* NestedStatement::BreakTargetFor(SourceLabel* label) {
   if (label != label_) return NULL;
   if (break_target_ == NULL) {
     break_target_ = new (owner()->zone()) JoinEntryInstr(
         owner()->AllocateBlockId(), try_index(), owner()->GetNextDeoptId());
   }
   return break_target_;
 }
 
-
 JoinEntryInstr* NestedStatement::ContinueTargetFor(SourceLabel* label) {
   return NULL;
 }
 
-
 // A nested statement that has its own context level.
 class NestedBlock : public NestedStatement {
  public:
   NestedBlock(FlowGraphBuilder* owner, SequenceNode* node)
       : NestedStatement(owner, node->label()), scope_(node->scope()) {}
 
   virtual intptr_t ContextLevel() const;
 
  private:
   LocalScope* scope_;
 };
 
-
 intptr_t NestedBlock::ContextLevel() const {
   return ((scope_ == NULL) || (scope_->num_context_variables() == 0))
              ? NestedStatement::ContextLevel()
              : scope_->context_level();
 }
 
-
 // A nested statement reflecting a context level adjustment.
 class NestedContextAdjustment : public NestedStatement {
  public:
   NestedContextAdjustment(FlowGraphBuilder* owner, intptr_t context_level)
       : NestedStatement(owner, NULL), context_level_(context_level) {}
 
   virtual intptr_t ContextLevel() const { return context_level_; }
 
   virtual void AdjustContextLevel(intptr_t context_level) {
     ASSERT(context_level <= context_level_);
     context_level_ = context_level;
   }
 
  private:
   intptr_t context_level_;
 };
 
-
 // A nested statement that can be the target of a continue as well as a
 // break.
 class NestedLoop : public NestedStatement {
  public:
   NestedLoop(FlowGraphBuilder* owner, SourceLabel* label)
       : NestedStatement(owner, label), continue_target_(NULL) {
     owner->IncrementLoopDepth();
   }
 
   virtual ~NestedLoop() { owner()->DecrementLoopDepth(); }
 
   JoinEntryInstr* continue_target() const { return continue_target_; }
 
   virtual JoinEntryInstr* ContinueTargetFor(SourceLabel* label);
 
  private:
   JoinEntryInstr* continue_target_;
 };
 
-
 JoinEntryInstr* NestedLoop::ContinueTargetFor(SourceLabel* label) {
   if (label != this->label()) return NULL;
   if (continue_target_ == NULL) {
     continue_target_ = new (owner()->zone()) JoinEntryInstr(
         owner()->AllocateBlockId(), try_index(), owner()->GetNextDeoptId());
   }
   return continue_target_;
 }
 
-
 // A nested switch which can be the target of a break if labeled, and whose
 // cases can be the targets of continues.
 class NestedSwitch : public NestedStatement {
  public:
   NestedSwitch(FlowGraphBuilder* owner, SwitchNode* node);
 
   virtual JoinEntryInstr* ContinueTargetFor(SourceLabel* label);
 
  private:
   GrowableArray<SourceLabel*> case_labels_;
   GrowableArray<JoinEntryInstr*> case_targets_;
 };
 
-
 NestedSwitch::NestedSwitch(FlowGraphBuilder* owner, SwitchNode* node)
     : NestedStatement(owner, node->label()),
       case_labels_(node->body()->length()),
       case_targets_(node->body()->length()) {
   SequenceNode* body = node->body();
   for (intptr_t i = 0; i < body->length(); ++i) {
     CaseNode* case_node = body->NodeAt(i)->AsCaseNode();
     if (case_node != NULL) {
       case_labels_.Add(case_node->label());
       case_targets_.Add(NULL);
     }
   }
 }
 
-
 JoinEntryInstr* NestedSwitch::ContinueTargetFor(SourceLabel* label) {
   // Allocate a join for a case clause that matches the label.  This block
   // is not necessarily targeted by a continue, but we always use a join in
   // the graph anyway.
   for (intptr_t i = 0; i < case_labels_.length(); ++i) {
     if (label != case_labels_[i]) continue;
     if (case_targets_[i] == NULL) {
       case_targets_[i] = new (owner()->zone()) JoinEntryInstr(
           owner()->AllocateBlockId(), try_index(), owner()->GetNextDeoptId());
     }
     return case_targets_[i];
   }
   return NULL;
 }
 
-
 FlowGraphBuilder::FlowGraphBuilder(
     const ParsedFunction& parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     ZoneGrowableArray<intptr_t>* context_level_array,
     InlineExitCollector* exit_collector,
     intptr_t osr_id)
     : parsed_function_(parsed_function),
       ic_data_array_(ic_data_array),
       context_level_array_(context_level_array),
       num_copied_params_(parsed_function.num_copied_params()),
@@ skipping 10 matching lines @@
       loop_depth_(0),
       graph_entry_(NULL),
       temp_count_(0),
       args_pushed_(0),
       nesting_stack_(NULL),
       osr_id_(osr_id),
       jump_count_(0),
       await_joins_(new (Z) ZoneGrowableArray<JoinEntryInstr*>()),
       await_token_positions_(new (Z) ZoneGrowableArray<TokenPosition>()) {}
 
-
 void FlowGraphBuilder::AddCatchEntry(CatchBlockEntryInstr* entry) {
   graph_entry_->AddCatchEntry(entry);
 }
 
-
 void InlineExitCollector::PrepareGraphs(FlowGraph* callee_graph) {
   ASSERT(callee_graph->graph_entry()->SuccessorCount() == 1);
   ASSERT(callee_graph->max_block_id() > caller_graph_->max_block_id());
   ASSERT(callee_graph->max_virtual_register_number() >
          caller_graph_->max_virtual_register_number());
 
   // Adjust the caller's maximum block id and current SSA temp index.
   caller_graph_->set_max_block_id(callee_graph->max_block_id());
   caller_graph_->set_current_ssa_temp_index(
       callee_graph->max_virtual_register_number());
@@ skipping 24 matching lines @@
       }
     }
     if (instr->IsGoto()) {
       instr->AsGoto()->adjust_edge_weight(scale_factor);
     }
   }
 
   RemoveUnreachableExits(callee_graph);
 }
 
-
 void InlineExitCollector::AddExit(ReturnInstr* exit) {
   Data data = {NULL, exit};
   exits_.Add(data);
 }
 
-
 void InlineExitCollector::Union(const InlineExitCollector* other) {
   // It doesn't make sense to combine different calls or calls from
   // different graphs.
   ASSERT(caller_graph_ == other->caller_graph_);
   ASSERT(call_ == other->call_);
   exits_.AddArray(other->exits_);
 }
 
-
 int InlineExitCollector::LowestBlockIdFirst(const Data* a, const Data* b) {
   return (a->exit_block->block_id() - b->exit_block->block_id());
 }
 
-
 void InlineExitCollector::RemoveUnreachableExits(FlowGraph* callee_graph) {
   const GrowableArray<BlockEntryInstr*>& postorder = callee_graph->postorder();
   int j = 0;
   for (int i = 0; i < exits_.length(); ++i) {
     BlockEntryInstr* block = exits_[i].exit_return->GetBlock();
     if ((block != NULL) && (0 <= block->postorder_number()) &&
         (block->postorder_number() < postorder.length()) &&
         (postorder[block->postorder_number()] == block)) {
       if (i != j) {
         exits_[j] = exits_[i];
       }
       j++;
     }
   }
   exits_.TruncateTo(j);
 }
 
-
 void InlineExitCollector::SortExits() {
   // Assign block entries here because we did not necessarily know them when
   // the return exit was added to the array.
   for (int i = 0; i < exits_.length(); ++i) {
     exits_[i].exit_block = exits_[i].exit_return->GetBlock();
   }
   exits_.Sort(LowestBlockIdFirst);
 }
 
-
 Definition* InlineExitCollector::JoinReturns(BlockEntryInstr** exit_block,
                                              Instruction** last_instruction,
                                              intptr_t try_index) {
   // First sort the list of exits by block id (caching return instruction
   // block entries as a side effect).
   SortExits();
   intptr_t num_exits = exits_.length();
   if (num_exits == 1) {
     ReturnAt(0)->UnuseAllInputs();
     *exit_block = ExitBlockAt(0);
@@ skipping 85 matching lines @@
       // from their definition's use list.
       for (intptr_t i = 0; i < num_exits; ++i) {
         ReturnAt(i)->UnuseAllInputs();
       }
       join->InheritDeoptTargetAfter(caller_graph_, call_, NULL);
       return NULL;
     }
   }
 }
 
-
 void InlineExitCollector::ReplaceCall(TargetEntryInstr* callee_entry) {
   ASSERT(call_->previous() != NULL);
   ASSERT(call_->next() != NULL);
   BlockEntryInstr* call_block = call_->GetBlock();
 
   // Insert the callee graph into the caller graph.
   BlockEntryInstr* callee_exit = NULL;
   Instruction* callee_last_instruction = NULL;
 
   if (exits_.length() == 0) {
@@ skipping 95 matching lines @@
     callee_entry->UnuseAllInputs();
   }
   // Neither call nor the graph entry (if present) are in the
   // graph at this point. Remove them from use lists.
   if (callee_entry->PredecessorCount() > 0) {
     callee_entry->PredecessorAt(0)->AsGraphEntry()->UnuseAllInputs();
   }
   call_->UnuseAllInputs();
 }
 
-
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
   if (is_empty()) {
     entry_ = other_fragment.entry();
   } else {
     exit()->LinkTo(other_fragment.entry());
   }
   exit_ = other_fragment.exit();
 }
 
-
 Value* EffectGraphVisitor::Bind(Definition* definition) {
   ASSERT(is_open());
   owner()->DeallocateTemps(definition->InputCount());
   owner()->add_args_pushed(-definition->ArgumentCount());
   definition->set_temp_index(owner()->AllocateTemp());
   if (is_empty()) {
     entry_ = definition;
   } else {
     exit()->LinkTo(definition);
   }
   exit_ = definition;
   return new (Z) Value(definition);
 }
 
-
 void EffectGraphVisitor::Do(Definition* definition) {
   ASSERT(is_open());
   owner()->DeallocateTemps(definition->InputCount());
   owner()->add_args_pushed(-definition->ArgumentCount());
   if (is_empty()) {
     entry_ = definition;
   } else {
     exit()->LinkTo(definition);
   }
   exit_ = definition;
 }
 
-
 void EffectGraphVisitor::AddInstruction(Instruction* instruction) {
   ASSERT(is_open());
   ASSERT(instruction->IsPushArgument() || !instruction->IsDefinition());
   ASSERT(!instruction->IsBlockEntry());
   owner()->DeallocateTemps(instruction->InputCount());
   owner()->add_args_pushed(-instruction->ArgumentCount());
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     exit()->LinkTo(instruction);
     exit_ = instruction;
   }
 }
 
-
 void EffectGraphVisitor::AddReturnExit(TokenPosition token_pos, Value* value) {
   ASSERT(is_open());
   ReturnInstr* return_instr =
       new (Z) ReturnInstr(token_pos, value, owner()->GetNextDeoptId());
   AddInstruction(return_instr);
   InlineExitCollector* exit_collector = owner()->exit_collector();
   if (exit_collector != NULL) {
     exit_collector->AddExit(return_instr);
   }
   CloseFragment();
 }
 
-
 void EffectGraphVisitor::Goto(JoinEntryInstr* join) {
   ASSERT(is_open());
   if (is_empty()) {
     entry_ = new (Z) GotoInstr(join, owner()->GetNextDeoptId());
   } else {
     exit()->Goto(join);
   }
   CloseFragment();
 }
 
-
 // Appends a graph fragment to a block entry instruction.  Returns the entry
 // instruction if the fragment was empty or else the exit of the fragment if
 // it was non-empty (so NULL if the fragment is closed).
 //
 // Note that the fragment is no longer a valid fragment after calling this
 // function -- the fragment is closed at its entry because the entry has a
 // predecessor in the graph.
 static Instruction* AppendFragment(BlockEntryInstr* entry,
                                    const EffectGraphVisitor& fragment) {
   if (fragment.is_empty()) return entry;
   entry->LinkTo(fragment.entry());
   return fragment.exit();
 }
 
-
 void EffectGraphVisitor::Join(const TestGraphVisitor& test_fragment,
                               const EffectGraphVisitor& true_fragment,
                               const EffectGraphVisitor& false_fragment) {
   // We have: a test graph fragment with zero, one, or two available exits;
   // and a pair of effect graph fragments with zero or one available exits.
   // We want to append the branch and (if necessary) a join node to this
   // graph fragment.
   ASSERT(is_open());
 
   // 1. Connect the test to this graph.
@@ skipping 15 matching lines @@
   } else {
     JoinEntryInstr* join =
         new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
                                owner()->GetNextDeoptId());
     true_exit->Goto(join);
     false_exit->Goto(join);
     exit_ = join;
   }
 }
 
-
 void EffectGraphVisitor::TieLoop(
     TokenPosition token_pos,
     const TestGraphVisitor& test_fragment,
     const EffectGraphVisitor& body_fragment,
     const EffectGraphVisitor& test_preamble_fragment) {
   // We have: a test graph fragment with zero, one, or two available exits;
   // and an effect graph fragment with zero or one available exits.  We want
   // to append the 'while loop' consisting of the test graph fragment as
   // condition and the effect graph fragment as body.
   ASSERT(is_open());
@@ skipping 23 matching lines @@
     }
     Goto(join);
     body_exit->Goto(join);
   }
 
   // 3. Set the exit to the graph to be the false successor of the test, a
   // fresh target node
   exit_ = test_fragment.CreateFalseSuccessor();
 }
 
-
 PushArgumentInstr* EffectGraphVisitor::PushArgument(Value* value) {
   owner_->add_args_pushed(1);
   PushArgumentInstr* result = new (Z) PushArgumentInstr(value);
   AddInstruction(result);
   return result;
 }
 
-
 Definition* EffectGraphVisitor::BuildStoreTemp(const LocalVariable& local,
                                                Value* value,
                                                TokenPosition token_pos) {
   ASSERT(!local.is_captured());
   ASSERT(!token_pos.IsClassifying());
   return new (Z) StoreLocalInstr(local, value, ST(token_pos));
 }
 
-
 Definition* EffectGraphVisitor::BuildStoreExprTemp(Value* value,
                                                    TokenPosition token_pos) {
   return BuildStoreTemp(*owner()->parsed_function().expression_temp_var(),
                         value, token_pos);
 }
 
-
 Definition* EffectGraphVisitor::BuildLoadExprTemp(TokenPosition token_pos) {
   ASSERT(!token_pos.IsClassifying());
   return BuildLoadLocal(*owner()->parsed_function().expression_temp_var(),
                         token_pos);
 }
 
-
 Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
                                                 Value* value,
                                                 TokenPosition token_pos) {
   if (local.is_captured()) {
     LocalVariable* tmp_var = EnterTempLocalScope(value);
     intptr_t delta = owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(BuildCurrentContext(token_pos));
     while (delta-- > 0) {
       context = Bind(new (Z) LoadFieldInstr(context, Context::parent_offset(),
                                             Type::ZoneHandle(Z, Type::null()),
                                             token_pos));
     }
     Value* tmp_val = Bind(new (Z) LoadLocalInstr(*tmp_var, token_pos));
     StoreInstanceFieldInstr* store = new (Z)
         StoreInstanceFieldInstr(Context::variable_offset(local.index()),
                                 context, tmp_val, kEmitStoreBarrier, token_pos);
     Do(store);
     return ExitTempLocalScope(value);
   } else {
     return new (Z) StoreLocalInstr(local, value, token_pos);
   }
 }
 
-
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local,
                                                TokenPosition token_pos) {
   if (local.IsConst()) {
     return new (Z) ConstantInstr(*local.ConstValue(), token_pos);
   } else if (local.is_captured()) {
     intptr_t delta = owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(BuildCurrentContext(token_pos));
     while (delta-- > 0) {
       context = Bind(new (Z) LoadFieldInstr(context, Context::parent_offset(),
                                             Type::ZoneHandle(Z, Type::null()),
                                             token_pos));
     }
     LoadFieldInstr* load =
         new (Z) LoadFieldInstr(context, Context::variable_offset(local.index()),
                                local.type(), token_pos);
     load->set_is_immutable(local.is_final());
     return load;
   } else {
     return new (Z) LoadLocalInstr(local, token_pos);
   }
 }
 
-
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildSaveContext(const LocalVariable& variable,
                                           TokenPosition token_pos) {
   ASSERT(token_pos.IsSynthetic() || token_pos.IsNoSource());
   Value* context = Bind(BuildCurrentContext(token_pos));
   Do(BuildStoreLocal(variable, context, token_pos));
 }
 
-
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildRestoreContext(const LocalVariable& variable,
                                              TokenPosition token_pos) {
   Value* load_saved_context = Bind(BuildLoadLocal(variable, token_pos));
   Do(BuildStoreContext(load_saved_context, token_pos));
 }
 
-
 Definition* EffectGraphVisitor::BuildStoreContext(Value* value,
                                                   TokenPosition token_pos) {
   return new (Z) StoreLocalInstr(
       *owner()->parsed_function().current_context_var(), value, token_pos);
 }
 
-
 Definition* EffectGraphVisitor::BuildCurrentContext(TokenPosition token_pos) {
   return new (Z) LoadLocalInstr(
       *owner()->parsed_function().current_context_var(), token_pos);
 }
 
-
 void TestGraphVisitor::ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const {
   ASSERT(!branches.is_empty());
   for (intptr_t i = 0; i < branches.length(); i++) {
     TargetEntryInstr* target = new (Z)
         TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
                          owner()->GetNextDeoptId());
     *(branches[i]) = target;
     target->Goto(join);
   }
 }
 
-
 void TestGraphVisitor::IfTrueGoto(JoinEntryInstr* join) const {
   ConnectBranchesTo(true_successor_addresses_, join);
 }
 
-
 void TestGraphVisitor::IfFalseGoto(JoinEntryInstr* join) const {
   ConnectBranchesTo(false_successor_addresses_, join);
 }
 
-
 BlockEntryInstr* TestGraphVisitor::CreateSuccessorFor(
     const GrowableArray<TargetEntryInstr**>& branches) const {
   ASSERT(!branches.is_empty());
 
   if (branches.length() == 1) {
     TargetEntryInstr* target = new (Z)
         TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
                          owner()->GetNextDeoptId());
     *(branches[0]) = target;
     return target;
   }
 
   JoinEntryInstr* join =
       new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
                              owner()->GetNextDeoptId());
   ConnectBranchesTo(branches, join);
   return join;
 }
 
-
 BlockEntryInstr* TestGraphVisitor::CreateTrueSuccessor() const {
   return CreateSuccessorFor(true_successor_addresses_);
 }
 
-
 BlockEntryInstr* TestGraphVisitor::CreateFalseSuccessor() const {
   return CreateSuccessorFor(false_successor_addresses_);
 }
 
-
 void TestGraphVisitor::ReturnValue(Value* value) {
   Isolate* isolate = Isolate::Current();
   if (isolate->type_checks() || isolate->asserts()) {
     value = Bind(new (Z) AssertBooleanInstr(condition_token_pos(), value,
                                             owner()->GetNextDeoptId()));
   }
   Value* constant_true = Bind(new (Z) ConstantInstr(Bool::True()));
   StrictCompareInstr* comp = new (Z) StrictCompareInstr(
       condition_token_pos(), Token::kEQ_STRICT, value, constant_true, false,
       owner()->GetNextDeoptId());  // No number check.
   BranchInstr* branch = new (Z) BranchInstr(comp, owner()->GetNextDeoptId());
   AddInstruction(branch);
   CloseFragment();
 
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
-
 void TestGraphVisitor::MergeBranchWithStrictCompare(StrictCompareInstr* comp) {
   BranchInstr* branch = new (Z) BranchInstr(comp, owner()->GetNextDeoptId());
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
-
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateInstr* neg) {
   ASSERT(!Isolate::Current()->type_checks());
   Value* constant_true = Bind(new (Z) ConstantInstr(Bool::True()));
   StrictCompareInstr* comp = new (Z) StrictCompareInstr(
       condition_token_pos(), Token::kNE_STRICT, neg->value(), constant_true,
       false, owner()->GetNextDeoptId());  // No number check.
   BranchInstr* branch = new (Z) BranchInstr(comp, owner()->GetNextDeoptId());
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
-
 void TestGraphVisitor::ReturnDefinition(Definition* definition) {
   StrictCompareInstr* comp = definition->AsStrictCompare();
   if (comp != NULL) {
     MergeBranchWithStrictCompare(comp);
     return;
   }
   if (!Isolate::Current()->type_checks()) {
     BooleanNegateInstr* neg = definition->AsBooleanNegate();
     if (neg != NULL) {
       MergeBranchWithNegate(neg);
       return;
     }
   }
   ReturnValue(Bind(definition));
 }
 
-
 // Special handling for AND/OR.
 void TestGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     TestGraphVisitor for_left(owner(), node->left()->token_pos());
     node->left()->Visit(&for_left);
 
     TestGraphVisitor for_right(owner(), node->right()->token_pos());
     node->right()->Visit(&for_right);
@@ skipping 11 matching lines @@
       false_successor_addresses_.AddArray(for_right.false_successor_addresses_);
       true_successor_addresses_.AddArray(for_left.true_successor_addresses_);
       true_successor_addresses_.AddArray(for_right.true_successor_addresses_);
     }
     CloseFragment();
     return;
   }
   ValueGraphVisitor::VisitBinaryOpNode(node);
 }
 
-
 void EffectGraphVisitor::Bailout(const char* reason) const {
   owner()->Bailout(reason);
 }
 
-
 void EffectGraphVisitor::InlineBailout(const char* reason) const {
   owner()->function().set_is_inlinable(false);
   if (owner()->IsInlining()) owner()->Bailout(reason);
 }
 
-
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* return_value = for_value.value();
 
   // Call to stub that checks whether the debugger is in single
   // step mode. This call must happen before the contexts are
@@ skipping 113 matching lines @@
        function.IsAsyncGenClosure()) &&
       (node->return_type() == ReturnNode::kContinuationTarget)) {
     JoinEntryInstr* const join =
         new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
                                owner()->GetNextDeoptId());
     owner()->await_joins()->Add(join);
     exit_ = join;
   }
 }
 
-
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   ReturnDefinition(new (Z) ConstantInstr(node->literal(), node->token_pos()));
 }
 
-
 // Type nodes are used when a type is referenced as a literal. Type nodes
 // can also be used for the right-hand side of instanceof comparisons,
 // but they are handled specially in that context, not here.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) {
   return;
 }
 
-
 void ValueGraphVisitor::VisitTypeNode(TypeNode* node) {
   const AbstractType& type = node->type();
   // Type may be malbounded, but not malformed.
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   if (type.IsInstantiated()) {
     ReturnDefinition(new (Z) ConstantInstr(type));
     return;
   }
   const TokenPosition token_pos = node->token_pos();
   Value* instantiator_type_arguments = NULL;
   if (type.IsInstantiated(kCurrentClass)) {
     instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
   }
   Value* function_type_arguments = NULL;
   if (type.IsInstantiated(kFunctions)) {
     function_type_arguments = BuildNullValue(token_pos);
   } else {
     function_type_arguments = BuildFunctionTypeArguments(token_pos);
   }
   ReturnDefinition(new (Z) InstantiateTypeInstr(
       token_pos, type, instantiator_type_arguments, function_type_arguments,
       owner()->GetNextDeoptId()));
 }
 
-
 // Returns true if the type check can be skipped, for example, if the
 // destination type is dynamic or if the compile type of the value is a subtype
 // of the destination type.
 bool EffectGraphVisitor::CanSkipTypeCheck(TokenPosition token_pos,
                                           Value* value,
                                           const AbstractType& dst_type,
                                           const String& dst_name) {
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
@@ skipping 22 matching lines @@
   }
 
   const bool eliminated = value->Type()->IsAssignableTo(dst_type);
   if (FLAG_trace_type_check_elimination) {
     FlowGraphPrinter::PrintTypeCheck(owner()->parsed_function(), token_pos,
                                      value, dst_type, dst_name, eliminated);
   }
   return eliminated;
 }
 
-
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner());
   node->expr()->Visit(&for_value);
   Append(for_value);
   if (CanSkipTypeCheck(node->expr()->token_pos(), for_value.value(),
                        node->type(), node->dst_name())) {
     ReturnValue(for_value.value());
   } else {
     ReturnDefinition(BuildAssertAssignable(node->expr()->token_pos(),
                                            for_value.value(), node->type(),
                                            node->dst_name()));
   }
 }
 
-
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner());
   node->expr()->Visit(&for_value);
   Append(for_value);
   ReturnValue(BuildAssignableValue(node->expr()->token_pos(), for_value.value(),
                                    node->type(), node->dst_name()));
 }
 
-
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(), node->left()->token_pos());
     node->left()->Visit(&for_left);
@@ skipping 39 matching lines @@
   const String& name = Symbols::Token(node->kind());
   const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 2;
   InstanceCallInstr* call = new (Z)
       InstanceCallInstr(node->token_pos(), name, node->kind(), arguments,
                         kTypeArgsLen, Object::null_array(), kNumArgsChecked,
                         owner()->ic_data_array(), owner()->GetNextDeoptId());
   ReturnDefinition(call);
 }
 
-
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
 
@@ skipping 27 matching lines @@
       for_true.Do(BuildStoreExprTemp(constant_true, node->token_pos()));
       Join(for_test, for_true, for_right);
     }
     ReturnDefinition(BuildLoadExprTemp(node->token_pos()));
     return;
   }
 
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
-
 PushArgumentInstr* EffectGraphVisitor::PushInstantiatorTypeArguments(
     const AbstractType& type,
     TokenPosition token_pos) {
   if (type.IsInstantiated(kCurrentClass)) {
     return PushArgument(BuildNullValue(token_pos));
   } else {
     Value* instantiator_type_args = BuildInstantiatorTypeArguments(token_pos);
     return PushArgument(instantiator_type_args);
   }
 }
 
-
 PushArgumentInstr* EffectGraphVisitor::PushFunctionTypeArguments(
     const AbstractType& type,
     TokenPosition token_pos) {
   if (type.IsInstantiated(kFunctions)) {
     return PushArgument(BuildNullValue(token_pos));
   } else {
     Value* function_type_args = BuildFunctionTypeArguments(token_pos);
     return PushArgument(function_type_args);
   }
 }
 
-
 Value* EffectGraphVisitor::BuildNullValue(TokenPosition token_pos) {
   return Bind(
       new (Z) ConstantInstr(Object::ZoneHandle(Z, Object::null()), token_pos));
 }
 
-
 Value* EffectGraphVisitor::BuildEmptyTypeArguments(TokenPosition token_pos) {
   return Bind(new (Z) ConstantInstr(
       TypeArguments::ZoneHandle(Z, Object::empty_type_arguments().raw()),
       token_pos));
 }
 
-
 // Used for testing incoming arguments.
 AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
     TokenPosition token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   Value* function_type_arguments = NULL;
   if (dst_type.IsInstantiated(kCurrentClass)) {
     instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
   }
   if (dst_type.IsInstantiated(kFunctions)) {
     function_type_arguments = BuildNullValue(token_pos);
   } else {
     function_type_arguments = BuildFunctionTypeArguments(token_pos);
   }
 
   const intptr_t deopt_id = owner()->GetNextDeoptId();
   return new (Z) AssertAssignableInstr(
       token_pos, value, instantiator_type_arguments, function_type_arguments,
       dst_type, dst_name, deopt_id);
 }
 
-
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(TokenPosition token_pos,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(token_pos, value, dst_type, dst_name)) {
     return value;
   }
   return Bind(BuildAssertAssignable(token_pos, value, dst_type, dst_name));
 }
 
-
 void EffectGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
   const bool negate_result = (node->kind() == Token::kISNOT);
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type = Type::Handle(Z, Type::ObjectType());
   if (type.IsInstantiated() &&
       object_type.IsSubtypeOf(type, NULL, NULL, Heap::kOld)) {
     // Must evaluate left side.
@@ skipping 48 matching lines @@
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_instanceOf()),
       node->kind(), arguments, kTypeArgsLen,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array(), owner()->GetNextDeoptId());
   if (negate_result) {
     result = new (Z) BooleanNegateInstr(Bind(result));
   }
   ReturnDefinition(result);
 }
 
-
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
   ValueGraphVisitor for_value(owner());
   node->left()->Visit(&for_value);
   Append(for_value);
   if (CanSkipTypeCheck(node->token_pos(), for_value.value(), type,
                        Symbols::InTypeCast())) {
@@ skipping 15 matching lines @@
   const int kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_as()),
       node->kind(), arguments, kTypeArgsLen,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array(), owner()->GetNextDeoptId());
   ReturnDefinition(call);
 }
 
-
 StrictCompareInstr* EffectGraphVisitor::BuildStrictCompare(
     AstNode* left,
     AstNode* right,
     Token::Kind kind,
     TokenPosition token_pos) {
   ValueGraphVisitor for_left_value(owner());
   left->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner());
   right->Visit(&for_right_value);
   Append(for_right_value);
   StrictCompareInstr* comp = new (Z) StrictCompareInstr(
       token_pos, kind, for_left_value.value(), for_right_value.value(), true,
       owner()->GetNextDeoptId());  // Number check.
   return comp;
 }
 
-
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsTypeTestOperator(node->kind())) {
     BuildTypeTest(node);
     return;
   }
   if (Token::IsTypeCastOperator(node->kind())) {
     BuildTypeCast(node);
@@ skipping 74 matching lines @@
 
   ASSERT(Token::IsRelationalOperator(node->kind()));
   const intptr_t kTypeArgsLen = 0;
   InstanceCallInstr* comp = new (Z) InstanceCallInstr(
       node->token_pos(), Symbols::Token(node->kind()), node->kind(), arguments,
       kTypeArgsLen, Object::null_array(), 2, owner()->ic_data_array(),
       owner()->GetNextDeoptId());
   ReturnDefinition(comp);
 }
 
-
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     Isolate* isolate = Isolate::Current();
     if (isolate->type_checks() || isolate->asserts()) {
       value = Bind(new (Z) AssertBooleanInstr(
@@ skipping 12 matching lines @@
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   const intptr_t kTypeArgsLen = 0;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Symbols::Token(node->kind()), node->kind(), arguments,
       kTypeArgsLen, Object::null_array(), 1, owner()->ic_data_array(),
       owner()->GetNextDeoptId());
   ReturnDefinition(call);
 }
 
-
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner());
   node->true_expr()->Visit(&for_true);
   EffectGraphVisitor for_false(owner());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
-
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   ValueGraphVisitor for_true(owner());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
   for_true.Do(
       BuildStoreExprTemp(for_true.value(), node->true_expr()->token_pos()));
 
   ValueGraphVisitor for_false(owner());
   node->false_expr()->Visit(&for_false);
   ASSERT(for_false.is_open());
   for_false.Do(
       BuildStoreExprTemp(for_false.value(), node->false_expr()->token_pos()));
 
   Join(for_test, for_true, for_false);
   ReturnDefinition(BuildLoadExprTemp(node->token_pos()));
 }
 
-
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   EffectGraphVisitor for_true(owner());
   EffectGraphVisitor for_false(owner());
 
   node->true_branch()->Visit(&for_true);
   // The for_false graph fragment will be empty (default graph fragment) if
   // we do not call Visit.
   if (node->false_branch() != NULL) node->false_branch()->Visit(&for_false);
   Join(for_test, for_true, for_false);
 }
 
-
 void EffectGraphVisitor::VisitSwitchNode(SwitchNode* node) {
   NestedSwitch nested_switch(owner(), node);
   EffectGraphVisitor switch_body(owner());
   node->body()->Visit(&switch_body);
   Append(switch_body);
   if (nested_switch.break_target() != NULL) {
     if (is_open()) Goto(nested_switch.break_target());
     exit_ = nested_switch.break_target();
   }
 }
 
-
 // A case node contains zero or more case expressions, can contain default
 // and a case statement body.
 // Compose fragment as follows:
 // - if no case expressions, must have default:
 //   a) target
 //   b) [ case-statements ]
 //
 // - if has 1 or more case statements
 //   a) target-0
 //   b) [ case-expression-0 ] -> (true-target-0, target-1)
@@ skipping 82 matching lines @@
     // A CaseNode without case expressions must contain default.
     ASSERT(node->contains_default());
     Goto(statement_start);
     exit_instruction = statement_exit;
   }
 
   ASSERT(!is_open());
   exit_ = exit_instruction;
 }
 
-
 // <Statement> ::= While { label:     SourceLabel
 //                         condition: <Expression>
 //                         body:      <Sequence> }
 // The fragment is composed as follows:
 // a) loop-join
 // b) [ test_preamble ]?
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ] -> (continue-join)
 // f) continue-join -> (loop-join)
@@ skipping 21 matching lines @@
     for_body.exit_ = join;
   }
   TieLoop(node->token_pos(), for_test, for_body, for_preamble);
   join = nested_loop.break_target();
   if (join != NULL) {
     Goto(join);
     exit_ = join;
   }
 }
 
-
 // The fragment is composed as follows:
 // a) body-entry-join
 // b) [ body ]
 // c) test-entry (continue-join or body-exit-target)
 // d) [ test-entry ] -> (back-target, loop-exit-target)
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   NestedLoop nested_loop(owner(), node->label());
@@ skipping 32 matching lines @@
   for_test.IfTrueGoto(body_entry_join);
   join = nested_loop.break_target();
   if (join == NULL) {
     exit_ = for_test.CreateFalseSuccessor();
   } else {
     for_test.IfFalseGoto(join);
     exit_ = join;
   }
 }
 
-
 // A ForNode can contain break and continue jumps. 'break' joins to
 // ForNode exit, 'continue' joins at increment entry. The fragment is composed
 // as follows:
 // a) [ initializer ]
 // b) loop-join
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ]
 // f) continue-join (optional)
 // g) [ increment ] -> (loop-join)
@@ skipping 59 matching lines @@
 
     if (nested_loop.break_target() == NULL) {
       exit_ = for_test.CreateFalseSuccessor();
     } else {
       for_test.IfFalseGoto(nested_loop.break_target());
       exit_ = nested_loop.break_target();
     }
   }
 }
 
-
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   if (FLAG_support_debugger && owner()->function().is_debuggable()) {
     AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
                                                RawPcDescriptors::kRuntimeCall,
                                                owner()->GetNextDeoptId()));
   }
 
   NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
@@ skipping 15 matching lines @@
     jump_target = (node->kind() == Token::kBREAK)
                       ? current->BreakTargetFor(node->label())
                       : current->ContinueTargetFor(node->label());
     if (jump_target != NULL) break;
     current = current->outer();
   }
   ASSERT(jump_target != NULL);
   Goto(jump_target);
 }
 
-
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
 }
 
-
 void EffectGraphVisitor::VisitAwaitNode(AwaitNode* node) {
   // Await nodes are temporary during parsing.
   UNREACHABLE();
 }
 
-
 void EffectGraphVisitor::VisitAwaitMarkerNode(AwaitMarkerNode* node) {
   // We need to create a new await state which involves:
   // * Increase the jump counter. Sanity check against the list of targets.
   // * Save the current context for resuming.
   ASSERT(node->token_pos().IsSynthetic() || node->token_pos().IsNoSource());
   ASSERT(node->async_scope() != NULL);
   ASSERT(node->await_scope() != NULL);
   LocalVariable* jump_var =
       node->async_scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   LocalVariable* ctx_var =
       node->async_scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((jump_var != NULL) && jump_var->is_captured());
   ASSERT((ctx_var != NULL) && ctx_var->is_captured());
   const intptr_t jump_count = owner()->next_await_counter();
   ASSERT(jump_count >= 0);
   // Sanity check that we always add a JoinEntryInstr before adding a new
   // state.
   ASSERT(jump_count == owner()->await_joins()->length());
   // Store the counter in :await_jump_var.
   Value* jump_val = Bind(new (Z) ConstantInstr(
       Smi::ZoneHandle(Z, Smi::New(jump_count)), node->token_pos()));
   Do(BuildStoreLocal(*jump_var, jump_val, node->token_pos()));
   // Add a mapping from jump_count -> token_position.
   owner()->AppendAwaitTokenPosition(node->token_pos());
   // Save the current context for resuming.
   BuildSaveContext(*ctx_var, node->token_pos());
 }
 
-
 intptr_t EffectGraphVisitor::GetCurrentTempLocalIndex() const {
   return kFirstLocalSlotFromFp - owner()->num_stack_locals() -
          owner()->num_copied_params() - owner()->args_pushed() -
          owner()->temp_count() + 1;
 }
 
-
 LocalVariable* EffectGraphVisitor::EnterTempLocalScope(Value* value) {
   ASSERT(value->definition()->temp_index() == (owner()->temp_count() - 1));
   intptr_t index = GetCurrentTempLocalIndex();
   char name[64];
   OS::SNPrint(name, 64, ":tmp_local%" Pd, index);
   LocalVariable* var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             String::ZoneHandle(Z, Symbols::New(T, name)),
                             *value->Type()->ToAbstractType());
   var->set_index(index);
   return var;
 }
 
-
 Definition* EffectGraphVisitor::ExitTempLocalScope(Value* value) {
   return new (Z) DropTempsInstr(0, value);
 }
 
-
 void EffectGraphVisitor::BuildLetTempExpressions(LetNode* node) {
   intptr_t num_temps = node->num_temps();
   for (intptr_t i = 0; i < num_temps; ++i) {
     ValueGraphVisitor for_value(owner());
     node->InitializerAt(i)->Visit(&for_value);
     Append(for_value);
     ASSERT(!node->TempAt(i)->HasIndex() ||
            (node->TempAt(i)->index() == GetCurrentTempLocalIndex()));
     node->TempAt(i)->set_index(GetCurrentTempLocalIndex());
   }
 }
 
-
 void EffectGraphVisitor::VisitLetNode(LetNode* node) {
   BuildLetTempExpressions(node);
 
   // Visit body.
   for (intptr_t i = 0; i < node->nodes().length(); ++i) {
     EffectGraphVisitor for_effect(owner());
     node->nodes()[i]->Visit(&for_effect);
     Append(for_effect);
   }
 
   intptr_t num_temps = node->num_temps();
   if (num_temps > 0) {
     owner()->DeallocateTemps(num_temps);
     Do(new (Z) DropTempsInstr(num_temps, NULL));
   }
 }
 
-
 void ValueGraphVisitor::VisitLetNode(LetNode* node) {
   BuildLetTempExpressions(node);
 
   // Visit body.
   for (intptr_t i = 0; i < node->nodes().length() - 1; ++i) {
     EffectGraphVisitor for_effect(owner());
     node->nodes()[i]->Visit(&for_effect);
     Append(for_effect);
   }
   // Visit the last body expression for value.
   ValueGraphVisitor for_value(owner());
   node->nodes().Last()->Visit(&for_value);
   Append(for_value);
   Value* result_value = for_value.value();
 
   intptr_t num_temps = node->num_temps();
   if (num_temps > 0) {
     owner()->DeallocateTemps(num_temps);
     ReturnDefinition(new (Z) DropTempsInstr(num_temps, result_value));
   } else {
     ReturnValue(result_value);
   }
 }
 
-
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   const TypeArguments& type_args =
       TypeArguments::ZoneHandle(Z, node->type().arguments());
   Value* element_type =
       BuildInstantiatedTypeArguments(node->token_pos(), type_args);
   Value* num_elements =
       Bind(new (Z) ConstantInstr(Smi::ZoneHandle(Z, Smi::New(node->length()))));
   CreateArrayInstr* create = new (Z) CreateArrayInstr(
       node->token_pos(), element_type, num_elements, owner()->GetNextDeoptId());
   Value* array_val = Bind(create);
@@ skipping 16 matching lines @@
       const intptr_t index_scale = Instance::ElementSizeFor(class_id);
       StoreIndexedInstr* store = new (Z) StoreIndexedInstr(
           array, index, for_value.value(), emit_store_barrier, index_scale,
           class_id, kAlignedAccess, deopt_id, node->token_pos());
       Do(store);
     }
     ReturnDefinition(ExitTempLocalScope(array_val));
   }
 }
 
-
 void EffectGraphVisitor::VisitStringInterpolateNode(
     StringInterpolateNode* node) {
   ValueGraphVisitor for_argument(owner());
   ArrayNode* arguments = node->value();
   if (arguments->length() == 1) {
     ZoneGrowableArray<PushArgumentInstr*>* values =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
     arguments->ElementAt(0)->Visit(&for_argument);
     Append(for_argument);
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
@@ skipping 14 matching lines @@
     ReturnDefinition(call);
     return;
   }
   arguments->Visit(&for_argument);
   Append(for_argument);
   StringInterpolateInstr* instr = new (Z) StringInterpolateInstr(
       for_argument.value(), node->token_pos(), owner()->GetNextDeoptId());
   ReturnDefinition(instr);
 }
 
-
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
   if (function.IsImplicitStaticClosureFunction()) {
     const Instance& closure =
         Instance::ZoneHandle(Z, function.ImplicitStaticClosure());
     ReturnDefinition(new (Z) ConstantInstr(closure));
     return;
   }
 
   const bool is_implicit = function.IsImplicitInstanceClosureFunction();
@@ skipping 98 matching lines @@
           Bind(new (Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
       Value* context = Bind(BuildCurrentContext(node->token_pos()));
       Do(new (Z) StoreInstanceFieldInstr(Closure::context_offset(),
                                          closure_tmp_val, context,
                                          kEmitStoreBarrier, node->token_pos()));
     }
     ReturnDefinition(ExitTempLocalScope(closure_val));
   }
 }
 
-
 void EffectGraphVisitor::BuildPushTypeArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
   if (node.type_args_len() > 0) {
     Value* type_args_val;
     if (node.type_args_var() != NULL) {
       type_args_val =
           Bind(new (Z) LoadLocalInstr(*node.type_args_var(), node.token_pos()));
     } else {
       const TypeArguments& type_args = node.type_arguments();
       ASSERT(!type_args.IsNull() && type_args.IsCanonical() &&
              (type_args.Length() == node.type_args_len()));
       type_args_val =
           BuildInstantiatedTypeArguments(node.token_pos(), type_args);
     }
     PushArgumentInstr* push_type_args = PushArgument(type_args_val);
     values->Add(push_type_args);
   }
 }
 
-
 void EffectGraphVisitor::BuildPushArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
   }
 }
 
-
 void EffectGraphVisitor::BuildInstanceCallConditional(InstanceCallNode* node) {
   const TokenPosition token_pos = node->token_pos();
   LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
   LoadLocalNode* load_temp = new (Z) LoadLocalNode(token_pos, temp_var);
 
   LiteralNode* null_constant =
       new (Z) LiteralNode(ST(token_pos), Object::null_instance());
   ComparisonNode* check_is_null = new (Z)
       ComparisonNode(ST(token_pos), Token::kEQ, load_temp, null_constant);
   TestGraphVisitor for_test(owner(), ST(token_pos));
   check_is_null->Visit(&for_test);
 
   EffectGraphVisitor for_true(owner());
   EffectGraphVisitor for_false(owner());
 
   StoreLocalNode* store_null =
       new (Z) StoreLocalNode(ST(token_pos), temp_var, null_constant);
   store_null->Visit(&for_true);
 
   InstanceCallNode* call = new (Z) InstanceCallNode(
       token_pos, load_temp, node->function_name(), node->arguments());
   StoreLocalNode* store_result =
       new (Z) StoreLocalNode(ST(token_pos), temp_var, call);
   store_result->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
-
 void ValueGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceCallConditional(node);
     ReturnDefinition(BuildLoadExprTemp(node->token_pos()));
   } else {
     EffectGraphVisitor::VisitInstanceCallNode(node);
   }
 }
 
-
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   if (node->is_conditional()) {
     ASSERT(node->arguments()->type_args_len() == 0);
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceCallConditional(node);
   } else {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(
             node->arguments()->LengthWithTypeArgs() + 1);
     BuildPushTypeArguments(*node->arguments(), arguments);
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
     arguments->Add(push_receiver);
     BuildPushArguments(*node->arguments(), arguments);
     InstanceCallInstr* call = new (Z) InstanceCallInstr(
         node->token_pos(), node->function_name(), Token::kILLEGAL, arguments,
         node->arguments()->type_args_len(), node->arguments()->names(), 1,
         owner()->ic_data_array(), owner()->GetNextDeoptId());
     ReturnDefinition(call);
   }
 }
 
-
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->LengthWithTypeArgs());
   BuildPushTypeArguments(*node->arguments(), arguments);
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallInstr* call = new (Z) StaticCallInstr(
       node->token_pos(), node->function(), node->arguments()->type_args_len(),
       node->arguments()->names(), arguments, owner()->ic_data_array(),
       owner()->GetNextDeoptId());
   if (node->function().recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(node->function()));
   }
   ReturnDefinition(call);
 }
 
-
 void EffectGraphVisitor::BuildClosureCall(ClosureCallNode* node,
                                           bool result_needed) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->LengthWithTypeArgs() + 1);
 
   ValueGraphVisitor for_closure(owner());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
   Value* closure_value = for_closure.value();
@@ skipping 17 matching lines @@
       function_val, node, arguments, owner()->GetNextDeoptId());
   if (result_needed) {
     Value* result = Bind(closure_call);
     Do(new (Z) StoreLocalInstr(*tmp_var, result, ST(node->token_pos())));
   } else {
     Do(closure_call);
   }
   ReturnDefinition(ExitTempLocalScope(closure_value));
 }
 
-
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, false);
 }
 
-
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, true);
 }
 
-
 void EffectGraphVisitor::VisitInitStaticFieldNode(InitStaticFieldNode* node) {
   Value* field = Bind(
       new (Z) ConstantInstr(Field::ZoneHandle(Z, node->field().Original())));
   AddInstruction(new (Z) InitStaticFieldInstr(field, node->field(),
                                               owner()->GetNextDeoptId()));
 }
 
-
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Value* context = Bind(BuildCurrentContext(node->token_pos()));
   Value* clone = Bind(new (Z) CloneContextInstr(node->token_pos(), context,
                                                 owner()->GetNextDeoptId()));
   Do(BuildStoreContext(clone, node->token_pos()));
 }
 
-
 Value* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(Z, node->constructor().Owner());
   const bool cls_is_parameterized = cls.NumTypeArguments() > 0;
 
   ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments = new (Z)
       ZoneGrowableArray<PushArgumentInstr*>(cls_is_parameterized ? 1 : 0);
   if (cls_is_parameterized) {
     Value* type_args = BuildInstantiatedTypeArguments(node->token_pos(),
                                                       node->type_arguments());
     allocate_arguments->Add(PushArgument(type_args));
   }
 
   Definition* allocation = new (Z) AllocateObjectInstr(
       node->token_pos(), Class::ZoneHandle(Z, node->constructor().Owner()),
       allocate_arguments);
 
   return Bind(allocation);
 }
 
-
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
 
   BuildPushArguments(*node->arguments(), arguments);
   const intptr_t kTypeArgsLen = 0;
   Do(new (Z)
          StaticCallInstr(node->token_pos(), node->constructor(), kTypeArgsLen,
                          node->arguments()->names(), arguments,
                          owner()->ic_data_array(), owner()->GetNextDeoptId()));
 }
 
-
 static intptr_t GetResultCidOfListFactory(ConstructorCallNode* node) {
   const Function& function = node->constructor();
   const Class& function_class = Class::Handle(function.Owner());
 
   if ((function_class.library() != Library::CoreLibrary()) &&
       (function_class.library() != Library::TypedDataLibrary())) {
     return kDynamicCid;
   }
 
   if (node->constructor().IsFactory()) {
     if ((function_class.Name() == Symbols::List().raw()) &&
         (function.name() == Symbols::ListFactory().raw())) {
       // Special recognition of 'new List()' vs 'new List(n)'.
       if (node->arguments()->length() == 0) {
         return kGrowableObjectArrayCid;
       }
       return kArrayCid;
     }
     return FactoryRecognizer::ResultCid(function);
   }
   return kDynamicCid;  // Not a known list constructor.
 }
 
-
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>();
     PushArgumentInstr* push_type_arguments =
         PushArgument(BuildInstantiatedTypeArguments(node->token_pos(),
                                                     node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
@@ skipping 21 matching lines @@
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Value* allocated_value = BuildObjectAllocation(node);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
 }
 
-
 Value* EffectGraphVisitor::BuildInstantiator(TokenPosition token_pos) {
   Function& outer_function = Function::Handle(Z, owner()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     return NULL;
   }
 
   LocalVariable* instantiator = owner()->parsed_function().instantiator();
   ASSERT(instantiator != NULL);
   Value* result = Bind(BuildLoadLocal(*instantiator, token_pos));
   return result;
 }
 
-
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
     TokenPosition token_pos) {
   const Class& instantiator_class =
       Class::Handle(Z, owner()->function().Owner());
   if (!instantiator_class.IsGeneric()) {
     // The type arguments are compile time constants.
     TypeArguments& type_arguments =
         TypeArguments::ZoneHandle(Z, TypeArguments::null());
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(Z, Type::New(instantiator_class, type_arguments,
@@ skipping 22 matching lines @@
   intptr_t type_arguments_field_offset =
       instantiator_class.type_arguments_field_offset();
   ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
   return Bind(new (Z) LoadFieldInstr(
       instantiator, type_arguments_field_offset,
       Type::ZoneHandle(Z, Type::null()),  // Not an instance, no type.
       token_pos));
 }
 
-
 Value* EffectGraphVisitor::BuildFunctionTypeArguments(TokenPosition token_pos) {
   LocalVariable* function_type_arguments_var =
       owner()->parsed_function().function_type_arguments();
   if (function_type_arguments_var == NULL) {
     // We encountered an uninstantiated type referring to type parameters of a
     // signature that is local to the function being compiled. The type remains
     // uninstantiated. Example: Foo(f<T>(T t)) => null;
     // Foo is non-generic, but takes a generic function f as argument.
     // The uninstantiated function type of f cannot be instantiated from within
     // Foo and should not be instantiated. It is used in uninstantiated form to
     // check incoming closures for assignability. We pass an empty function
     // type argument vector.
     return BuildEmptyTypeArguments(token_pos);
 
     // Note that the function type could also get partially instantiated:
     // Bar<B>(B g<T>(T t)) => null;
     // In this case, function_type_arguments_var will not be null, since Bar
     // is generic, and will be used to partially instantiate the type of g, more
     // specifically the result type of g. Note that the instantiator vector will
     // have length 1, and type parameters with indices above 0, e.g. T, must
     // remain uninstantiated.
   }
   return Bind(BuildLoadLocal(*function_type_arguments_var, token_pos));
 }
 
-
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     TokenPosition token_pos,
     const TypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new (Z) ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
   const Class& instantiator_class =
       Class::ZoneHandle(Z, owner()->function().Owner());
   Value* instantiator_type_args = NULL;
@@ skipping 12 matching lines @@
   if (type_arguments.IsInstantiated(kFunctions)) {
     function_type_args = BuildNullValue(token_pos);
   } else {
     function_type_args = BuildFunctionTypeArguments(token_pos);
   }
   return Bind(new (Z) InstantiateTypeArgumentsInstr(
       token_pos, type_arguments, instantiator_class, instantiator_type_args,
       function_type_args, owner()->GetNextDeoptId()));
 }
 
-
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
   Value* allocate = BuildObjectAllocation(node);
   {
     LocalVariable* tmp_var = EnterTempLocalScope(allocate);
     Value* allocated_tmp =
         Bind(new (Z) LoadLocalInstr(*tmp_var, node->token_pos()));
     PushArgumentInstr* push_allocated_value = PushArgument(allocated_tmp);
     BuildConstructorCall(node, push_allocated_value);
     ReturnDefinition(ExitTempLocalScope(allocate));
   }
 }
 
-
 void EffectGraphVisitor::BuildInstanceGetterConditional(
     InstanceGetterNode* node) {
   const TokenPosition token_pos = node->token_pos();
   LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
   LoadLocalNode* load_temp = new (Z) LoadLocalNode(token_pos, temp_var);
 
   LiteralNode* null_constant =
       new (Z) LiteralNode(ST(token_pos), Object::null_instance());
   ComparisonNode* check_is_null = new (Z)
       ComparisonNode(ST(token_pos), Token::kEQ, load_temp, null_constant);
   TestGraphVisitor for_test(owner(), ST(token_pos));
   check_is_null->Visit(&for_test);
 
   EffectGraphVisitor for_true(owner());
   EffectGraphVisitor for_false(owner());
 
   StoreLocalNode* store_null =
       new (Z) StoreLocalNode(ST(token_pos), temp_var, null_constant);
   store_null->Visit(&for_true);
 
   InstanceGetterNode* getter =
       new (Z) InstanceGetterNode(token_pos, load_temp, node->field_name());
   StoreLocalNode* store_getter =
       new (Z) StoreLocalNode(ST(token_pos), temp_var, getter);
   store_getter->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
-
 void ValueGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceGetterConditional(node);
     ReturnDefinition(BuildLoadExprTemp(node->token_pos()));
   } else {
     EffectGraphVisitor::VisitInstanceGetterNode(node);
   }
 }
 
-
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   if (node->is_conditional()) {
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceGetterConditional(node);
   } else {
     PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
     arguments->Add(push_receiver);
     const String& name =
         String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
     const intptr_t kTypeArgsLen = 0;
     InstanceCallInstr* call = new (Z)
         InstanceCallInstr(node->token_pos(), name, Token::kGET, arguments,
                           kTypeArgsLen, Object::null_array(), 1,
                           owner()->ic_data_array(), owner()->GetNextDeoptId());
     ReturnDefinition(call);
   }
 }
 
-
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
   ValueGraphVisitor for_receiver(owner());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   arguments->Add(PushArgument(for_receiver.value()));
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value(), node->token_pos()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 }
 
-
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   const TokenPosition token_pos = node->token_pos();
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), token_pos));
 
     LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
     LoadLocalNode* load_temp = new (Z) LoadLocalNode(ST(token_pos), temp_var);
@@ skipping 20 matching lines @@
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   const int kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
   InstanceCallInstr* call = new (Z)
       InstanceCallInstr(token_pos, name, Token::kSET, arguments, kTypeArgsLen,
                         Object::null_array(), kNumArgsChecked,
                         owner()->ic_data_array(), owner()->GetNextDeoptId());
   ReturnDefinition(call);
 }
 
-
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   const TokenPosition token_pos = node->token_pos();
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Do(BuildStoreExprTemp(for_receiver.value(), token_pos));
 
     LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
     LoadLocalNode* load_temp = new (Z) LoadLocalNode(ST(token_pos), temp_var);
@@ skipping 25 matching lines @@
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
   Do(new (Z) InstanceCallInstr(token_pos, name, Token::kSET, arguments,
                                kTypeArgsLen, Object::null_array(),
                                kNumArgsChecked, owner()->ic_data_array(),
                                owner()->GetNextDeoptId()));
   ReturnDefinition(BuildLoadExprTemp(token_pos));
 }
 
-
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle(Z, Function::null());
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     ASSERT(node->receiver() != NULL);
     getter_function =
@@ skipping 45 matching lines @@
   }
   ASSERT(!getter_function.IsNull());
   const intptr_t kTypeArgsLen = 0;
   StaticCallInstr* call = new (Z) StaticCallInstr(
       node->token_pos(), getter_function, kTypeArgsLen,
       Object::null_array(),  // No names
       arguments, owner()->ic_data_array(), owner()->GetNextDeoptId());
   ReturnDefinition(call);
 }
 
-
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   const TokenPosition token_pos = node->token_pos();
   // A super setter is an instance setter whose setter function is
   // resolved at compile time (in the caller instance getter's super class).
   // Unlike a static getter, a super getter has a receiver parameter.
@@ skipping 48 matching lines @@
                                    owner()->GetNextDeoptId());
   }
   if (result_is_needed) {
     Do(call);
     ReturnDefinition(BuildLoadExprTemp(token_pos));
   } else {
     ReturnDefinition(call);
   }
 }
 
-
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   BuildStaticSetter(node, false);  // Result not needed.
 }
 
-
 void ValueGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   BuildStaticSetter(node, true);  // Result needed.
 }
 
-
 static intptr_t OffsetForLengthGetter(MethodRecognizer::Kind kind) {
   switch (kind) {
     case MethodRecognizer::kObjectArrayLength:
     case MethodRecognizer::kImmutableArrayLength:
       return Array::length_offset();
     case MethodRecognizer::kTypedDataLength:
       // .length is defined in _TypedList which is the base class for internal
       // and external typed data.
       ASSERT(TypedData::length_offset() == ExternalTypedData::length_offset());
       return TypedData::length_offset();
     case MethodRecognizer::kGrowableArrayLength:
       return GrowableObjectArray::length_offset();
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
-
 LoadLocalInstr* EffectGraphVisitor::BuildLoadThisVar(LocalScope* scope,
                                                      TokenPosition token_pos) {
   LocalVariable* receiver_var = scope->LookupVariable(Symbols::This(),
                                                       true);  // Test only.
   return new (Z) LoadLocalInstr(*receiver_var, token_pos);
 }
 
-
 LoadFieldInstr* EffectGraphVisitor::BuildNativeGetter(
     NativeBodyNode* node,
     MethodRecognizer::Kind kind,
     intptr_t offset,
     const Type& type,
     intptr_t class_id) {
   Value* receiver = Bind(BuildLoadThisVar(node->scope(), node->token_pos()));
   LoadFieldInstr* load =
       new (Z) LoadFieldInstr(receiver, offset, type, node->token_pos());
   load->set_result_cid(class_id);
   load->set_recognized_kind(kind);
   return load;
 }
 
-
 ConstantInstr* EffectGraphVisitor::DoNativeSetterStoreValue(
     NativeBodyNode* node,
     intptr_t offset,
     StoreBarrierType emit_store_barrier) {
   Value* receiver = Bind(BuildLoadThisVar(node->scope(), node->token_pos()));
   LocalVariable* value_var =
       node->scope()->LookupVariable(Symbols::Value(), true);
   Value* value = Bind(new (Z) LoadLocalInstr(*value_var, node->token_pos()));
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       offset, receiver, value, emit_store_barrier, node->token_pos());
   Do(store);
   return new (Z) ConstantInstr(Object::ZoneHandle(Z, Object::null()));
 }
 
-
 void EffectGraphVisitor::VisitNativeBodyNode(NativeBodyNode* node) {
   const Function& function = owner()->function();
   const TokenPosition token_pos = node->token_pos();
   if (!function.IsClosureFunction()) {
     MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(function);
     switch (kind) {
       case MethodRecognizer::kObjectEquals: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope(), token_pos));
         LocalVariable* other_var =
             node->scope()->LookupVariable(Symbols::Other(),
@@ skipping 137 matching lines @@
       }
       default:
         break;
     }
   }
   InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
   NativeCallInstr* native_call = new (Z) NativeCallInstr(node);
   ReturnDefinition(native_call);
 }
 
-
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
-
 // <Expression> ::= LoadLocal { local: LocalVariable }
 void EffectGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   // Nothing to do.
 }
 
-
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   Definition* load = BuildLoadLocal(node->local(), node->token_pos());
   ReturnDefinition(load);
 }
 
-
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   // If the right hand side is an expression that does not contain
   // a safe point for the debugger to stop, add an explicit stub
   // call. Exception: don't do this when assigning to or from internal
   // variables, or for generated code that has no source position.
   if (FLAG_support_debugger) {
     AstNode* rhs = node->value();
     if (rhs->IsAssignableNode()) {
@@ skipping 17 matching lines @@
   if (Isolate::Current()->type_checks()) {
     store_value =
         BuildAssignableValue(node->value()->token_pos(), store_value,
                              node->local().type(), node->local().name());
   }
   Definition* store =
       BuildStoreLocal(node->local(), store_value, node->token_pos());
   ReturnDefinition(store);
 }
 
-
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadFieldInstr* load =
       new (Z) LoadFieldInstr(for_instance.value(), &node->field(),
                              AbstractType::ZoneHandle(Z, node->field().type()),
                              node->token_pos(), &owner()->parsed_function());
   ReturnDefinition(load);
 }
 
-
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   const TokenPosition token_pos = node->token_pos();
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
@@ skipping 17 matching lines @@
     store_value = Bind(BuildLoadExprTemp(token_pos));
   }
   StoreInstanceFieldInstr* store = new (Z)
       StoreInstanceFieldInstr(node->field(), for_instance.value(), store_value,
                               kEmitStoreBarrier, token_pos);
   // Maybe initializing unboxed store.
   store->set_is_initialization(node->is_initializer());
   ReturnDefinition(store);
 }
 
-
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   const TokenPosition token_pos = node->token_pos();
   if (node->field().is_const()) {
     ASSERT(node->field().StaticValue() != Object::sentinel().raw());
     ASSERT(node->field().StaticValue() != Object::transition_sentinel().raw());
     Definition* result = new (Z) ConstantInstr(
         Instance::ZoneHandle(Z, node->field().StaticValue()), token_pos);
     return ReturnDefinition(result);
   }
   Value* field_value = Bind(new (Z) ConstantInstr(
       Field::ZoneHandle(Z, node->field().Original()), token_pos));
   LoadStaticFieldInstr* load =
       new (Z) LoadStaticFieldInstr(field_value, token_pos);
   ReturnDefinition(load);
 }
 
-
 Definition* EffectGraphVisitor::BuildStoreStaticField(
     StoreStaticFieldNode* node,
     bool result_is_needed,
     TokenPosition token_pos) {
   if (FLAG_support_debugger) {
     // If the right hand side is an expression that does not contain
     // a safe point for the debugger to stop, add an explicit stub
     // call.
     AstNode* rhs = node->value();
     if (rhs->IsAssignableNode()) {
@@ skipping 21 matching lines @@
       new (Z) StoreStaticFieldInstr(node->field(), store_value, token_pos);
 
   if (result_is_needed) {
     Do(store);
     return BuildLoadExprTemp(token_pos);
   } else {
     return store;
   }
 }
 
-
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ReturnDefinition(
       BuildStoreStaticField(node, kResultNotNeeded, node->token_pos()));
 }
 
-
 void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ReturnDefinition(
       BuildStoreStaticField(node, kResultNeeded, node->token_pos()));
 }
 
-
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   Function* super_function = NULL;
   if (node->IsSuperLoad()) {
     // Resolve the load indexed operator in the super class.
     super_function = &Function::ZoneHandle(
         Z, Resolver::ResolveDynamicAnyArgs(Z, node->super_class(),
                                            Symbols::IndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
@@ skipping 31 matching lines @@
     // Generate dynamic call to index operator.
     const intptr_t checked_argument_count = 1;
     InstanceCallInstr* load = new (Z) InstanceCallInstr(
         node->token_pos(), Symbols::IndexToken(), Token::kINDEX, arguments,
         kTypeArgsLen, Object::null_array(), checked_argument_count,
         owner()->ic_data_array(), owner()->GetNextDeoptId());
     ReturnDefinition(load);
   }
 }
 
-
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(StoreIndexedNode* node,
                                                         bool result_is_needed) {
   Function* super_function = NULL;
   const TokenPosition token_pos = node->token_pos();
   if (node->IsSuperStore()) {
     // Resolve the store indexed operator in the super class.
     super_function = &Function::ZoneHandle(
         Z, Resolver::ResolveDynamicAnyArgs(Z, node->super_class(),
                                            Symbols::AssignIndexToken()));
     if (super_function->IsNull()) {
@@ skipping 63 matching lines @@
         owner()->ic_data_array(), owner()->GetNextDeoptId());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp(token_pos);
     } else {
       return store;
     }
   }
 }
 
-
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ReturnDefinition(BuildStoreIndexedValues(node, kResultNotNeeded));
 }
 
-
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ReturnDefinition(BuildStoreIndexedValues(node, kResultNeeded));
 }
 
-
 bool EffectGraphVisitor::HasContextScope() const {
   const ContextScope& context_scope =
       ContextScope::Handle(owner()->function().context_scope());
   return !context_scope.IsNull() && (context_scope.num_variables() > 0);
 }
 
-
 void EffectGraphVisitor::UnchainContexts(intptr_t n) {
   // TODO(johnmccutchan): Pass this in.
   const TokenPosition token_pos = TokenPosition::kContext;
   if (n > 0) {
     Value* context = Bind(BuildCurrentContext(token_pos));
     while (n-- > 0) {
       context = Bind(new (Z) LoadFieldInstr(context, Context::parent_offset(),
                                             // Not an instance, no type.
                                             Type::ZoneHandle(Z, Type::null()),
                                             token_pos));
     }
     Do(BuildStoreContext(context, token_pos));
   }
 }
 
-
 void EffectGraphVisitor::AdjustContextLevel(LocalScope* target_scope) {
   ASSERT(target_scope != NULL);
   intptr_t target_context_level = 0;
   if (target_scope->num_context_variables() > 0) {
     // The scope of the target label allocates a context, therefore its outer
     // scope is at a lower context level.
     target_context_level = target_scope->context_level() - 1;
   } else {
     // The scope of the target label does not allocate a context, so its outer
     // scope is at the same context level. Find it.
     while ((target_scope != NULL) &&
            (target_scope->num_context_variables() == 0)) {
       target_scope = target_scope->parent();
     }
     if (target_scope != NULL) {
       target_context_level = target_scope->context_level();
     }
   }
   ASSERT(target_context_level >= 0);
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= target_context_level);
   UnchainContexts(current_context_level - target_context_level);
   // Record adjusted context level.
   owner()->nesting_stack()->AdjustContextLevel(target_context_level);
 }
 
-
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const Function& function = owner()->function();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   const bool is_top_level_sequence =
       node == owner()->parsed_function().node_sequence();
@@ skipping 160 matching lines @@
     // Call _asyncSetThreadStackTrace
     const intptr_t kTypeArgsLen = 0;
     StaticCallInstr* call_async_set_thread_stack_trace = new (Z)
         StaticCallInstr(node->token_pos().ToSynthetic(),
                         async_set_thread_stack_trace, kTypeArgsLen,
                         Object::null_array(), arguments,
                         owner()->ic_data_array(), owner()->GetNextDeoptId());
     Do(call_async_set_thread_stack_trace);
   }
 
-
   if (FLAG_support_debugger && is_top_level_sequence &&
       function.is_debuggable()) {
     // Place a debug check at method entry to ensure breaking on a method always
     // happens, even if there are no assignments/calls/runtimecalls in the first
     // basic block. Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
     const int num_params = function.NumParameters();
     TokenPosition check_pos = TokenPosition::kNoSource;
     if (num_params > 0) {
       const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
@@ skipping 149 matching lines @@
   }
 
   // If this node sequence is labeled, a break out of the sequence will have
   // taken care of unchaining the context.
   if (nested_block.break_target() != NULL) {
     if (is_open()) Goto(nested_block.break_target());
     exit_ = nested_block.break_target();
   }
 }
 
-
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCatchClauseNode (exception)");
   // Restores current context from local variable ':saved_try_context_var'.
   BuildRestoreContext(node->context_var(), node->token_pos());
 
   EffectGraphVisitor for_catch(owner());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
-
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   InlineBailout("EffectGraphVisitor::VisitTryCatchNode (exception)");
   CatchClauseNode* catch_block = node->catch_block();
   SequenceNode* finally_block = node->finally_block();
   if ((finally_block != NULL) && (finally_block->length() == 0)) {
     SequenceNode* catch_sequence = catch_block->sequence();
     if (catch_sequence->length() == 1) {
       // Check for a single rethrow statement. This only matches the synthetic
       // catch-clause generated for try-finally.
       ThrowNode* throw_node = catch_sequence->NodeAt(0)->AsThrowNode();
@@ skipping 113 matching lines @@
   }
 
   // Generate code for the finally block if one exists.
   if ((finally_block != NULL) && is_open()) {
     EffectGraphVisitor for_finally_block(owner());
     finally_block->Visit(&for_finally_block);
     Append(for_finally_block);
   }
 }
 
-
 // Looks up dynamic method noSuchMethod in target_class
 // (including its super class chain) and builds a static call to it.
 StaticCallInstr* EffectGraphVisitor::BuildStaticNoSuchMethodCall(
     const Class& target_class,
     AstNode* receiver,
     const String& method_name,
     ArgumentListNode* method_arguments,
     bool save_last_arg,
     bool is_super_invocation) {
   TokenPosition args_pos = method_arguments->token_pos();
@@ skipping 21 matching lines @@
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
   ZoneGrowableArray<PushArgumentInstr*>* push_arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildPushArguments(*args, push_arguments);
   return new (Z) StaticCallInstr(
       args_pos, no_such_method_func, kTypeArgsLen, Object::null_array(),
       push_arguments, owner()->ic_data_array(), owner()->GetNextDeoptId());
 }
 
-
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
     TokenPosition token_pos,
     const Class& function_class,
     const String& function_name,
     ArgumentListNode* function_arguments,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>();
   // Object receiver, actually a class literal of the unresolved method's owner.
   AbstractType& type = Type::ZoneHandle(
@@ skipping 46 matching lines @@
       Z, Resolver::ResolveStatic(
              cls, Library::PrivateCoreLibName(Symbols::ThrowNew()),
              kTypeArgsLen, arguments->length(), Object::null_array()));
   ASSERT(!func.IsNull());
   return new (Z) StaticCallInstr(token_pos, func, kTypeArgsLen,
                                  Object::null_array(),  // No names.
                                  arguments, owner()->ic_data_array(),
                                  owner()->GetNextDeoptId());
 }
 
-
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   if (FLAG_support_debugger) {
     if (node->exception()->IsLiteralNode() ||
         node->exception()->IsLoadLocalNode() ||
         node->exception()->IsLoadStaticFieldNode() ||
         node->exception()->IsClosureNode()) {
       AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
                                                  RawPcDescriptors::kRuntimeCall,
                                                  owner()->GetNextDeoptId()));
     }
   }
   ValueGraphVisitor for_exception(owner());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
     instr = new (Z) ThrowInstr(node->token_pos(), owner()->GetNextDeoptId());
   } else {
     ValueGraphVisitor for_stack_trace(owner());
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
     PushArgument(for_stack_trace.value());
     instr = new (Z) ReThrowInstr(node->token_pos(), owner()->catch_try_index(),
                                  owner()->GetNextDeoptId());
   }
   AddInstruction(instr);
 }
 
-
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
   CloseFragment();
 }
 
-
 // A throw cannot be part of an expression, however, the parser may replace
 // certain expression nodes with a throw. In that case generate a literal null
 // so that the fragment is not closed in the middle of an expression.
 void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
   ReturnDefinition(
       new (Z) ConstantInstr(Instance::ZoneHandle(Z, Instance::null())));
 }
 
-
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   InlineBailout("EffectGraphVisitor::VisitInlinedFinallyNode (exception)");
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     intptr_t outer_try_index = node->try_index();
     owner()->set_try_index(outer_try_index);
   }
@@ skipping 21 matching lines @@
                                owner()->GetNextDeoptId());
     for_finally_block.Goto(after_finally);
     for_finally_block.exit_ = after_finally;
   }
 
   Goto(finally_entry);
   AppendFragment(finally_entry, for_finally_block);
   exit_ = for_finally_block.exit_;
 }
 
-
 void EffectGraphVisitor::VisitStopNode(StopNode* node) {
   AddInstruction(new (Z) StopInstr(node->message()));
 }
 
-
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   VMTagScope tagScope(thread(), VMTag::kCompileFlowGraphBuilderTagId,
                       FLAG_profile_vm);
   if (FLAG_support_ast_printer && FLAG_print_ast &&
       FlowGraphPrinter::ShouldPrint(parsed_function().function())) {
     // Print the function ast before IL generation.
     AstPrinter ast_printer;
     ast_printer.PrintFunctionNodes(parsed_function());
   }
   if (FLAG_support_ast_printer && FLAG_print_scopes &&
@@ skipping 18 matching lines @@
   if (osr_id_ != Compiler::kNoOSRDeoptId) {
     graph_entry_->RelinkToOsrEntry(Z, last_used_block_id_);
   }
 
   FlowGraph* graph =
       new (Z) FlowGraph(parsed_function(), graph_entry_, last_used_block_id_);
   graph->set_await_token_positions(await_token_positions_);
   return graph;
 }
 
-
 void FlowGraphBuilder::AppendAwaitTokenPosition(TokenPosition token_pos) {
   await_token_positions_->Add(token_pos);
 }
 
-
 void FlowGraphBuilder::Bailout(const char* reason) const {
   parsed_function_.Bailout("FlowGraphBuilder", reason);
 }
 
-
 bool FlowGraphBuilder::SimpleInstanceOfType(const AbstractType& type) {
   // Bail if the type is still uninstantiated at compile time.
   if (!type.IsInstantiated()) return false;
 
   // Bail if the type is a function or a Dart Function type.
   if (type.IsFunctionType() || type.IsDartFunctionType()) return false;
 
   ASSERT(type.HasResolvedTypeClass());
   const Class& type_class = Class::Handle(type.type_class());
   // Bail if the type has any type parameters.
   if (type_class.IsGeneric()) return false;
 
   // Finally a simple class for instance of checking.
   return true;
 }
 
 }  // namespace dart