Fix scoping async functions.

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 30 matching lines @@
   ParsedFunction(Isolate* isolate, const Function& function)
       : function_(function),
         code_(Code::Handle(isolate, function.unoptimized_code())),
         node_sequence_(NULL),
         instantiator_(NULL),
         default_parameter_values_(Array::ZoneHandle(isolate, Array::null())),
         saved_current_context_var_(NULL),
         saved_entry_context_var_(NULL),
         expression_temp_var_(NULL),
         finally_return_temp_var_(NULL),
-        await_temps_scope_(NULL),
         deferred_prefixes_(new ZoneGrowableArray<const LibraryPrefix*>()),
         first_parameter_index_(0),
         first_stack_local_index_(0),
         num_copied_params_(0),
         num_stack_locals_(0),
         have_seen_await_expr_(false),
         saved_try_ctx_(NULL),
-        async_saved_try_ctx_(NULL),
+        async_saved_try_ctx_name_(String::ZoneHandle(isolate, String::null())),
         isolate_(isolate) {
     ASSERT(function.IsZoneHandle());
   }
 
   const Function& function() const { return function_; }
   const Code& code() const { return code_; }
 
   SequenceNode* node_sequence() const { return node_sequence_; }
   void SetNodeSequence(SequenceNode* node_sequence);
 
@@ skipping 65 matching lines @@
   }
   void AddDeferredPrefix(const LibraryPrefix& prefix);
 
   int first_parameter_index() const { return first_parameter_index_; }
   int first_stack_local_index() const { return first_stack_local_index_; }
   int num_copied_params() const { return num_copied_params_; }
   int num_stack_locals() const { return num_stack_locals_; }
 
   void AllocateVariables();
 
-  void set_await_temps_scope(LocalScope* scope) {
-    ASSERT(await_temps_scope_ == NULL);
-    await_temps_scope_ = scope;
-  }
-  LocalScope* await_temps_scope() const {
-    ASSERT(await_temps_scope_ != NULL);
-    return await_temps_scope_;
-  }
-
   void record_await() {
     have_seen_await_expr_ = true;
   }
   void reset_have_seen_await() { have_seen_await_expr_ = false; }
   bool have_seen_await() const { return have_seen_await_expr_; }
 
   void set_saved_try_ctx(LocalVariable* saved_try_ctx) {
-    ASSERT((saved_try_ctx != NULL) && !saved_try_ctx->is_captured());
+    ASSERT((saved_try_ctx == NULL) || !saved_try_ctx->is_captured());
     saved_try_ctx_ = saved_try_ctx;
   }
   LocalVariable* saved_try_ctx() const { return saved_try_ctx_; }
 
-  void set_async_saved_try_ctx(LocalVariable* async_saved_try_ctx) {
-    ASSERT((async_saved_try_ctx != NULL) && async_saved_try_ctx->is_captured());
-    async_saved_try_ctx_ = async_saved_try_ctx;
+  void set_async_saved_try_ctx_name(const String& async_saved_try_ctx_name) {
+    async_saved_try_ctx_name_ = async_saved_try_ctx_name.raw();
   }
-  LocalVariable* async_saved_try_ctx() const { return async_saved_try_ctx_; }
+  RawString* async_saved_try_ctx_name() const {
+    return async_saved_try_ctx_name_.raw();
+  }
 
   void reset_saved_try_ctx_vars() {
     saved_try_ctx_ = NULL;
-    async_saved_try_ctx_ = NULL;
+    async_saved_try_ctx_name_ = String::null();
   }
 
   Isolate* isolate() const { return isolate_; }
 
  private:
   const Function& function_;
   Code& code_;
   SequenceNode* node_sequence_;
   LocalVariable* instantiator_;
   Array& default_parameter_values_;
   LocalVariable* saved_current_context_var_;
   LocalVariable* saved_entry_context_var_;
   LocalVariable* expression_temp_var_;
   LocalVariable* finally_return_temp_var_;
-  LocalScope* await_temps_scope_;
   ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes_;
 
   int first_parameter_index_;
   int first_stack_local_index_;
   int num_copied_params_;
   int num_stack_locals_;
   bool have_seen_await_expr_;
   LocalVariable* saved_try_ctx_;
-  LocalVariable* async_saved_try_ctx_;
+  String& async_saved_try_ctx_name_;

[Michael Lippautz (Google), 2014/09/02 18:22:11]

It's not ideal that we need to save the symbol in the one case and the variable
in the other... 

We need to look up the async version though as the try/catch/finally might live
in a context level further down.

 
   Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(ParsedFunction);
 };
 
 
 class Parser : public ValueObject {
  public:
   // Parse the top level of a whole script file and register declared classes
@@ skipping 341 matching lines @@
   void ChainNewBlock(LocalScope* outer_scope);
   void OpenBlock();
   void OpenLoopBlock();
   void OpenFunctionBlock(const Function& func);
   void OpenAsyncClosure();
   RawFunction* OpenAsyncFunction(intptr_t formal_param_pos);
   SequenceNode* CloseBlock();
   SequenceNode* CloseAsyncFunction(const Function& closure,
                                    SequenceNode* closure_node);
   void CloseAsyncClosure(SequenceNode* body);
+  void AddAsyncClosureVariables();
 
 
   LocalVariable* LookupPhaseParameter();
   LocalVariable* LookupReceiver(LocalScope* from_scope, bool test_only);
   LocalVariable* LookupTypeArgumentsParameter(LocalScope* from_scope,
                                               bool test_only);
   void CaptureInstantiator();
   AstNode* LoadReceiver(intptr_t token_pos);
   AstNode* LoadTypeArgumentsParameter(intptr_t token_pos);
   AstNode* LoadFieldIfUnresolved(AstNode* node);
@@ skipping 154 matching lines @@
   AstNode* MakeAssertCall(intptr_t begin, intptr_t end);
   AstNode* ThrowTypeError(intptr_t type_pos, const AbstractType& type);
   AstNode* ThrowNoSuchMethodError(intptr_t call_pos,
                                   const Class& cls,
                                   const String& function_name,
                                   ArgumentListNode* function_arguments,
                                   InvocationMirror::Call call,
                                   InvocationMirror::Type type,
                                   const Function* func);
 
-  void SetupSavedTryContext(LocalScope* saved_try_context_scope,
-                            int16_t try_index,
-                            SequenceNode* target);
+  void SetupSavedTryContext(LocalVariable* saved_try_context);
+  void RestoreSavedTryContext(LocalScope* saved_try_context_scope,
+                              int16_t try_index,
+                              SequenceNode* target);
 
   void CheckOperatorArity(const MemberDesc& member);
 
   void EnsureExpressionTemp();
   void EnsureSavedCurrentContext();
   bool IsLegalAssignableSyntax(AstNode* expr, intptr_t end_pos);
   AstNode* CreateAssignmentNode(AstNode* original,
                                 AstNode* rhs,
                                 const String* left_ident,
                                 intptr_t left_pos);
@@ skipping 63 matching lines @@
   // done using 'return', 'break' or 'continue' statements.
   TryBlocks* try_blocks_list_;
 
   // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_