Fix more async machinery (issue 22579 and possibly more to be triaged).

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 261 matching lines @@
   }
   Block* parent;  // Enclosing block, or NULL if outermost.
   LocalScope* scope;
   SequenceNode* statements;
 };
 
 
 // Class which describes an inlined finally block which is used to generate
 // inlined code for the finally blocks when there is an exit from a try
 // block using 'return', 'break' or 'continue'.
-class Parser::TryBlocks : public ZoneAllocated {
+class Parser::TryStack : public ZoneAllocated {
  public:
-  TryBlocks(Block* try_block, TryBlocks* outer_try_block, intptr_t try_index)
+  TryStack(Block* try_block, TryStack* outer_try, intptr_t try_index)
       : try_block_(try_block),
         inlined_finally_nodes_(),
-        outer_try_block_(outer_try_block),
+        outer_try_(outer_try),
         try_index_(try_index),
         inside_catch_(false) { }
 
-  TryBlocks* outer_try_block() const { return outer_try_block_; }
+  TryStack* outer_try() const { return outer_try_; }
   Block* try_block() const { return try_block_; }
   intptr_t try_index() const { return try_index_; }
   bool inside_catch() const { return inside_catch_; }
   void enter_catch() { inside_catch_ = true; }
 
   void AddNodeForFinallyInlining(AstNode* node);
   AstNode* GetNodeToInlineFinally(int index) {
     if (0 <= index && index < inlined_finally_nodes_.length()) {
       return inlined_finally_nodes_[index];
     }
     return NULL;
   }
 
  private:
   Block* try_block_;
   GrowableArray<AstNode*> inlined_finally_nodes_;
-  TryBlocks* outer_try_block_;
+  TryStack* outer_try_;
   const intptr_t try_index_;
   bool inside_catch_;
 
-  DISALLOW_COPY_AND_ASSIGN(TryBlocks);
+  DISALLOW_COPY_AND_ASSIGN(TryStack);
 };
 
 
-void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
+void Parser::TryStack::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script, const Library& library, intptr_t token_pos)
     : thread_(Thread::Current()),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(TokenStream::Handle(zone(), script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
       innermost_function_(Function::Handle(zone())),
       literal_token_(LiteralToken::Handle(zone())),
       current_class_(Class::Handle(zone())),
       library_(Library::Handle(zone(), library.raw())),
-      try_blocks_list_(NULL),
+      try_stack_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false),
       async_temp_scope_(NULL),
       trace_indent_(0) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
@@ skipping 12 matching lines @@
       allow_function_literals_(true),
       parsed_function_(parsed_function),
       innermost_function_(Function::Handle(zone(),
                                            parsed_function->function().raw())),
       literal_token_(LiteralToken::Handle(zone())),
       current_class_(Class::Handle(zone(),
                                    parsed_function->function().Owner())),
       library_(Library::Handle(zone(), Class::Handle(
           zone(),
           parsed_function->function().origin()).library())),
-      try_blocks_list_(NULL),
+      try_stack_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false),
       async_temp_scope_(NULL),
       trace_indent_(0) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   EnsureExpressionTemp();
 }
 
 
@@ skipping 5593 matching lines @@
   async_temp_scope_ = current_block_->scope;
 
   OpenAsyncTryBlock();
 }
 
 
 SequenceNode* Parser::CloseAsyncGeneratorTryBlock(SequenceNode *body) {
   TRACE_PARSER("CloseAsyncGeneratorTryBlock");
   // The generated try-catch-finally that wraps the async generator function
   // body is the outermost try statement.
-  ASSERT(try_blocks_list_ != NULL);
-  ASSERT(try_blocks_list_->outer_try_block() == NULL);
+  ASSERT(try_stack_ != NULL);
+  ASSERT(try_stack_->outer_try() == 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();
+  try_stack_->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;
@@ skipping 60 matching lines @@
           new(Z) LoadLocalNode(Scanner::kNoSourcePos, controller),
           Symbols::AddError(),
           args));
   ReturnNode* return_node = new(Z) ReturnNode(Scanner::kNoSourcePos);
   AddNodeForFinallyInlining(return_node);
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
-  TryBlocks* try_block = PopTryBlock();
-  ASSERT(try_blocks_list_ == NULL);  // We popped the outermost try block.
+  TryStack* outer_try = PopTry();

[hausner, 2015/03/05 00:23:01]

I always get confused with this name. Try statements are popped from inside out
(innermost try is at the top of the stack). Thus, naming the try statement you
pop off the stack the "outer_try" makes my head spin. I prefer just
"try_statement" or something. In CloseAsyncTryBlock it's called "inner_try",
btw. 

[regis, 2015/03/05 00:41:51]

Done. Renamed to "try_statement" here and below.

+  ASSERT(try_stack_ == NULL);  // We popped the outermost try block.
 
   // Finally block: closing the stream and returning. (Note: the return
   // is necessary otherwise the back-end will append a rethrow of the
   // current exception.)
   // :controller.close();
   // return;
   // We need to inline this code in all recorded exit points.
   intptr_t node_index = 0;
   SequenceNode* finally_clause = NULL;
   do {
     OpenBlock();
     ArgumentListNode* no_args =
         new(Z) ArgumentListNode(Scanner::kNoSourcePos);
     current_block_->statements->Add(
         new(Z) InstanceCallNode(try_end_pos,
             new(Z) LoadLocalNode(Scanner::kNoSourcePos, controller),
             Symbols::Close(),
             no_args));
 
     ReturnNode* return_node = new(Z) ReturnNode(Scanner::kNoSourcePos);
     current_block_->statements->Add(return_node);
 
     finally_clause = CloseBlock();
-    AstNode* node_to_inline = try_block->GetNodeToInlineFinally(node_index);
+    AstNode* node_to_inline = outer_try->GetNodeToInlineFinally(node_index);
     if (node_to_inline != NULL) {
       InlinedFinallyNode* node =
           new(Z) InlinedFinallyNode(try_end_pos,
                                     finally_clause,
                                     context_var,
                                     // No outer try statement
                                     CatchClauseNode::kInvalidTryIndex);
       finally_clause = NULL;
       AddFinallyBlockToNode(true, node_to_inline, node);
       node_index++;
     }
   } while (finally_clause == NULL);
 
   const GrowableObjectArray& handler_types =
       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();
+  const intptr_t try_index = outer_try->try_index();
 
   AstNode* try_catch_node =
       new(Z) TryCatchNode(Scanner::kNoSourcePos,
                           body,
                           context_var,
                           catch_clause,
                           finally_clause,
                           try_index);
   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(try_stack_ != NULL);
+  ASSERT(try_stack_->outer_try() == NULL);
   ASSERT(innermost_function().IsAsyncClosure());
   LocalScope* try_scope = current_block_->scope;
 
-  try_blocks_list_->enter_catch();
+  try_stack_->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();
@@ skipping 64 matching lines @@
   current_block_->statements->Add(return_node);
   AstNode* catch_block = CloseBlock();
   current_block_->statements->Add(catch_block);
   SequenceNode* catch_handler_list = CloseBlock();
 
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   handler_types.SetLength(0);
   handler_types.Add(*exception_param.type);
 
-  TryBlocks* inner_try_block = PopTryBlock();
-  const intptr_t try_index = inner_try_block->try_index();
+  TryStack* inner_try = PopTry();
+  const intptr_t try_index = inner_try->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,
@@ skipping 24 matching lines @@
                           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_);
+  ASSERT(try_stack_ == NULL);
+  PushTry(current_block_);
 
   SetupSavedTryContext(context_var);
 }
 
 
 void Parser::AddSyncGenClosureParameters(ParamList* params) {
   // Create the parameter list for the body closure of a sync generator:
   // 1) Implicit closure parameter;
   // 2) Iterator
   const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
@@ skipping 1851 matching lines @@
     dowhile_body->Add(await_preamble);
   }
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new(Z) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 // If the await or yield being parsed is in a try block, the continuation code
 // needs to restore the corresponding stack-based variable :saved_try_ctx_var,
-// and possibly the stack-based variable :saved_try_ctx_var of the outer try
-// block.
+// and the stack-based variable :saved_try_ctx_var of the outer try block.
 // The inner :saved_try_ctx_var is used by a finally clause handling an
-// exception thrown by the continuation code in a catch clause. If no finally
-// clause exists, the catch or finally clause of the outer try block, if any,
-// uses the outer :saved_try_ctx_var to handle the exception.
+// exception thrown by the continuation code in a try block or catch block.
+// If no finally clause exists, the catch or finally clause of the outer try
+// block, if any, uses the outer :saved_try_ctx_var to handle the exception.
 //
-// * Try blocks: Set the context variable for this try block.
-// * Catch blocks: Set the context variable for this try block and for any outer
-//                 try block (if existent).
-// * Finally blocks: Set the context variable for any outer try block (if
-//                   existent). Note that this try block is popped before
-//                   parsing the finally clause, so the outer try block (if
-//                   existent) is at the top of the try block list.
+// * Try blocks and catch blocks:
+//     Set the context variable for this try block and for the outer try block.
+// * Finally blocks:
+//     Set the context variable for the outer try block. Note that the try
+//     declaring the finally is popped before parsing the finally clause, so the
+//     outer try block is at the top of the try block list.
 //
 // TODO(regis): Could we return the variables instead of their containing
 // scopes? Check if they are already setup at this point.
 void Parser::CheckAsyncOpInTryBlock(LocalScope** try_scope,
                                     int16_t* try_index,
                                     LocalScope** outer_try_scope,
                                     int16_t* outer_try_index) const {
   *try_scope = NULL;
   *try_index = CatchClauseNode::kInvalidTryIndex;
   *outer_try_scope = NULL;
   *outer_try_index = CatchClauseNode::kInvalidTryIndex;
-  if (try_blocks_list_ != NULL) {
-    LocalScope* scope = try_blocks_list_->try_block()->scope;
+  if (try_stack_ != NULL) {
+    LocalScope* scope = try_stack_->try_block()->scope;
     const int current_function_level = current_block_->scope->function_level();
     if (scope->function_level() == current_function_level) {
       // The block declaring :saved_try_ctx_var variable is the parent of the
       // pushed try block.
       *try_scope = scope->parent();
-      *try_index = try_blocks_list_->try_index();
-      if (try_blocks_list_->inside_catch() &&
-          (try_blocks_list_->outer_try_block() != NULL)) {
-        scope = try_blocks_list_->outer_try_block()->try_block()->scope;
+      *try_index = try_stack_->try_index();
+      if (try_stack_->outer_try() != NULL) {
+        // TODO(regis): Collecting the outer try scope is not necessary if we
+        // are in a finally block. Add support for try_stack_->inside_finally().
+        scope = try_stack_->outer_try()->try_block()->scope;
         if (scope->function_level() == current_function_level) {
           *outer_try_scope = scope->parent();
-          *outer_try_index = try_blocks_list_->outer_try_block()->try_index();
+          *outer_try_index = try_stack_->outer_try()->try_index();
         }
       }
     }
   }
   // An async or async* has an implicitly created try-catch around the
   // function body, so the await or yield inside the async closure should always
   // be created with a try scope.
   ASSERT((*try_scope != NULL) ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsAsyncGenerator() ||
@@ skipping 494 matching lines @@
     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 (is_async) {
-    if (try_blocks_list_ != NULL) {
-      LocalScope* scope = try_blocks_list_->try_block()->scope;
+    if (try_stack_ != NULL) {
+      LocalScope* scope = try_stack_->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()));
+                Z, scope->parent(), try_stack_->try_index()));
       }
     }
     // We need to save the exception variables as in catch clauses, whether
     // there is an outer try or not. Note that this is only necessary if the
     // finally clause contains an await or yield.
     // TODO(hausner): Optimize.
     SaveExceptionAndStacktrace(current_block_->statements,
                                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) {
+void Parser::PushTry(Block* try_block) {
   intptr_t try_index = AllocateTryIndex();
-  TryBlocks* block = new(Z) TryBlocks(
-      try_block, try_blocks_list_, try_index);
-  try_blocks_list_ = block;
+  try_stack_ = new(Z) TryStack(try_block, try_stack_, try_index);
 }
 
 
-Parser::TryBlocks* Parser::PopTryBlock() {
-  TryBlocks* innermost_try_block = try_blocks_list_;
-  try_blocks_list_ = try_blocks_list_->outer_try_block();
-  return innermost_try_block;
+Parser::TryStack* Parser::PopTry() {
+  TryStack* innermost_try = try_stack_;
+  try_stack_ = try_stack_->outer_try();
+  return innermost_try;
 }
 
 
 void Parser::AddNodeForFinallyInlining(AstNode* node) {
   if (node == NULL) {
     return;
   }
   ASSERT(node->IsReturnNode() || node->IsJumpNode());
-  TryBlocks* iterator = try_blocks_list_;
+  TryStack* iterator = try_stack_;
   while (iterator != NULL) {
     // For continue and break node check if the target label is in scope.
     if (node->IsJumpNode()) {
       SourceLabel* label = node->AsJumpNode()->label();
       ASSERT(label != NULL);
       LocalScope* try_scope = iterator->try_block()->scope;
       // If the label is defined in a scope which is a child (nested scope)
       // of the try scope then we are not breaking out of this try block
       // so we do not need to inline the finally code. Otherwise we need
       // to inline the finally code of this try block and then move on to the
       // next outer try block.
       if (label->owner()->IsNestedWithin(try_scope)) {
         break;
       }
     }
     iterator->AddNodeForFinallyInlining(node);
-    iterator = iterator->outer_try_block();
+    iterator = iterator->outer_try();
   }
 }
 
 
 // Add the inlined finally block to the specified node.
 void Parser::AddFinallyBlockToNode(bool is_async,
                                    AstNode* node,
                                    InlinedFinallyNode* finally_node) {
   ReturnNode* return_node = node->AsReturnNode();
   if (return_node != NULL) {
@@ skipping 176 matching lines @@
   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();
   }
   // In case of async closures, restore :saved_try_context_var before executing
   // the catch clauses.
   if (is_async && (current != NULL)) {
-    ASSERT(try_blocks_list_ != NULL);
+    ASSERT(try_stack_ != NULL);
     SequenceNode* async_code = new(Z) SequenceNode(handler_pos, NULL);
-    const TryBlocks* try_block = try_blocks_list_->outer_try_block();
+    const TryStack* try_block = try_stack_->outer_try();
     if (try_block != NULL) {
       LocalScope* scope = try_block->try_block()->scope;
       if (scope->function_level() ==
           current_block_->scope->function_level()) {
         async_code->Add(
             AwaitTransformer::RestoreSavedTryContext(
                 Z, scope->parent(), try_block->try_index()));
       }
     }
     SaveExceptionAndStacktrace(async_code,
@@ skipping 137 matching lines @@
                           &context_var,
                           &exception_var,
                           &stack_trace_var,
                           &saved_exception_var,
                           &saved_stack_trace_var);
 
   ConsumeToken();  // Consume the 'try'.
 
   // Now parse the 'try' block.
   OpenBlock();
-  PushTryBlock(current_block_);
+  PushTry(current_block_);
   ExpectToken(Token::kLBRACE);
 
   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();
+  try_stack_->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,
                         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);
 
-  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;
+  TryStack* inner_try = PopTry();
+  const intptr_t try_index = inner_try->try_index();
+  TryStack* outer_try = try_stack_;
+  const intptr_t outer_try_index = (outer_try != NULL) ?
+      outer_try->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);
+    AstNode* node_to_inline = inner_try->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       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(is_async, node_to_inline, node);
       node_index += 1;
-      node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
+      node_to_inline = inner_try->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     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);
   }
 
@@ skipping 325 matching lines @@
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (token == Token::kSEMICOLON) {
     // Empty statement, nothing to do.
     ConsumeToken();
   } else if (token == Token::kRETHROW) {
     // Rethrow of current exception.
     ConsumeToken();
     ExpectSemicolon();
     // Check if it is ok to do a rethrow.
-    if ((try_blocks_list_ == NULL) || !try_blocks_list_->inside_catch()) {
+    if ((try_stack_ == NULL) || !try_stack_->inside_catch()) {
       ReportError(statement_pos, "rethrow of an exception is not valid here");
     }
 
     // If in async code, use :saved_exception_var and :saved_stack_trace_var
     // 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();
+    LocalScope* scope = try_stack_->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() ||
         innermost_function().IsAsyncGenClosure() ||
         innermost_function().IsAsyncGenerator()) {
       excp_var = scope->LocalLookupVariable(Symbols::SavedExceptionVar());
@@ skipping 3645 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart