[kernel] [partial] Streaming of kernel binary without AST nodes

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 798 matching lines @@
     Field* field = fields[i];
     Expression* initializer = field->initializer();
     if (!field->IsStatic() && (initializer != NULL)) {
       initializer->AcceptExpressionVisitor(this);
     }
   }
   node->VisitChildren(this);
 }
 
 
-class BreakableBlock {
- public:
-  BreakableBlock(FlowGraphBuilder* builder, LabeledStatement* statement)
-      : builder_(builder),
-        labeled_statement_(statement),
-        outer_(builder->breakable_block_),
-        destination_(NULL),
-        outer_finally_(builder->try_finally_block_),
-        context_depth_(builder->context_depth_),
-        try_index_(builder->CurrentTryIndex()) {
-    builder_->breakable_block_ = this;
-  }
-  ~BreakableBlock() { builder_->breakable_block_ = outer_; }
-
-  bool HadJumper() { return destination_ != NULL; }
-
-  JoinEntryInstr* destination() { return destination_; }
-
-  JoinEntryInstr* BreakDestination(LabeledStatement* label,
-                                   TryFinallyBlock** outer_finally,
-                                   intptr_t* context_depth) {
-    BreakableBlock* block = builder_->breakable_block_;
-    while (block->labeled_statement_ != label) {
-      block = block->outer_;
-    }
-    ASSERT(block != NULL);
-    *outer_finally = block->outer_finally_;
-    *context_depth = block->context_depth_;
-    return block->EnsureDestination();
-  }
-
- private:
-  JoinEntryInstr* EnsureDestination() {
-    if (destination_ == NULL) {
-      destination_ = builder_->BuildJoinEntry(try_index_);
-    }
-    return destination_;
-  }
-
-  FlowGraphBuilder* builder_;
-  LabeledStatement* labeled_statement_;
-  BreakableBlock* outer_;
-  JoinEntryInstr* destination_;
-  TryFinallyBlock* outer_finally_;
-  intptr_t context_depth_;
-  intptr_t try_index_;
-};
-
-
-class SwitchBlock {
- public:
-  SwitchBlock(FlowGraphBuilder* builder, SwitchStatement* switch_stmt)
-      : builder_(builder),
-        outer_(builder->switch_block_),
-        outer_finally_(builder->try_finally_block_),
-        switch_statement_(switch_stmt),
-        context_depth_(builder->context_depth_),
-        try_index_(builder->CurrentTryIndex()) {
-    builder_->switch_block_ = this;
-  }
-  ~SwitchBlock() { builder_->switch_block_ = outer_; }
-
-  bool HadJumper(SwitchCase* switch_case) {
-    return destinations_.Lookup(switch_case) != NULL;
-  }
-
-  JoinEntryInstr* Destination(SwitchCase* label,
-                              TryFinallyBlock** outer_finally = NULL,
-                              intptr_t* context_depth = NULL) {
-    // Find corresponding [SwitchStatement].
-    SwitchBlock* block = this;
-    while (true) {
-      block->EnsureSwitchCaseMapping();
-      if (block->Contains(label)) break;
-      block = block->outer_;
-    }
-
-    // Set the outer finally block.
-    if (outer_finally != NULL) {
-      *outer_finally = block->outer_finally_;
-      *context_depth = block->context_depth_;
-    }
-
-    // Ensure there's [JoinEntryInstr] for that [SwitchCase].
-    return block->EnsureDestination(label);
-  }
-
- private:
-  typedef std::set<SwitchCase*> DestinationSwitches;
-
-  JoinEntryInstr* EnsureDestination(SwitchCase* switch_case) {
-    JoinEntryInstr* cached_inst = destinations_.Lookup(switch_case);
-    if (cached_inst == NULL) {
-      JoinEntryInstr* inst = builder_->BuildJoinEntry(try_index_);
-      destinations_.Insert(switch_case, inst);
-      return inst;
-    }
-    return cached_inst;
-  }
-
-  void EnsureSwitchCaseMapping() {
-    if (destination_switches_.begin() == destination_switches_.end()) {
-      List<SwitchCase>& cases = switch_statement_->cases();
-      for (intptr_t i = 0; i < cases.length(); i++) {
-        destination_switches_.insert(cases[i]);
-      }
-    }
-  }
-
-  bool Contains(SwitchCase* sc) {
-    return destination_switches_.find(sc) != destination_switches_.end();
-  }
-
-  FlowGraphBuilder* builder_;
-  SwitchBlock* outer_;
-
-  Map<SwitchCase, JoinEntryInstr*> destinations_;
-  DestinationSwitches destination_switches_;
-
-  TryFinallyBlock* outer_finally_;
-  SwitchStatement* switch_statement_;
-  intptr_t context_depth_;
-  intptr_t try_index_;
-};
-
-
-class TryFinallyBlock {
- public:
-  TryFinallyBlock(FlowGraphBuilder* builder, Statement* finalizer)
-      : builder_(builder),
-        outer_(builder->try_finally_block_),
-        finalizer_(finalizer),
-        context_depth_(builder->context_depth_),
-        // Finalizers are executed outside of the try block hence
-        // try depth of finalizers are one less than current try
-        // depth.
-        try_depth_(builder->try_depth_ - 1),
-        try_index_(builder_->CurrentTryIndex()) {
-    builder_->try_finally_block_ = this;
-  }
-  ~TryFinallyBlock() { builder_->try_finally_block_ = outer_; }
-
-  Statement* finalizer() const { return finalizer_; }
-  intptr_t context_depth() const { return context_depth_; }
-  intptr_t try_depth() const { return try_depth_; }
-  intptr_t try_index() const { return try_index_; }
-  TryFinallyBlock* outer() const { return outer_; }
-
- private:
-  FlowGraphBuilder* const builder_;
-  TryFinallyBlock* const outer_;
-  Statement* const finalizer_;
-  const intptr_t context_depth_;
-  const intptr_t try_depth_;
-  const intptr_t try_index_;
-};
-
-
-class TryCatchBlock {
- public:
-  explicit TryCatchBlock(FlowGraphBuilder* builder,
-                         intptr_t try_handler_index = -1)
-      : builder_(builder),
-        outer_(builder->try_catch_block_),
-        try_index_(try_handler_index) {
-    if (try_index_ == -1) try_index_ = builder->AllocateTryIndex();
-    builder->try_catch_block_ = this;
-  }
-  ~TryCatchBlock() { builder_->try_catch_block_ = outer_; }
-
-  intptr_t try_index() { return try_index_; }
-  TryCatchBlock* outer() const { return outer_; }
-
- private:
-  FlowGraphBuilder* builder_;
-  TryCatchBlock* outer_;
-  intptr_t try_index_;
-};
-
-
 Fragment& Fragment::operator+=(const Fragment& other) {
   if (entry == NULL) {
     entry = other.entry;
     current = other.current;
   } else if (current != NULL && other.entry != NULL) {
     current->LinkTo(other.entry);
     current = other.current;
   }
   return *this;
 }
@@ skipping 1255 matching lines @@
       try_catch_block_ = try_catch_block_->outer();
       changed_try_index = true;
     }
     if (changed_try_index) {
       JoinEntryInstr* entry = BuildJoinEntry();
       instructions += Goto(entry);
       instructions = Fragment(instructions.entry, entry);
     }
 
     Statement* finalizer = try_finally_block_->finalizer();
+    intptr_t finalizer_kernel_offset =
+        try_finally_block_->finalizer_kernel_offset();
     try_finally_block_ = try_finally_block_->outer();
-
-    // This will potentially have exceptional cases as described in
-    // [VisitTryFinally] and will handle them.
-    instructions += TranslateStatement(finalizer);
+    if (finalizer != NULL) {
+      // This will potentially have exceptional cases as described in
+      // [VisitTryFinally] and will handle them.
+      instructions += TranslateStatement(finalizer);
+    } else {
+      instructions += streaming_flow_graph_builder_->BuildStatementAt(
+          finalizer_kernel_offset);
+    }
 
     // We only need to make sure that if the finalizer ended normally, we
     // continue towards the next outer try-finally.
     if (!instructions.is_open()) break;
   }
 
   if (instructions.is_open() && target_context_depth != -1) {
     // A target context depth of -1 indicates that the code after this
     // will not care about the context chain so we can leave it any way we
     // want after the last finalizer.  That is used when returning.
     instructions += AdjustContextTo(target_context_depth);
   }
 
   try_finally_block_ = saved_block;
   try_catch_block_ = saved_try_catch_block;
   context_depth_ = saved_depth;
   try_depth_ = saved_try_depth;
 
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::EnterScope(TreeNode* node, bool* new_context) {
+  return EnterScope(node->kernel_offset(), new_context);
+}
+
+
+Fragment FlowGraphBuilder::EnterScope(intptr_t kernel_offset,
+                                      bool* new_context) {
   Fragment instructions;
   const intptr_t context_size =
-      scopes_->scopes.Lookup(node->kernel_offset())->num_context_variables();
+      scopes_->scopes.Lookup(kernel_offset)->num_context_variables();
   if (context_size > 0) {
     instructions += PushContext(context_size);
     instructions += Drop();
     if (new_context != NULL) {
       *new_context = true;
     }
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::ExitScope(TreeNode* node) {
+  return ExitScope(node->kernel_offset());
+}
+
+
+Fragment FlowGraphBuilder::ExitScope(intptr_t kernel_offset) {
   Fragment instructions;
   const intptr_t context_size =
-      scopes_->scopes.Lookup(node->kernel_offset())->num_context_variables();
+      scopes_->scopes.Lookup(kernel_offset)->num_context_variables();
   if (context_size > 0) {
     instructions += PopContext();
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::LoadContextAt(int depth) {
   intptr_t delta = context_depth_ - depth;
   ASSERT(delta >= 0);
@@ skipping 856 matching lines @@
 }
 
 
 LocalVariable* FlowGraphBuilder::LookupVariable(VariableDeclaration* var) {
   LocalVariable* local = scopes_->locals.Lookup(var->kernel_offset());
   ASSERT(local != NULL);
   return local;
 }
 
 
+dart::LocalVariable* FlowGraphBuilder::LookupVariable(intptr_t kernel_offset) {
+  LocalVariable* local = scopes_->locals.Lookup(kernel_offset);
+  ASSERT(local != NULL);
+  return local;
+}
+
+
 void FlowGraphBuilder::SetTempIndex(Definition* definition) {
   definition->set_temp_index(
       stack_ == NULL ? 0 : stack_->definition()->temp_index() + 1);
 }
 
 
 void FlowGraphBuilder::Push(Definition* definition) {
   SetTempIndex(definition);
   Value::AddToList(new (Z) Value(definition), &stack_);
 }
@@ skipping 775 matching lines @@
     const AbstractType& dst_type = T.TranslateType(variable->type());
     if (dst_type.IsMalformed()) {
       return ThrowTypeError();
     }
     return CheckAssignableInCheckedMode(dst_type,
                                         H.DartSymbol(variable->name()));
   }
   return Fragment();
 }
 
+Fragment FlowGraphBuilder::CheckVariableTypeInCheckedMode(
+    const AbstractType& dst_type,
+    const dart::String& name_symbol) {
+  if (I->type_checks()) {
+    if (dst_type.IsMalformed()) {
+      return ThrowTypeError();
+    }
+    return CheckAssignableInCheckedMode(dst_type, name_symbol);
+  }
+  return Fragment();
+}
+
 
 bool FlowGraphBuilder::NeedsDebugStepCheck(const Function& function,
                                            TokenPosition position) {
   return FLAG_support_debugger && position.IsDebugPause() &&
          !function.is_native() && function.is_debuggable();
 }
 
 
 bool FlowGraphBuilder::NeedsDebugStepCheck(Value* value,
                                            TokenPosition position) {
@@ skipping 533 matching lines @@
     }
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::TranslateStatement(Statement* statement) {
 #ifdef DEBUG
   intptr_t original_context_depth = context_depth_;
 #endif
-  statement->AcceptStatementVisitor(this);
+
+  // TODO(jensj): VariableDeclaration doesn't necessarily have a tag.
+  if (statement->can_stream() &&
+      statement->Type() != Node::kTypeVariableDeclaration) {
+    fragment_ = streaming_flow_graph_builder_->BuildStatementAt(
+        statement->kernel_offset());
+  } else {
+    statement->AcceptStatementVisitor(this);
+  }
   DEBUG_ASSERT(context_depth_ == original_context_depth);
   return fragment_;
 }
 
 
 Fragment FlowGraphBuilder::TranslateCondition(Expression* expression,
                                               bool* negate) {
   *negate = expression->IsNot();
   Fragment instructions;
   if (*negate) {
     instructions += TranslateExpression(Not::Cast(expression)->expression());
   } else {
     instructions += TranslateExpression(expression);
   }
   instructions += CheckBooleanInCheckedMode();
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::TranslateExpression(Expression* expression) {
-  expression->AcceptExpressionVisitor(this);
+  if (expression->can_stream()) {
+    fragment_ = streaming_flow_graph_builder_->BuildExpressionAt(
+        expression->kernel_offset());
+  } else {
+    expression->AcceptExpressionVisitor(this);
+  }
   return fragment_;
 }
 
 
 ArgumentArray FlowGraphBuilder::GetArguments(int count) {
   ArgumentArray arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(Z, count);
   arguments->SetLength(count);
   for (intptr_t i = count - 1; i >= 0; --i) {
     ASSERT(stack_->definition()->IsPushArgument());
     ASSERT(!stack_->definition()->HasSSATemp());
     arguments->data()[i] = stack_->definition()->AsPushArgument();
     Drop();
   }
   pending_argument_count_ -= count;
   ASSERT(pending_argument_count_ >= 0);
   return arguments;
 }
 
 
+#define STREAM_EXPRESSION_IF_POSSIBLE(node)                                    \
+  if (node->can_stream()) {                                                    \
+    fragment_ = streaming_flow_graph_builder_->BuildExpressionAt(              \
+        node->kernel_offset());                                                \
+    return;                                                                    \
+  }
+
+
 void FlowGraphBuilder::VisitInvalidExpression(InvalidExpression* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitNullLiteral(NullLiteral* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitBoolLiteral(BoolLiteral* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitIntLiteral(IntLiteral* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitBigintLiteral(BigintLiteral* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitDoubleLiteral(DoubleLiteral* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitStringLiteral(StringLiteral* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitSymbolLiteral(SymbolLiteral* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 AbstractType& DartTypeTranslator::TranslateType(DartType* node) {
   node->AcceptDartTypeVisitor(this);
 
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
   return AbstractType::ZoneHandle(Z, result_.raw());
 }
@@ skipping 282 matching lines @@
   }
   type = Type::New(klass, TypeArguments::Handle(Z, klass.type_parameters()),
                    klass.token_pos());
   if (klass.is_type_finalized()) {
     type ^= ClassFinalizer::FinalizeType(klass, type);
     klass.SetCanonicalType(type);
   }
   return type;
 }
 
+void FlowGraphBuilder::VisitTypeLiteral(TypeLiteral* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
 
-void FlowGraphBuilder::VisitTypeLiteral(TypeLiteral* node) {
   const AbstractType& type = T.TranslateType(node->type());
   if (type.IsMalformed()) H.ReportError("Malformed type literal");
 
   Fragment instructions;
   if (type.IsInstantiated()) {
     instructions += Constant(type);
   } else {
     if (!type.IsInstantiated(kCurrentClass)) {
       instructions += LoadInstantiatorTypeArguments();
     } else {
       instructions += NullConstant();
     }
     if (!type.IsInstantiated(kFunctions)) {
       instructions += LoadFunctionTypeArguments();
     } else {
       instructions += NullConstant();
     }
     instructions += InstantiateType(type);
   }
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitVariableGet(VariableGet* node) {
-  fragment_ = LoadLocal(LookupVariable(node->variable()));
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitVariableSet(VariableSet* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateExpression(node->expression());
   if (NeedsDebugStepCheck(stack_, node->position())) {
     instructions = DebugStepCheck(node->position()) + instructions;
   }
   instructions += CheckVariableTypeInCheckedMode(node->variable());
   instructions +=
       StoreLocal(node->position(), LookupVariable(node->variable()));
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
-  if (node->kernel_offset() != -1) {
-    fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
-    return;
-  }
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   // A StaticGet will always have a kernel_offset, except for the StaticGet that
   // was manually created for _getMainClosure in dart:_builtin.  Compile that
   // one specially here.
   const dart::Library& builtin =
       dart::Library::Handle(Z, I->object_store()->builtin_library());
   const Object& main =
       Object::Handle(Z, builtin.LookupObjectAllowPrivate(dart::String::Handle(
                             Z, dart::String::New("main"))));
   if (main.IsField()) {
     UNIMPLEMENTED();
   } else if (main.IsFunction()) {
     const Function& function = Function::Cast(main);
     if (function.kind() == RawFunction::kRegularFunction) {
       const Function& closure_function =
           Function::Handle(Z, function.ImplicitClosureFunction());
       closure_function.set_kernel_function(function.kernel_function());
       const Instance& closure =
           Instance::ZoneHandle(Z, closure_function.ImplicitStaticClosure());
       fragment_ = Constant(closure);
     } else {
       UNIMPLEMENTED();
     }
   } else {
     UNIMPLEMENTED();
   }
 }
 
 
 void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   NameIndex target = node->target();
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
     Fragment instructions = TranslateExpression(node->expression());
     if (NeedsDebugStepCheck(stack_, node->position())) {
       instructions = DebugStepCheck(node->position()) + instructions;
     }
     instructions += CheckAssignableInCheckedMode(
@@ skipping 17 matching lines @@
         Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
     instructions += StaticCall(node->position(), function, 1);
 
     // Drop the unused result & leave the stored value on the stack.
     fragment_ = instructions + Drop();
   }
 }
 
 
 void FlowGraphBuilder::VisitPropertyGet(PropertyGet* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   const dart::String& getter_name = H.DartGetterName(node->name());
   fragment_ = instructions +
               InstanceCall(node->position(), getter_name, Token::kGET, 1);
 }
 
 
 void FlowGraphBuilder::VisitPropertySet(PropertySet* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions(NullConstant());
   LocalVariable* variable = MakeTemporary();
   instructions += TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateExpression(node->value());
   instructions += StoreLocal(TokenPosition::kNoSource, variable);
   instructions += PushArgument();
 
   const dart::String& setter_name = H.DartSetterName(node->name());
   instructions += InstanceCall(node->position(), setter_name, Token::kSET, 2);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Function& target = Function::ZoneHandle(Z);
   NameIndex kernel_name = node->target();
   if (H.IsProcedure(kernel_name)) {
     if (H.IsGetter(kernel_name)) {
       target = LookupMethodByMember(kernel_name, H.DartGetterName(kernel_name));
     } else {
       target = LookupMethodByMember(kernel_name, H.DartMethodName(kernel_name));
       target = target.ImplicitClosureFunction();
       ASSERT(!target.IsNull());
       fragment_ = BuildImplicitClosureCreation(target);
       return;
     }
   } else {
     ASSERT(H.IsField(kernel_name));
     const dart::String& getter_name = H.DartGetterName(kernel_name);
     target = LookupMethodByMember(kernel_name, getter_name);
     ASSERT(target.IsGetterFunction() || target.IsImplicitGetterFunction());
   }
 
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   fragment_ = instructions + StaticCall(node->position(), target, 1);
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertySet(DirectPropertySet* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   const dart::String& method_name = H.DartSetterName(node->target());
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(node->target(), method_name));
   ASSERT(target.IsSetterFunction() || target.IsImplicitSetterFunction());
 
   Fragment instructions(NullConstant());
   LocalVariable* value = MakeTemporary();
   instructions += TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateExpression(node->value());
   instructions += StoreLocal(TokenPosition::kNoSource, value);
   instructions += PushArgument();
   instructions += StaticCall(node->position(), target, 2);
 
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitStaticInvocation(StaticInvocation* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   const Function& target = Function::ZoneHandle(
       Z, H.LookupStaticMethodByKernelProcedure(node->procedure()));
   const dart::Class& klass = dart::Class::ZoneHandle(Z, target.Owner());
   intptr_t argument_count = node->arguments()->count();
   if (target.IsGenerativeConstructor() || target.IsFactory()) {
     // The VM requires a TypeArguments object as first parameter for
     // every factory constructor.
     ++argument_count;
   }
 
@@ skipping 99 matching lines @@
       fragment_ = instructions + StrictCompare(strict_cmp_kind,
                                                /*number_check = */ true);
       return true;
     }
   }
   return false;
 }
 
 
 void FlowGraphBuilder::VisitMethodInvocation(MethodInvocation* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   const dart::String& name = H.DartMethodName(node->name());
   const intptr_t argument_count = node->arguments()->count() + 1;
   const Token::Kind token_kind = MethodKind(name);
   if (IsNumberLiteral(node->receiver())) {
     if ((argument_count == 1) && (token_kind == Token::kNEGATE)) {
       const Object& result = constant_evaluator_.EvaluateExpressionSafe(node);
       if (!result.IsError()) {
         fragment_ = Constant(result);
         return;
       }
@@ skipping 34 matching lines @@
   // actually produce any value. See http://dartbug.com/29135 for more details.
   if (name.raw() == Symbols::AssignIndexToken().raw()) {
     fragment_ += Drop();
     fragment_ += NullConstant();
   }
 }
 
 
 void FlowGraphBuilder::VisitDirectMethodInvocation(
     DirectMethodInvocation* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   const dart::String& method_name = H.DartProcedureName(node->target());
   const Token::Kind token_kind = MethodKind(method_name);
 
   if (RecognizeComparisonWithNull(token_kind, node)) return;
 
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(node->target(), method_name));
 
   intptr_t argument_count = node->arguments()->count() + 1;
   Array& argument_names = Array::ZoneHandle(Z);
 
   // TODO(28109) Support generic methods in the VM or reify them away.
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateArguments(node->arguments(), &argument_names);
   fragment_ = instructions + StaticCall(node->position(), target,
                                         argument_count, argument_names);
 }
 
 
 void FlowGraphBuilder::VisitConstructorInvocation(ConstructorInvocation* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   if (node->is_const()) {
     fragment_ =
         Constant(constant_evaluator_.EvaluateConstructorInvocation(node));
     return;
   }
 
   dart::Class& klass = dart::Class::ZoneHandle(
       Z, H.LookupClassByKernelClass(H.EnclosingName(node->target())));
 
   Fragment instructions;
@@ skipping 68 matching lines @@
   const Function& target = Function::ZoneHandle(
       Z, H.LookupConstructorByKernelConstructor(klass, node->target()));
   intptr_t argument_count = node->arguments()->count() + 1;
   instructions +=
       StaticCall(node->position(), target, argument_count, argument_names);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitIsExpression(IsExpression* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateExpression(node->operand());
 
   // The VM does not like an instanceOf call with a dynamic type. We need to
   // special case this situation.
   const Type& object_type = Type::Handle(Z, Type::ObjectType());
   const AbstractType& type = T.TranslateType(node->type());
   if (type.IsMalformed()) {
     instructions += Drop();
     instructions += ThrowTypeError();
     fragment_ = instructions;
@@ skipping 43 matching lines @@
         InstanceCall(node->position(),
                      dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
                      Token::kIS, 4);
   }
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitAsExpression(AsExpression* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateExpression(node->operand());
 
   // The VM does not like an Object_as call with a dynamic type. We need to
   // special case this situation.
   const Type& object_type = Type::Handle(Z, Type::ObjectType());
   const AbstractType& type = T.TranslateType(node->type());
   if (type.IsMalformed()) {
     instructions += Drop();
     instructions += ThrowTypeError();
     fragment_ = instructions;
@@ skipping 27 matching lines @@
     instructions += InstanceCall(
         node->position(), dart::Library::PrivateCoreLibName(Symbols::_as()),
         Token::kAS, 4);
   }
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitConditionalExpression(ConditionalExpression* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   bool negate;
   Fragment instructions = TranslateCondition(node->condition(), &negate);
 
   TargetEntryInstr* then_entry;
   TargetEntryInstr* otherwise_entry;
   instructions += BranchIfTrue(&then_entry, &otherwise_entry, negate);
 
   Value* top = stack_;
   Fragment then_fragment(then_entry);
   then_fragment += TranslateExpression(node->then());
@@ skipping 12 matching lines @@
   JoinEntryInstr* join = BuildJoinEntry();
   then_fragment += Goto(join);
   otherwise_fragment += Goto(join);
 
   fragment_ = Fragment(instructions.entry, join) +
               LoadLocal(parsed_function_->expression_temp_var());
 }
 
 
 void FlowGraphBuilder::VisitLogicalExpression(LogicalExpression* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   bool negate;
   Fragment instructions = TranslateCondition(node->left(), &negate);
   TargetEntryInstr* right_entry;
   TargetEntryInstr* constant_entry;
 
   if (node->op() == LogicalExpression::kAnd) {
     instructions += BranchIfTrue(&right_entry, &constant_entry, negate);
   } else {
     instructions += BranchIfTrue(&constant_entry, &right_entry, negate);
   }
@@ skipping 19 matching lines @@
   JoinEntryInstr* join = BuildJoinEntry();
   right_fragment += Goto(join);
   constant_fragment += Goto(join);
 
   fragment_ = Fragment(instructions.entry, join) +
               LoadLocal(parsed_function_->expression_temp_var());
 }
 
 
 void FlowGraphBuilder::VisitNot(Not* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateExpression(node->expression());
   instructions += CheckBooleanInCheckedMode();
   instructions += BooleanNegate();
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitThisExpression(ThisExpression* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitStringConcatenation(StringConcatenation* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   List<Expression>& expressions = node->expressions();
 
   Fragment instructions;
 
   if (node->expressions().length() == 1) {
     instructions += TranslateExpression(node->expressions()[0]);
     instructions += StringInterpolateSingle(node->position());
   } else {
     // The type arguments for CreateArray.
     instructions += Constant(TypeArguments::ZoneHandle(Z));
     instructions += IntConstant(expressions.length());
     instructions += CreateArray();
     LocalVariable* array = MakeTemporary();
 
     for (intptr_t i = 0; i < node->expressions().length(); i++) {
       instructions += LoadLocal(array);
       instructions += IntConstant(i);
       instructions += TranslateExpression(node->expressions()[i]);
       instructions += StoreIndexed(kArrayCid);
       instructions += Drop();
     }
 
     instructions += StringInterpolate(node->position());
   }
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitListLiteral(ListLiteral* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   if (node->is_const()) {
     fragment_ = Constant(constant_evaluator_.EvaluateListLiteral(node));
     return;
   }
 
   DartType* types[] = {node->type()};
   const TypeArguments& type_arguments = T.TranslateTypeArguments(types, 1);
 
   // The type argument for the factory call.
   Fragment instructions = TranslateInstantiatedTypeArguments(type_arguments);
@@ skipping 21 matching lines @@
   const dart::Class& factory_class =
       dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::List()));
   const Function& factory_method = Function::ZoneHandle(
       Z, factory_class.LookupFactory(
              dart::Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
   fragment_ = instructions + StaticCall(node->position(), factory_method, 2);
 }
 
 
 void FlowGraphBuilder::VisitMapLiteral(MapLiteral* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   if (node->is_const()) {
     fragment_ = Constant(constant_evaluator_.EvaluateMapLiteral(node));
     return;
   }
 
   const dart::Class& map_class =
       dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::Map()));
   const Function& factory_method = Function::ZoneHandle(
       Z, map_class.LookupFactory(
              dart::Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
@@ skipping 36 matching lines @@
   fragment_ = instructions + StaticCall(node->position(), factory_method, 2);
 }
 
 
 void FlowGraphBuilder::VisitFunctionExpression(FunctionExpression* node) {
   fragment_ = TranslateFunctionNode(node->function(), node);
 }
 
 
 void FlowGraphBuilder::VisitLet(Let* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateStatement(node->variable());
   instructions += TranslateExpression(node->body());
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitThrow(Throw* node) {
+  STREAM_EXPRESSION_IF_POSSIBLE(node);
+
   Fragment instructions;
 
   instructions += TranslateExpression(node->expression());
   if (NeedsDebugStepCheck(stack_, node->position())) {
     instructions = DebugStepCheck(node->position()) + instructions;
   }
   instructions += PushArgument();
   instructions += ThrowException(node->position());
   ASSERT(instructions.is_closed());
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitRethrow(Rethrow* node) {
-  fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
+  fragment_ =
+      streaming_flow_graph_builder_->BuildExpressionAt(node->kernel_offset());
 }
 
 
 Fragment FlowGraphBuilder::TranslateArguments(Arguments* node,
                                               Array* argument_names) {
   Fragment instructions;
 
   List<Expression>& positional = node->positional();
   for (intptr_t i = 0; i < positional.length(); ++i) {
     instructions += TranslateExpression(positional[i]);
     instructions += PushArgument();
   }
 
   List<NamedExpression>& named = node->named();
   if (argument_names != NULL) {
     *argument_names = H.ArgumentNames(&named).raw();
   }
   for (intptr_t i = 0; i < named.length(); ++i) {
     NamedExpression* named_expression = named[i];
     instructions += TranslateExpression(named_expression->expression());
     instructions += PushArgument();
   }
   return instructions;
 }
 
+#define STREAM_STATEMENT_IF_POSSIBLE(node)                                     \
+  if (node->can_stream()) {                                                    \
+    fragment_ = streaming_flow_graph_builder_->BuildStatementAt(               \
+        node->kernel_offset());                                                \
+    return;                                                                    \
+  }
+
 
 void FlowGraphBuilder::VisitInvalidStatement(InvalidStatement* node) {
-  H.ReportError("Invalid statements not implemented yet!");
+  fragment_ =
+      streaming_flow_graph_builder_->BuildStatementAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitEmptyStatement(EmptyStatement* node) {
-  fragment_ = Fragment();
+  fragment_ =
+      streaming_flow_graph_builder_->BuildStatementAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitBlock(Block* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   Fragment instructions;
 
   instructions += EnterScope(node);
   List<Statement>& statements = node->statements();
   for (intptr_t i = 0; (i < statements.length()) && instructions.is_open();
        ++i) {
     instructions += TranslateStatement(statements[i]);
   }
   instructions += ExitScope(node);
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitReturnStatement(ReturnStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   bool inside_try_finally = try_finally_block_ != NULL;
 
   Fragment instructions = node->expression() == NULL
                               ? NullConstant()
                               : TranslateExpression(node->expression());
   if (instructions.is_open()) {
     if (inside_try_finally) {
       ASSERT(scopes_->finally_return_variable != NULL);
       const Function& function = parsed_function_->function();
       if (NeedsDebugStepCheck(function, node->position())) {
@@ skipping 11 matching lines @@
       instructions += Return(node->position());
     }
   } else {
     Pop();
   }
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitExpressionStatement(ExpressionStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateExpression(node->expression());
   instructions += Drop();
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitVariableDeclaration(VariableDeclaration* node) {
   LocalVariable* variable = LookupVariable(node);
   Expression* initializer = node->initializer();
 
@@ skipping 28 matching lines @@
   Fragment instructions = DebugStepCheck(node->position());
   instructions += TranslateFunctionNode(node->function(), node);
   instructions +=
       StoreLocal(node->position(), LookupVariable(node->variable()));
   instructions += Drop();
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitIfStatement(IfStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   bool negate;
   Fragment instructions = TranslateCondition(node->condition(), &negate);
   TargetEntryInstr* then_entry;
   TargetEntryInstr* otherwise_entry;
   instructions += BranchIfTrue(&then_entry, &otherwise_entry, negate);
 
   Fragment then_fragment(then_entry);
   then_fragment += TranslateStatement(node->then());
 
   Fragment otherwise_fragment(otherwise_entry);
@@ skipping 10 matching lines @@
     }
   } else if (otherwise_fragment.is_open()) {
     fragment_ = Fragment(instructions.entry, otherwise_fragment.current);
   } else {
     fragment_ = instructions.closed();
   }
 }
 
 
 void FlowGraphBuilder::VisitWhileStatement(WhileStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   ++loop_depth_;
   bool negate;
   Fragment condition = TranslateCondition(node->condition(), &negate);
   TargetEntryInstr* body_entry;
   TargetEntryInstr* loop_exit;
   condition += BranchIfTrue(&body_entry, &loop_exit, negate);
 
   Fragment body(body_entry);
   body += TranslateStatement(node->body());
 
@@ skipping 10 matching lines @@
     entry = condition.entry;
   }
 
 
   fragment_ = Fragment(entry, loop_exit);
   --loop_depth_;
 }
 
 
 void FlowGraphBuilder::VisitDoStatement(DoStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   ++loop_depth_;
   Fragment body = TranslateStatement(node->body());
 
   if (body.is_closed()) {
     fragment_ = body;
     --loop_depth_;
     return;
   }
 
   bool negate;
   JoinEntryInstr* join = BuildJoinEntry();
   Fragment loop(join);
   loop += CheckStackOverflow();
   loop += body;
   loop += TranslateCondition(node->condition(), &negate);
   TargetEntryInstr* loop_repeat;
   TargetEntryInstr* loop_exit;
   loop += BranchIfTrue(&loop_repeat, &loop_exit, negate);
 
   Fragment repeat(loop_repeat);
   repeat += Goto(join);
 
   fragment_ = Fragment(new (Z) GotoInstr(join), loop_exit);
   --loop_depth_;
 }
 
 
 void FlowGraphBuilder::VisitForStatement(ForStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   Fragment declarations;
 
   bool new_context = false;
   declarations += EnterScope(node, &new_context);
 
   List<VariableDeclaration>& variables = node->variables();
   for (intptr_t i = 0; i < variables.length(); ++i) {
     declarations += TranslateStatement(variables[i]);
   }
 
@@ skipping 36 matching lines @@
   Fragment loop(declarations.entry, loop_exit);
   --loop_depth_;
 
   loop += ExitScope(node);
 
   fragment_ = loop;
 }
 
 
 void FlowGraphBuilder::VisitForInStatement(ForInStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   Fragment instructions = TranslateExpression(node->iterable());
   instructions += PushArgument();
 
   const dart::String& iterator_getter = dart::String::ZoneHandle(
       Z, dart::Field::GetterSymbol(Symbols::Iterator()));
   instructions += InstanceCall(node->iterable()->position(), iterator_getter,
                                Token::kGET, 1);
   LocalVariable* iterator = scopes_->iterator_variables[for_in_depth_];
   instructions += StoreLocal(TokenPosition::kNoSource, iterator);
   instructions += Drop();
@@ skipping 33 matching lines @@
     instructions += condition;
   }
 
   fragment_ = Fragment(instructions.entry, loop_exit);
   --loop_depth_;
   --for_in_depth_;
 }
 
 
 void FlowGraphBuilder::VisitLabeledStatement(LabeledStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   // There can be serveral cases:
   //
   //   * the body contains a break
   //   * the body doesn't contain a break
   //
   //   * translating the body results in a closed fragment
   //   * translating the body results in a open fragment
   //
   // => We will only know which case we are in after the body has been
   //    traversed.
 
-  BreakableBlock block(this, node);
+  BreakableBlock block(this);
   Fragment instructions = TranslateStatement(node->body());
   if (block.HadJumper()) {
     if (instructions.is_open()) {
       instructions += Goto(block.destination());
     }
     fragment_ = Fragment(instructions.entry, block.destination());
   } else {
     fragment_ = instructions;
   }
 }
 
 
 void FlowGraphBuilder::VisitBreakStatement(BreakStatement* node) {
-  TryFinallyBlock* outer_finally = NULL;
-  intptr_t target_context_depth = -1;
-  JoinEntryInstr* destination = breakable_block_->BreakDestination(
-      node->target(), &outer_finally, &target_context_depth);
-
-  Fragment instructions;
-  instructions +=
-      TranslateFinallyFinalizers(outer_finally, target_context_depth);
-  if (instructions.is_open()) {
-    if (NeedsDebugStepCheck(parsed_function_->function(), node->position())) {
-      instructions += DebugStepCheck(node->position());
-    }
-    instructions += Goto(destination);
-  }
-  fragment_ = instructions;
+  fragment_ =
+      streaming_flow_graph_builder_->BuildStatementAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitSwitchStatement(SwitchStatement* node) {
-  SwitchBlock block(this, node);
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
+  SwitchBlock block(this, node->cases().length());
 
   // Instead of using a variable we should reuse the expression on the stack,
   // since it won't be assigned again, we don't need phi nodes.
   Fragment head_instructions = TranslateExpression(node->condition());
   head_instructions +=
       StoreLocal(TokenPosition::kNoSource, scopes_->switch_variable);
   head_instructions += Drop();
 
   // Phase 1: Generate bodies and try to find out whether a body will be target
   // of a jump due to:
@@ skipping 57 matching lines @@
     //    switch(expr) {
     //      case a:
     //      case b:
     //        <stmt-body>
     //    }
     //
     // This means that the <stmt-body> will have more than 1 incoming edge (one
     // from `a == expr` and one from `a != expr && b == expr`). The
     // `block.Destination()` records the additional jump.
     if (switch_case->expressions().length() > 1) {
-      block.Destination(switch_case);
+      block.DestinationDirect(i);
     }
   }
 
   // Phase 2: Generate everything except the real bodies:
   //   * jump directly to a body (if there is no jumper)
   //   * jump to a wrapper block which jumps to the body (if there is a jumper)
   Fragment current_instructions = head_instructions;
   for (intptr_t i = 0; i < num_cases; i++) {
     SwitchCase* switch_case = node->cases()[i];
 
     if (switch_case->is_default()) {
       ASSERT(i == (node->cases().length() - 1));
 
       // Evaluate the conditions for the default [SwitchCase] just for the
       // purpose of potentially triggering a compile-time error.
       for (intptr_t k = 0; k < switch_case->expressions().length(); k++) {
         constant_evaluator_.EvaluateExpression(switch_case->expressions()[k]);
       }
 
-      if (block.HadJumper(switch_case)) {
+      if (block.HadJumper(i)) {
         // There are several branches to the body, so we will make a goto to
         // the join block (and prepend a join instruction to the real body).
-        JoinEntryInstr* join = block.Destination(switch_case);
+        JoinEntryInstr* join = block.DestinationDirect(i);
         current_instructions += Goto(join);
 
         current_instructions = Fragment(current_instructions.entry, join);
         current_instructions += body_fragments[i];
       } else {
         current_instructions += body_fragments[i];
       }
     } else {
       JoinEntryInstr* body_join = NULL;
-      if (block.HadJumper(switch_case)) {
-        body_join = block.Destination(switch_case);
+      if (block.HadJumper(i)) {
+        body_join = block.DestinationDirect(i);
         body_fragments[i] = Fragment(body_join) + body_fragments[i];
       }
 
       for (intptr_t j = 0; j < switch_case->expressions().length(); j++) {
         TargetEntryInstr* then;
         TargetEntryInstr* otherwise;
 
         Expression* expression = switch_case->expressions()[j];
         current_instructions +=
             Constant(constant_evaluator_.EvaluateExpression(expression));
@@ skipping 51 matching lines @@
   }
 
   delete[] body_fragments;
 
   fragment_ = Fragment(head_instructions.entry, current_instructions.current);
 }
 
 
 void FlowGraphBuilder::VisitContinueSwitchStatement(
     ContinueSwitchStatement* node) {
-  TryFinallyBlock* outer_finally = NULL;
-  intptr_t target_context_depth = -1;
-  JoinEntryInstr* entry = switch_block_->Destination(
-      node->target(), &outer_finally, &target_context_depth);
-
-  Fragment instructions;
-  instructions +=
-      TranslateFinallyFinalizers(outer_finally, target_context_depth);
-  if (instructions.is_open()) {
-    instructions += Goto(entry);
-  }
-  fragment_ = instructions;
+  fragment_ =
+      streaming_flow_graph_builder_->BuildStatementAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitAssertStatement(AssertStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   if (!I->asserts()) {
     fragment_ = Fragment();
     return;
   }
 
   TargetEntryInstr* then;
   TargetEntryInstr* otherwise;
 
   Fragment instructions;
   // Asserts can be of the following two kinds:
@@ skipping 55 matching lines @@
   // Throw _AssertionError exception.
   otherwise_fragment += PushArgument();
   otherwise_fragment += ThrowException(TokenPosition::kNoSource);
   otherwise_fragment += Drop();
 
   fragment_ = Fragment(instructions.entry, then);
 }
 
 
 void FlowGraphBuilder::VisitTryFinally(TryFinally* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   InlineBailout("kernel::FlowgraphBuilder::VisitTryFinally");
 
   // There are 5 different cases where we need to execute the finally block:
   //
   //  a) 1/2/3th case: Special control flow going out of `node->body()`:
   //
   //   * [BreakStatement] transfers control to a [LabledStatement]
   //   * [ContinueSwitchStatement] transfers control to a [SwitchCase]
   //   * [ReturnStatement] returns a value
   //
@@ skipping 11 matching lines @@
   //
   //   => We are responsible for catching it, executing the finally block and
   //      rethrowing the exception.
   intptr_t try_handler_index = AllocateTryIndex();
   Fragment try_body = TryCatch(try_handler_index);
   JoinEntryInstr* after_try = BuildJoinEntry();
 
   // Fill in the body of the try.
   ++try_depth_;
   {
-    TryFinallyBlock tfb(this, node->finalizer());
+    TryFinallyBlock tfb(this, node->finalizer(), -1);
     TryCatchBlock tcb(this, try_handler_index);
     try_body += TranslateStatement(node->body());
   }
   --try_depth_;
 
   if (try_body.is_open()) {
     // Please note: The try index will be on level out of this block,
     // thereby ensuring if there's an exception in the finally block we
     // won't run it twice.
     JoinEntryInstr* finally_entry = BuildJoinEntry();
@@ skipping 22 matching lines @@
         RethrowException(TokenPosition::kNoSource, try_handler_index);
     Drop();
   }
   --catch_depth_;
 
   fragment_ = Fragment(try_body.entry, after_try);
 }
 
 
 void FlowGraphBuilder::VisitTryCatch(class TryCatch* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   InlineBailout("kernel::FlowgraphBuilder::VisitTryCatch");
 
   intptr_t try_handler_index = AllocateTryIndex();
   Fragment try_body = TryCatch(try_handler_index);
   JoinEntryInstr* after_try = BuildJoinEntry();
 
   // Fill in the body of the try.
   ++try_depth_;
   {
     TryCatchBlock block(this, try_handler_index);
@@ skipping 99 matching lines @@
     catch_body += RethrowException(TokenPosition::kNoSource, try_handler_index);
     Drop();
   }
   --catch_depth_;
 
   fragment_ = Fragment(try_body.entry, after_try);
 }
 
 
 void FlowGraphBuilder::VisitYieldStatement(YieldStatement* node) {
+  STREAM_STATEMENT_IF_POSSIBLE(node);
+
   ASSERT(node->is_native());  // Must have been desugared.
   // Setup yield/continue point:
   //
   //   ...
   //   :await_jump_var = index;
   //   :await_ctx_var = :current_context_var
   //   return <expr>
   //
   // Continuation<index>:
   //   Drop(1)
@@ skipping 292 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)