Fix VM bug with try-catch inside of try-finally.

runtime/vm/parser.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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED
 
 #include "lib/invocation_mirror.h"
@@ skipping 6447 matching lines @@
       true);
 
   const intptr_t try_index = try_statement->try_index();
 
   AstNode* try_catch_node =
       new(Z) TryCatchNode(Scanner::kNoSourcePos,
                           body,
                           context_var,
                           catch_clause,
                           finally_clause,
-                          try_index);
+                          try_index,
+                          finally_clause);
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::CloseAsyncTryBlock(SequenceNode* try_block) {
   // This is the outermost try-catch of the function.
   ASSERT(try_stack_ != NULL);
   ASSERT(try_stack_->outer_try() == NULL);
   ASSERT(innermost_function().IsAsyncClosure());
@@ skipping 95 matching lines @@
       saved_exception_var,
       saved_stack_trace_var,
       CatchClauseNode::kInvalidTryIndex,
       true);
   AstNode* try_catch_node = new (Z) TryCatchNode(
       Scanner::kNoSourcePos,
       try_block,
       context_var,
       catch_clause,
       NULL,  // No finally clause.
-      try_index);
+      try_index,
+      NULL);  // No rethrow-finally clause.
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
 
 // Wrap the body of the async or async* closure in a try/catch block.
 void Parser::OpenAsyncTryBlock() {
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncGenClosure());
   LocalVariable* context_var = NULL;
@@ skipping 2334 matching lines @@
       stack_trace_var,
       AllocateTryIndex(),
       true);  // Needs stack trace.
 
   AstNode* try_catch_node =
       new(Z) TryCatchNode(await_for_pos,
                          try_block,
                          context_var,
                          catch_clause,
                          finally_clause,
-                         try_index);
+                         try_index,
+                         finally_clause);
 
   ASSERT(current_block_ == loop_block);
   loop_block->statements->Add(try_catch_node);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
@@ skipping 805 matching lines @@
   const intptr_t try_index = try_statement->try_index();
   TryStack* outer_try = try_stack_;
   const intptr_t outer_try_index = (outer_try != NULL) ?
       outer_try->try_index() : CatchClauseNode::kInvalidTryIndex;
 
   // Finally, parse or generate the 'finally' clause.
   // A finally clause is required in async code to restore the saved try context
   // of an existing outer try. Generate a finally clause to this purpose if it
   // is not declared.
   SequenceNode* finally_clause = NULL;
+  SequenceNode* rethrow_clause = NULL;
   const bool parse = CurrentToken() == Token::kFINALLY;
   if (parse || (is_async && (try_stack_ != NULL))) {
     if (parse) {
       ConsumeToken();  // Consume the 'finally'.
     }
     const intptr_t finally_pos = TokenPos();
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline = try_statement->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
@@ skipping 13 matching lines @@
       node_to_inline = try_statement->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_clause = EnsureFinallyClause(
         parse,
         is_async,
         exception_var,
         stack_trace_var,
         is_async ? saved_exception_var : exception_var,
         is_async ? saved_stack_trace_var : stack_trace_var);
+    if (finally_clause != NULL) {
+      // Re-parse to create a duplicate of finally clause to avoid unintended
+      // sharing of try-indices if the finally-block contains a try-catch.
+      // The flow graph builder emits two copies of the finally-block if the
+      // try-block has a normal exit: one for the exception- and one for the
+      // non-exception case (see EffectGraphVisitor::VisitTryCatchNode)
+      tokens_iterator_.SetCurrentPosition(finally_pos);
+      rethrow_clause = EnsureFinallyClause(
+          parse,
+          is_async,
+          exception_var,
+          stack_trace_var,
+          is_async ? saved_exception_var : exception_var,
+          is_async ? saved_stack_trace_var : stack_trace_var);
+    }
   }
 
   CatchClauseNode* catch_clause = new(Z) CatchClauseNode(
       handler_pos,
       catch_handler_list,
       Array::ZoneHandle(Z, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
       is_async ? saved_exception_var : exception_var,
       is_async ? saved_stack_trace_var : stack_trace_var,
       (finally_clause != NULL) ?
           AllocateTryIndex() : CatchClauseNode::kInvalidTryIndex,
       needs_stack_trace);
 
   // Now create the try/catch ast node and return it. If there is a label
   // on the try/catch, close the block that's embedding the try statement
   // and attach the label to it.
   AstNode* try_catch_node = new(Z) TryCatchNode(
-      try_pos, try_block, context_var, catch_clause, finally_clause, try_index);
+      try_pos, try_block, context_var, catch_clause, finally_clause, try_index,
+      rethrow_clause);
 
   if (try_label != NULL) {
     current_block_->statements->Add(try_catch_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(try_label);
     try_catch_node = sequence;
   }
 
   return try_catch_node;
 }
@@ skipping 4680 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED