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

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 205 matching lines @@
     kParameterDefaultValueOffset,
     kParameterMetadataOffset,
     kParameterEntrySize,
   };
   static RawObject* ParseFunctionParameters(const Function& func);
 
  private:
   friend class EffectGraphVisitor;  // For BuildNoSuchMethodArguments.
 
   struct Block;
-  class TryBlocks;
+  class TryStack;
 
   Parser(const Script& script, const Library& library, intptr_t token_pos);
   Parser(const Script& script, ParsedFunction* function, intptr_t token_pos);
   ~Parser();
 
   // The function for which we will generate code.
   const Function& current_function() const;
 
   // The innermost function being parsed.
   const Function& innermost_function() const;
@@ skipping 376 matching lines @@
                                   LocalVariable* rethrow_exception_var,
                                   LocalVariable* rethrow_stack_trace_var,
                                   const GrowableObjectArray& handler_types,
                                   bool* needs_stack_trace);
   // Parse finally block and create an AST for it.
   SequenceNode* ParseFinallyBlock(bool is_async,
                                   LocalVariable* exception_var,
                                   LocalVariable* stack_trace_var,
                                   LocalVariable* rethrow_exception_var,
                                   LocalVariable* rethrow_stack_trace_var);
-  // Adds try block to the list of try blocks seen so far.
-  void PushTryBlock(Block* try_block);
-  // Pops the inner most try block from the list.
-  TryBlocks* PopTryBlock();
+  // Push try block onto the stack of try blocks in scope.
+  void PushTry(Block* try_block);
+  // Pop the inner most try block from the stack.
+  TryStack* PopTry();
   // Collect try block scopes and indices if await or yield is in try block.
   void CheckAsyncOpInTryBlock(LocalScope** try_scope,
                               int16_t* try_index,
                               LocalScope** outer_try_scope,
                               int16_t* outer_try_index) const;
   // Add specified node to try block list so that it can be patched with
   // inlined finally code if needed.
   void AddNodeForFinallyInlining(AstNode* node);
   // Add the inlined finally block to the specified node.
   void AddFinallyBlockToNode(bool is_async,
@@ skipping 196 matching lines @@
   // The class currently being parsed, or the owner class of the
   // function currently being parsed. It is used for primary identifier lookups.
   Class& current_class_;
 
   // The current library (and thus class dictionary) used to resolve names.
   // When parsing a function, this is the library in which the function
   // is defined. This can be the library in which the current_class_ is
   // defined, or the library of a mixin class where the function originates.
   Library& library_;
 
-  // List of try blocks seen so far, this is used to generate inlined finally
+  // Stack of try blocks in scope, this is used to generate inlined finally
   // code at all points in the try block where an exit from the block is
   // done using 'return', 'break' or 'continue' statements.
-  TryBlocks* try_blocks_list_;
+  TryStack* try_stack_;
 
   // Each try in this function gets its own try index.
   int16_t AllocateTryIndex();
 
   int16_t last_used_try_index_;
 
   bool unregister_pending_function_;
 
   LocalScope* async_temp_scope_;
 
   // Indentation of parser trace.
   intptr_t trace_indent_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_