Fix try-catch and continue in switch statements.

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"
@@ skipping 71 matching lines @@
   virtual intptr_t ContextLevel() const;
 
   virtual JoinEntryInstr* BreakTargetFor(SourceLabel* label);
   virtual JoinEntryInstr* ContinueTargetFor(SourceLabel* label);
 
  protected:
   NestedStatement(FlowGraphBuilder* owner, const SourceLabel* label)
       : owner_(owner),
         label_(label),
         outer_(owner->nesting_stack_),
-        break_target_(NULL) {
+        break_target_(NULL),
+        try_index_(owner->try_index()) {
     // Push on the owner's nesting stack.
     owner->nesting_stack_ = this;
   }
 
+  intptr_t try_index() const { return try_index_; }
+
   virtual ~NestedStatement() {
     // Pop from the owner's nesting stack.
     ASSERT(owner_->nesting_stack_ == this);
     owner_->nesting_stack_ = outer_;
   }
 
  private:
   FlowGraphBuilder* owner_;
   const SourceLabel* label_;
   NestedStatement* outer_;
 
   JoinEntryInstr* break_target_;
+  intptr_t try_index_;

[srdjan, 2014/06/02 18:29:31]

const?

[Florian Schneider, 2014/06/03 10:50:18]

Yes, I will add it in my next cl.

 };
 
 
 intptr_t NestedStatement::ContextLevel() const {
   // Context level is determined by the innermost nested statement having one.
   return (outer() == NULL) ? 0 : outer()->ContextLevel();
 }
 
 
 intptr_t FlowGraphBuilder::context_level() const {
@@ skipping 55 matching lines @@
 
  private:
   JoinEntryInstr* continue_target_;
 };
 
 
 JoinEntryInstr* NestedLoop::ContinueTargetFor(SourceLabel* label) {
   if (label != this->label()) return NULL;
   if (continue_target_ == NULL) {
     continue_target_ =
-        new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new JoinEntryInstr(owner()->AllocateBlockId(), try_index());
   }
   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);
@@ skipping 22 matching lines @@
 
 
 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 JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+          new JoinEntryInstr(owner()->AllocateBlockId(), try_index());
     }
     return case_targets_[i];
   }
   return NULL;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(ParsedFunction* parsed_function,
                                    const Array& ic_data_array,
                                    InlineExitCollector* exit_collector,
@@ skipping 3747 matching lines @@
           LanguageError::kBailout,
           Heap::kNew,
           "FlowGraphBuilder Bailout: %s %s",
           String::Handle(I, function.name()).ToCString(),
           reason));
   I->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart