One more fix to async machinery (rethrow in finally, issue 22595).

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 6016 matching lines @@
   ASSERT(stack_trace_var != NULL);
   if (stack_trace_param.var != NULL) {
     // A stack trace variable is specified in this block, so generate code
     // to load the stack trace object (:stack_trace_var) into the stack
     // trace variable specified in this block.
     current_block_->statements->Add(new(Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         stack_trace_param.var,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
   }
-
-  SaveExceptionAndStacktrace(exception_var, stack_trace_var);
+  LocalVariable* saved_exception_var = current_block_->scope->LookupVariable(
+      Symbols::SavedExceptionVar(), false);
+  LocalVariable* saved_stack_trace_var = current_block_->scope->LookupVariable(
+      Symbols::SavedStackTraceVar(), false);
+  SaveExceptionAndStacktrace(exception_var,
+                             stack_trace_var,
+                             saved_exception_var,
+                             saved_stack_trace_var);
 
   // Catch block: add the error to the stream.
   // :controller.AddError(:exception, :stack_trace);
   // return;  // The finally block will close the stream.
   LocalVariable* controller =
       current_block_->scope->LookupVariable(Symbols::Controller(), false);
   ASSERT(controller != NULL);
   ArgumentListNode* args =
       new(Z) ArgumentListNode(Scanner::kNoSourcePos);
   args->Add(new(Z) LoadLocalNode(Scanner::kNoSourcePos, exception_param.var));
@@ skipping 53 matching lines @@
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   handler_types.Add(dynamic_type);  // Catch block handles all exceptions.
 
   CatchClauseNode* catch_clause = new(Z) CatchClauseNode(
       Scanner::kNoSourcePos,
       catch_handler_list,
       Array::ZoneHandle(Z, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
+      saved_exception_var,
+      saved_stack_trace_var,
       AllocateTryIndex(),
       true);
 
   const intptr_t try_index = try_block->try_index();
 
   AstNode* try_catch_node =
       new(Z) TryCatchNode(Scanner::kNoSourcePos,
                           body,
                           context_var,
                           catch_clause,
@@ skipping 49 matching lines @@
   if (stack_trace_param.var != NULL) {
     // A stack trace variable is specified in this block, so generate code
     // to load the stack trace object (:stack_trace_var) into the stack
     // trace variable specified in this block.
     ASSERT(stack_trace_var != NULL);
     current_block_->statements->Add(new(Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         stack_trace_param.var,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
   }
-
-  SaveExceptionAndStacktrace(exception_var, stack_trace_var);
+  LocalVariable* saved_exception_var = current_block_->scope->LookupVariable(
+      Symbols::SavedExceptionVar(), false);
+  LocalVariable* saved_stack_trace_var = current_block_->scope->LookupVariable(
+      Symbols::SavedStackTraceVar(), false);
+  SaveExceptionAndStacktrace(exception_var,
+                             stack_trace_var,
+                             saved_exception_var,
+                             saved_stack_trace_var);
 
   // Complete the async future with an error. This catch block executes
   // unconditionally, there is no need to generate a type check for.
   LocalVariable* async_completer = current_block_->scope->LookupVariable(
       Symbols::AsyncCompleter(), false);
   ASSERT(async_completer != NULL);
   ArgumentListNode* completer_args =
       new (Z) ArgumentListNode(Scanner::kNoSourcePos);
   completer_args->Add(
       new (Z) LoadLocalNode(Scanner::kNoSourcePos, exception_param.var));
@@ skipping 20 matching lines @@
   TryBlocks* inner_try_block = PopTryBlock();
   const intptr_t try_index = inner_try_block->try_index();
 
   CatchClauseNode* catch_clause = new (Z) CatchClauseNode(
       Scanner::kNoSourcePos,
       catch_handler_list,
       Array::ZoneHandle(Z, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
+      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);
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
 
 // Wrap the body of the async or arync* closure in a try/catch block.
 void Parser::OpenAsyncTryBlock() {
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncGenClosure());
 
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
     context_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::SavedTryContextVar(),
-        Type::ZoneHandle(Z, Type::DynamicType()));
+        dynamic_type);
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* exception_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (exception_var == NULL) {
     exception_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::ExceptionVar(),
-        Type::ZoneHandle(Z, Type::DynamicType()));
+        dynamic_type);
     current_block_->scope->AddVariable(exception_var);
   }
   LocalVariable* stack_trace_var =
       current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (stack_trace_var == NULL) {
     stack_trace_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::StackTraceVar(),
-        Type::ZoneHandle(Z, Type::DynamicType()));
+        dynamic_type);
     current_block_->scope->AddVariable(stack_trace_var);
   }
-
-  SetupSavedExceptionAndStacktrace();
+  LocalVariable* saved_exception_var =
+      current_block_->scope->LocalLookupVariable(Symbols::SavedExceptionVar());
+  if (saved_exception_var == NULL) {
+    saved_exception_var = new(Z) LocalVariable(
+        TokenPos(),
+        Symbols::SavedExceptionVar(),
+        dynamic_type);
+    current_block_->scope->AddVariable(saved_exception_var);
+  }
+  LocalVariable* saved_stack_trace_var =
+      current_block_->scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
+  if (saved_stack_trace_var == NULL) {
+    saved_stack_trace_var = new(Z) LocalVariable(
+        TokenPos(),
+        Symbols::SavedStackTraceVar(),
+        dynamic_type);
+    current_block_->scope->AddVariable(saved_stack_trace_var);
+  }
 
   // Open the try block.
   OpenBlock();
   // This is the outermost try-catch in the function.
   ASSERT(try_blocks_list_ == NULL);
   PushTryBlock(current_block_);
 
   SetupSavedTryContext(context_var);
 }
 
@@ skipping 2364 matching lines @@
       // The name of the exception param is reused for the stack trace param.
       ReportError(stack_trace_param->token_pos,
                   "name '%s' already exists in scope",
                   stack_trace_param->name->ToCString());
     }
     stack_trace_param->var = var;
   }
 }
 
 
-// Populate current scope of the try block with the saved exception and saved
-// stack trace.
-void Parser::SetupSavedExceptionAndStacktrace() {
-  ASSERT(innermost_function().IsAsyncClosure() ||
-         innermost_function().IsAsyncFunction() ||
-         innermost_function().IsSyncGenClosure() ||
-         innermost_function().IsSyncGenerator() ||
-         innermost_function().IsAsyncGenerator() ||
-         innermost_function().IsAsyncGenClosure());
-  // Add :saved_exception_var and :saved_stack_trace_var to current scope.
-  // They will automatically get captured.
-  // Parallel try statements share the same set of variables.
-  LocalVariable* saved_exception_var =
-      current_block_->scope->LocalLookupVariable(Symbols::SavedExceptionVar());
-  if (saved_exception_var == NULL) {
-    saved_exception_var = new (Z) LocalVariable(
-        Scanner::kNoSourcePos,
-        Symbols::SavedExceptionVar(),
-        Type::ZoneHandle(Z, Type::DynamicType()));
-    saved_exception_var->set_is_final();
-    current_block_->scope->AddVariable(saved_exception_var);
-  }
-  LocalVariable* saved_stack_trace_var =
-      current_block_->scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
-  if (saved_stack_trace_var == NULL) {
-    saved_stack_trace_var = new (Z) LocalVariable(
-      Scanner::kNoSourcePos,
-      Symbols::SavedStackTraceVar(),
-      Type::ZoneHandle(Z, Type::DynamicType()));
-    saved_exception_var->set_is_final();
-    current_block_->scope->AddVariable(saved_stack_trace_var);
-  }
-}
-
-
 // Generate code to load the exception object (:exception_var) into
 // the saved exception variable (:saved_exception_var) used to rethrow.
+// Generate code to load the stack trace object (:stack_trace_var) into
+// the saved stacktrace variable (:saved_stack_trace_var) used to rethrow.
 void Parser::SaveExceptionAndStacktrace(LocalVariable* exception_var,
-                                        LocalVariable* stack_trace_var) {
+                                        LocalVariable* stack_trace_var,
+                                        LocalVariable* saved_exception_var,
+                                        LocalVariable* saved_stack_trace_var) {
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator() ||
          innermost_function().IsAsyncGenClosure() ||
          innermost_function().IsAsyncGenerator());
-  LocalVariable* saved_exception_var = current_block_->scope->LookupVariable(
-      Symbols::SavedExceptionVar(), false);
+
   ASSERT(saved_exception_var != NULL);
   ASSERT(exception_var != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       saved_exception_var,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
 
-  // Generate code to load the stack trace object (:stack_trace_var) into
-  // the saved stacktrace variable (:saved_stack_trace_var) used to rethrow.
-  LocalVariable* saved_stack_trace_var = current_block_->scope->LookupVariable(
-      Symbols::SavedStackTraceVar(), false);
   ASSERT(saved_stack_trace_var != NULL);
   ASSERT(stack_trace_var != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       saved_stack_trace_var,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
 }
 
 
 SequenceNode* Parser::ParseFinallyBlock() {
@@ skipping 80 matching lines @@
   JumpNode* jump_node = node->AsJumpNode();
   ASSERT(jump_node != NULL);
   jump_node->AddInlinedFinallyNode(finally_node);
 }
 
 
 SequenceNode* Parser::ParseCatchClauses(
     intptr_t handler_pos,
     LocalVariable* exception_var,
     LocalVariable* stack_trace_var,
+    LocalVariable* rethrow_exception_var,
+    LocalVariable* rethrow_stack_trace_var,
     const GrowableObjectArray& handler_types,
     bool* needs_stack_trace) {
   // All catch blocks are merged into an if-then-else sequence of the
   // different types specified using the 'is' operator.  While parsing
   // record the type tests (either a ComparisonNode or else the LiteralNode
   // true for a generic catch) and the catch bodies in a pair of parallel
   // lists.  Afterward, construct the nested if-then-else.
   bool generic_catch_seen = false;
   GrowableArray<AstNode*> type_tests;
   GrowableArray<SequenceNode*> catch_blocks;
@@ skipping 72 matching lines @@
       const TryBlocks* try_block = try_blocks_list_->outer_try_block();
       if (try_block != NULL) {
         LocalScope* scope = try_block->try_block()->scope;
         if (scope->function_level() ==
             current_block_->scope->function_level()) {
           current_block_->statements->Add(
               AwaitTransformer::RestoreSavedTryContext(
                   Z, scope->parent(), try_block->try_index()));
         }
       }
-      SaveExceptionAndStacktrace(exception_var, stack_trace_var);
+      SaveExceptionAndStacktrace(exception_var,
+                                 stack_trace_var,
+                                 rethrow_exception_var,
+                                 rethrow_stack_trace_var);
     }
 
     current_block_->statements->Add(ParseNestedStatement(false, NULL));
     catch_blocks.Add(CloseBlock());
 
     const bool is_bad_type =
         exception_param.type->IsMalformed() ||
         exception_param.type->IsMalbounded();
     if (exception_param.type->IsDynamicType() || is_bad_type) {
       // There is no exception type or else it is malformed or malbounded.
@@ skipping 143 matching lines @@
   //                            restored from this variable before
   //                            processing the catch block handler.
   // ':exception_var' - Used to save the current exception object that was
   //                    thrown.
   // ':stack_trace_var' - Used to save the current stack trace object which
   //                      the stack trace was copied into when an exception
   //                      was thrown.
   // :exception_var and :stack_trace_var get set with the exception object
   // and the stack trace object when an exception is thrown.  These three
   // implicit variables can never be captured.
-  // Parallel try statements share the same set of variables.
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
+  // Consecutive try statements share the same set of variables.
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
     context_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::SavedTryContextVar(),
-        Type::ZoneHandle(Z, Type::DynamicType()));
+        dynamic_type);
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* exception_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (exception_var == NULL) {
     exception_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::ExceptionVar(),
-        Type::ZoneHandle(Z, Type::DynamicType()));
+        dynamic_type);
     current_block_->scope->AddVariable(exception_var);
   }
   LocalVariable* stack_trace_var =
       current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (stack_trace_var == NULL) {
     stack_trace_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::StackTraceVar(),
-        Type::ZoneHandle(Z, Type::DynamicType()));
+        dynamic_type);
     current_block_->scope->AddVariable(stack_trace_var);
   }
-
-  if (innermost_function().IsAsyncClosure() ||
-      innermost_function().IsAsyncFunction() ||
-      innermost_function().IsSyncGenClosure() ||
-      innermost_function().IsSyncGenerator() ||
-      innermost_function().IsAsyncGenClosure() ||
-      innermost_function().IsAsyncGenerator()) {
-    SetupSavedExceptionAndStacktrace();
+  LocalVariable* saved_exception_var = NULL;
+  LocalVariable* saved_stack_trace_var = NULL;
+  const bool is_async = innermost_function().IsAsyncClosure() ||
+                        innermost_function().IsAsyncFunction() ||
+                        innermost_function().IsSyncGenClosure() ||
+                        innermost_function().IsSyncGenerator() ||
+                        innermost_function().IsAsyncGenClosure() ||
+                        innermost_function().IsAsyncGenerator();
+  if (is_async) {
+    saved_exception_var = current_block_->scope->LocalLookupVariable(
+        Symbols::SavedExceptionVar());
+    if (saved_exception_var == NULL) {
+      saved_exception_var = new(Z) LocalVariable(
+          TokenPos(),
+          Symbols::SavedExceptionVar(),
+          dynamic_type);
+      current_block_->scope->AddVariable(saved_exception_var);
+    }
+    saved_stack_trace_var = current_block_->scope->LocalLookupVariable(
+        Symbols::SavedStackTraceVar());
+    if (saved_stack_trace_var == NULL) {
+      saved_stack_trace_var = new(Z) LocalVariable(
+          TokenPos(),
+          Symbols::SavedStackTraceVar(),
+          dynamic_type);
+      current_block_->scope->AddVariable(saved_stack_trace_var);
+    }
   }
 
   const intptr_t try_pos = TokenPos();
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   // Now parse the 'try' block.
   OpenBlock();
   PushTryBlock(current_block_);
   ExpectToken(Token::kLBRACE);
 
-  if (innermost_function().IsAsyncClosure() ||
-      innermost_function().IsAsyncFunction() ||
-      innermost_function().IsSyncGenClosure() ||
-      innermost_function().IsSyncGenerator() ||
-      innermost_function().IsAsyncGenerator() ||
-      innermost_function().IsAsyncGenClosure()) {
+  if (is_async) {
     SetupSavedTryContext(context_var);
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
       (CurrentToken() != Token::kFINALLY)) {
     ReportError("catch or finally clause expected");
   }
 
   // Now parse the 'catch' blocks if any.
   try_blocks_list_->enter_catch();
   const intptr_t handler_pos = TokenPos();
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   bool needs_stack_trace = false;
   SequenceNode* catch_handler_list =
       ParseCatchClauses(handler_pos, exception_var, stack_trace_var,
+                        is_async ? saved_exception_var : exception_var,
+                        is_async ? saved_stack_trace_var : stack_trace_var,
                         handler_types, &needs_stack_trace);
 
   TryBlocks* inner_try_block = PopTryBlock();
   const intptr_t try_index = inner_try_block->try_index();
   TryBlocks* outer_try_block = try_blocks_list_;
   const intptr_t outer_try_index = (outer_try_block != NULL)
       ? outer_try_block->try_index()
       : CatchClauseNode::kInvalidTryIndex;
 
   // Finally parse the 'finally' block.
@@ skipping 19 matching lines @@
     finally_block = ParseFinallyBlock();
   }
 
   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_block != 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_block, try_index);
 
@@ skipping 3978 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart