Fix async machinery for finally clauses (issues 22445, 22300).

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 5967 matching lines @@
   // body is the outermost try statement.
   ASSERT(try_blocks_list_ != NULL);
   ASSERT(try_blocks_list_->outer_try_block() == NULL);
   // We only get here when parsing an async generator body.
   ASSERT(innermost_function().IsAsyncGenClosure());
 
   const intptr_t try_end_pos = innermost_function().end_token_pos();
 
   // The try-block (closure body code) has been parsed. We are now
   // generating the code for the catch block.
+  LocalScope* try_scope = current_block_->scope;
   try_blocks_list_->enter_catch();
   OpenBlock();  // Catch handler list.
   OpenBlock();  // Catch block.
 
   // Add the exception and stack trace parameters to the scope.
   const AbstractType& dynamic_type =
       AbstractType::ZoneHandle(Z, Type::DynamicType());
   CatchParamDesc exception_param;
   CatchParamDesc stack_trace_param;
   exception_param.token_pos = Scanner::kNoSourcePos;
   exception_param.type = &dynamic_type;
   exception_param.name = &Symbols::ExceptionParameter();
   stack_trace_param.token_pos = Scanner::kNoSourcePos;
   stack_trace_param.type = &dynamic_type;
   stack_trace_param.name = &Symbols::StackTraceParameter();
 
   AddCatchParamsToScope(
       &exception_param, &stack_trace_param, current_block_->scope);
 
   // Generate code to save the exception object and stack trace
   // in local variables.
-  LocalVariable* context_var = current_block_->scope->LookupVariable(
-      Symbols::SavedTryContextVar(), false);
+  LocalVariable* context_var = try_scope->LocalLookupVariable(
+      Symbols::SavedTryContextVar());
   ASSERT(context_var != NULL);
 
-  LocalVariable* exception_var = current_block_->scope->LookupVariable(
-      Symbols::ExceptionVar(), false);
+  LocalVariable* exception_var = try_scope->LocalLookupVariable(
+      Symbols::ExceptionVar());
   ASSERT(exception_var != NULL);
   if (exception_param.var != NULL) {
     // Generate code to load the exception object (:exception_var) into
     // the exception variable specified in this block.
     current_block_->statements->Add(new(Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         exception_param.var,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
   }
 
   LocalVariable* stack_trace_var =
-      current_block_->scope->LookupVariable(Symbols::StackTraceVar(), false);
+      try_scope->LocalLookupVariable(Symbols::StackTraceVar());
   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)));
   }
-  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,
+  LocalVariable* saved_exception_var = try_scope->LocalLookupVariable(

[hausner, 2015/03/03 23:19:11]

Nit: the initializer value for the variable may now fit on one line, so the line
can wrap after the =. Dirro below.

[regis, 2015/03/03 23:47:09]

It does not.

+      Symbols::SavedExceptionVar());
+  LocalVariable* saved_stack_trace_var = try_scope->LocalLookupVariable(
+      Symbols::SavedStackTraceVar());
+  SaveExceptionAndStacktrace(current_block_->statements,
+                             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);
@@ skipping 80 matching lines @@
   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_blocks_list_ != NULL);
   ASSERT(try_blocks_list_->outer_try_block() == NULL);
   ASSERT(innermost_function().IsAsyncClosure());
+  LocalScope* try_scope = current_block_->scope;
 
   try_blocks_list_->enter_catch();
 
   OpenBlock();  // Catch handler list.
   OpenBlock();  // Catch block.
   const AbstractType& dynamic_type =
       AbstractType::ZoneHandle(Z, Type::DynamicType());
   CatchParamDesc exception_param;
   CatchParamDesc stack_trace_param;
   exception_param.token_pos = Scanner::kNoSourcePos;
   exception_param.type = &dynamic_type;
   exception_param.name = &Symbols::ExceptionParameter();
   stack_trace_param.token_pos = Scanner::kNoSourcePos;
   stack_trace_param.type = &dynamic_type;
   stack_trace_param.name = &Symbols::StackTraceParameter();
 
   AddCatchParamsToScope(
       &exception_param, &stack_trace_param, current_block_->scope);
 
-  LocalVariable* context_var = current_block_->scope->LookupVariable(
-      Symbols::SavedTryContextVar(), false);
+  LocalVariable* context_var = try_scope->LocalLookupVariable(

[hausner, 2015/03/03 23:19:11]

Nit: line break after =

[regis, 2015/03/03 23:47:09]

ditto

+      Symbols::SavedTryContextVar());
   ASSERT(context_var != NULL);
 
-  LocalVariable* exception_var = current_block_->scope->LookupVariable(
-      Symbols::ExceptionVar(), false);
+  LocalVariable* exception_var = try_scope->LocalLookupVariable(
+      Symbols::ExceptionVar());
   if (exception_param.var != NULL) {
     // Generate code to load the exception object (:exception_var) into
     // the exception variable specified in this block.
     ASSERT(exception_var != NULL);
     current_block_->statements->Add(new(Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         exception_param.var,
         new(Z) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
   }
 
   LocalVariable* stack_trace_var =
-      current_block_->scope->LookupVariable(Symbols::StackTraceVar(), false);
+      try_scope->LocalLookupVariable(Symbols::StackTraceVar());
   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)));
   }
-  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,
+  LocalVariable* saved_exception_var = try_scope->LocalLookupVariable(
+      Symbols::SavedExceptionVar());
+  LocalVariable* saved_stack_trace_var = try_scope->LocalLookupVariable(
+      Symbols::SavedStackTraceVar());
+  SaveExceptionAndStacktrace(current_block_->statements,
+                             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 =
@@ skipping 39 matching lines @@
       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.
+// Wrap the body of the async or async* 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(),
-        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(),
-        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(),
-        dynamic_type);
-    current_block_->scope->AddVariable(stack_trace_var);
-  }
-  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);
-  }
+  LocalVariable* context_var = NULL;
+  LocalVariable* exception_var = NULL;
+  LocalVariable* stack_trace_var = NULL;
+  LocalVariable* saved_exception_var = NULL;
+  LocalVariable* saved_stack_trace_var = NULL;
+  SetupExceptionVariables(current_block_->scope,
+                          true,
+                          &context_var,
+                          &exception_var,
+                          &stack_trace_var,
+                          &saved_exception_var,
+                          &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 2368 matching lines @@
     }
     stack_trace_param->var = 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,
+void Parser::SaveExceptionAndStacktrace(SequenceNode* statements,
+                                        LocalVariable* exception_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());
 
   ASSERT(saved_exception_var != NULL);
   ASSERT(exception_var != NULL);
-  current_block_->statements->Add(new(Z) StoreLocalNode(
+  statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       saved_exception_var,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
 
   ASSERT(saved_stack_trace_var != NULL);
   ASSERT(stack_trace_var != NULL);
-  current_block_->statements->Add(new(Z) StoreLocalNode(
+  statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       saved_stack_trace_var,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
 }
 
 
-SequenceNode* Parser::ParseFinallyBlock() {
+SequenceNode* Parser::ParseFinallyBlock(
+    bool is_async,
+    LocalVariable* exception_var,
+    LocalVariable* stack_trace_var,
+    LocalVariable* rethrow_exception_var,
+    LocalVariable* rethrow_stack_trace_var) {
   TRACE_PARSER("ParseFinallyBlock");
   OpenBlock();
   ExpectToken(Token::kLBRACE);
 
   // In case of async closures we need to restore the saved try index of an
   // outer try block (if it exists).  The current try block has already been
   // removed from the stack of try blocks.
-  if ((innermost_function().IsAsyncClosure() ||
-       innermost_function().IsAsyncFunction() ||
-       innermost_function().IsSyncGenClosure() ||
-       innermost_function().IsSyncGenerator() ||
-       innermost_function().IsAsyncGenerator() ||
-       innermost_function().IsAsyncGenClosure()) &&
-      (try_blocks_list_ != NULL)) {
+  if (is_async && (try_blocks_list_ != NULL)) {
     LocalScope* scope = try_blocks_list_->try_block()->scope;
     if (scope->function_level() == current_block_->scope->function_level()) {
       current_block_->statements->Add(
           AwaitTransformer::RestoreSavedTryContext(
               Z, scope->parent(), try_blocks_list_->try_index()));
     }
+    SaveExceptionAndStacktrace(current_block_->statements,

[hausner, 2015/03/03 23:19:11]

Strictly speaking, this is only necessary if the finally block contains an await
or yield statement that suspends execution of the function. Correct? If so, it
might be worth adding a comment that we might want to "optimize" this at some
time in the future.

[regis, 2015/03/03 23:47:09]

Yes, I added a comment and a TODO(hausner) :-)

I also fixed a potential bug:
The call to RestoreSavedTryContext is only done if there is an outer try block,
but the saving of the exception variables is unconditional (even without an
outer try).

+                               exception_var,
+                               stack_trace_var,
+                               rethrow_exception_var,
+                               rethrow_stack_trace_var);
   }
 
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* finally_block = CloseBlock();
   return finally_block;
 }
 
 
 void Parser::PushTryBlock(Block* try_block) {
@@ skipping 48 matching lines @@
     return;
   }
   JumpNode* jump_node = node->AsJumpNode();
   ASSERT(jump_node != NULL);
   jump_node->AddInlinedFinallyNode(finally_node);
 }
 
 
 SequenceNode* Parser::ParseCatchClauses(
     intptr_t handler_pos,
+    bool is_async,
     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
@@ skipping 57 matching lines @@
       ASSERT(stack_trace_var != NULL);
       current_block_->statements->Add(new(Z) StoreLocalNode(
           catch_pos, stack_trace_param.var, new(Z) LoadLocalNode(
               catch_pos, stack_trace_var)));
     }
 
     // Add nested block with user-defined code.  This block allows
     // declarations in the body to shadow the catch parameters.
     CheckToken(Token::kLBRACE);
 
-    // In case of async closures we need to restore the saved try index of an
-    // outer try block (if it exists).
-    ASSERT(try_blocks_list_ != NULL);
-    if (innermost_function().IsAsyncClosure() ||
-        innermost_function().IsAsyncFunction() ||
-        innermost_function().IsSyncGenClosure() ||
-        innermost_function().IsSyncGenerator() ||
-        innermost_function().IsAsyncGenerator() ||
-        innermost_function().IsAsyncGenClosure()) {
-      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,
-                                 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.
       // In the first case, unconditionally execute the catch body.  In the
       // second case, unconditionally throw.
@@ skipping 73 matching lines @@
   }
   // If the last body was entered conditionally and there is no need to add
   // a rethrow, use an empty else body (current = NULL above).
   while (!type_tests.is_empty()) {
     AstNode* type_test = type_tests.RemoveLast();
     SequenceNode* catch_block = catch_blocks.RemoveLast();
     current_block_->statements->Add(new(Z) IfNode(
         type_test->token_pos(), type_test, catch_block, current));
     current = CloseBlock();
   }
-  // Restore :saved_try_context_var before executing the catch clauses.
+  // In case of async closures, restore :saved_try_context_var before executing
+  // the catch clauses.
   if (current != NULL) {

[hausner, 2015/03/03 23:19:11]

Can this be simplified to if (is_async && (current != NULL))?

[regis, 2015/03/03 23:47:09]

Done.

     ASSERT(try_blocks_list_ != NULL);
-    if (innermost_function().IsAsyncClosure() ||
-        innermost_function().IsAsyncFunction() ||
-        innermost_function().IsSyncGenClosure() ||
-        innermost_function().IsSyncGenerator() ||
-        innermost_function().IsAsyncGenerator() ||
-        innermost_function().IsAsyncGenClosure()) {
+    if (is_async) {
+      SequenceNode* async_code = new(Z) SequenceNode(handler_pos, NULL);
       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()) {
-          SequenceNode* restore_code = new(Z) SequenceNode(handler_pos, NULL);
-          restore_code->Add(
+          async_code->Add(
               AwaitTransformer::RestoreSavedTryContext(
                   Z, scope->parent(), try_block->try_index()));
-          restore_code->Add(current);
-          current = restore_code;
         }
       }
+      SaveExceptionAndStacktrace(async_code,

[Ivan Posva, 2015/03/03 22:57:57]

Please add comment what is being saved here and where this code is in relation
to the rest.

[regis, 2015/03/03 23:47:09]

Done.

+                                 exception_var,
+                                 stack_trace_var,
+                                 rethrow_exception_var,
+                                 rethrow_stack_trace_var);
+      async_code->Add(current);
+      current = async_code;
     }
   }
   return current;
 }
 
 
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name = String::ZoneHandle(Z,
       Symbols::New(String::Handle(Z,
           String::NewFormatted("%s%d",
@@ skipping 10 matching lines @@
       async_saved_try_ctx_name, false);
   ASSERT(async_saved_try_ctx != NULL);
   ASSERT(saved_try_context != NULL);
   current_block_->statements->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_saved_try_ctx,
       new(Z) LoadLocalNode(Scanner::kNoSourcePos, saved_try_context)));
 }
 
 
+// We create three variables for exceptions:
+// ':saved_try_context_var' - Used to save the context before the start of
+//                            the try block. The context register is
+//                            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.
+//
+// In case of async code, we create two additional variables:
+// ':saved_exception_var' - Used to capture the exception object above.
+// ':saved_stack_trace_var' - Used to capture the stack trace object above.
+void Parser::SetupExceptionVariables(LocalScope* try_scope,
+                                     bool is_async,
+                                     LocalVariable** context_var,
+                                     LocalVariable** exception_var,
+                                     LocalVariable** stack_trace_var,
+                                     LocalVariable** saved_exception_var,
+                                     LocalVariable** saved_stack_trace_var) {
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
+  // Consecutive try statements share the same set of variables.
+  *context_var = try_scope->LocalLookupVariable(Symbols::SavedTryContextVar());
+  if (*context_var == NULL) {
+    *context_var = new(Z) LocalVariable(
+        TokenPos(),
+        Symbols::SavedTryContextVar(),
+        dynamic_type);
+    try_scope->AddVariable(*context_var);
+  }
+  *exception_var = try_scope->LocalLookupVariable(Symbols::ExceptionVar());
+  if (*exception_var == NULL) {
+    *exception_var = new(Z) LocalVariable(
+        TokenPos(),
+        Symbols::ExceptionVar(),
+        dynamic_type);
+    try_scope->AddVariable(*exception_var);
+  }
+  *stack_trace_var = try_scope->LocalLookupVariable(Symbols::StackTraceVar());
+  if (*stack_trace_var == NULL) {
+    *stack_trace_var = new(Z) LocalVariable(
+        TokenPos(),
+        Symbols::StackTraceVar(),
+        dynamic_type);
+    try_scope->AddVariable(*stack_trace_var);
+  }
+  if (is_async) {
+    *saved_exception_var = try_scope->LocalLookupVariable(
+        Symbols::SavedExceptionVar());
+    if (*saved_exception_var == NULL) {
+      *saved_exception_var = new(Z) LocalVariable(
+          TokenPos(),
+          Symbols::SavedExceptionVar(),
+          dynamic_type);
+      try_scope->AddVariable(*saved_exception_var);
+    }
+    *saved_stack_trace_var = try_scope->LocalLookupVariable(
+        Symbols::SavedStackTraceVar());
+    if (*saved_stack_trace_var == NULL) {
+      *saved_stack_trace_var = new(Z) LocalVariable(
+          TokenPos(),
+          Symbols::SavedStackTraceVar(),
+          dynamic_type);
+      try_scope->AddVariable(*saved_stack_trace_var);
+    }
+  }
+}
+
+
 AstNode* Parser::ParseTryStatement(String* label_name) {
   TRACE_PARSER("ParseTryStatement");
-
-  // We create three variables for exceptions here:
-  // ':saved_try_context_var' - Used to save the context before the start of
-  //                            the try block. The context register is
-  //                            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.
-  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(),
-        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(),
-        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(),
-        dynamic_type);
-    current_block_->scope->AddVariable(stack_trace_var);
-  }
-  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);
-    }
-  }
+  LocalVariable* context_var = NULL;
+  LocalVariable* exception_var = NULL;
+  LocalVariable* stack_trace_var = NULL;
+  LocalVariable* saved_exception_var = NULL;
+  LocalVariable* saved_stack_trace_var = NULL;
+  SetupExceptionVariables(current_block_->scope,
+                          is_async,
+                          &context_var,
+                          &exception_var,
+                          &stack_trace_var,
+                          &saved_exception_var,
+                          &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);
   }
@@ skipping 16 matching lines @@
     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,
+      ParseCatchClauses(handler_pos,
+                        is_async,
+                        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);
+                        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.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
     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 =
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
-      finally_block = ParseFinallyBlock();
+      finally_block = ParseFinallyBlock(
+          is_async,
+          exception_var,
+          stack_trace_var,
+          is_async ? saved_exception_var : exception_var,
+          is_async ? saved_stack_trace_var : stack_trace_var);
       InlinedFinallyNode* node = new(Z) InlinedFinallyNode(finally_pos,
                                                            finally_block,
                                                            context_var,
                                                            outer_try_index);
       AddFinallyBlockToNode(node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
-    finally_block = ParseFinallyBlock();
+    finally_block = ParseFinallyBlock(
+        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,
@@ skipping 332 matching lines @@
     // instead of :exception_var and :stack_trace_var.
     // These variables are bound in the block containing the try.
     // Look in the try scope directly.
     LocalScope* scope = try_blocks_list_->try_block()->scope->parent();
     ASSERT(scope != NULL);
     LocalVariable* excp_var;
     LocalVariable* trace_var;
     if (innermost_function().IsAsyncClosure() ||
         innermost_function().IsAsyncFunction() ||
         innermost_function().IsSyncGenClosure() ||
         innermost_function().IsSyncGenerator()) {

[regis, 2015/03/03 23:47:09]

Matthias, is the list above correct?

[regis, 2015/03/03 23:54:45]

OK, I'm submitting, but we should verify all the locations where we check
against a list of innermost functions.

[hausner, 2015/03/03 23:59:40]

Good catch. It seems that we also need to include async* functions and closures,
so the if should be

if (innermost_function().IsAsyncClosure() ||
       innermost_function().IsAsyncFunction() ||
       innermost_function().IsSyncGenClosure() ||
       innermost_function().IsSyncGenerator() ||
       innermost_function().IsAsyncGenerator() ||
       innermost_function().IsAsyncGenClosure()) {

       excp_var = scope->LocalLookupVariable(Symbols::SavedExceptionVar());
       trace_var = scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
     } else {
       excp_var = scope->LocalLookupVariable(Symbols::ExceptionVar());
       trace_var = scope->LocalLookupVariable(Symbols::StackTraceVar());
     }
     ASSERT(excp_var != NULL);
     ASSERT(trace_var != NULL);
 
     statement = new(Z) ThrowNode(
@@ skipping 3636 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart