Bubble up exceptions throw async/await.

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 205 matching lines @@
       set_saved_entry_context_var(context_var);
     }
   }
 
   // Frame indices are relative to the frame pointer and are decreasing.
   ASSERT(next_free_frame_index <= first_stack_local_index_);
   num_stack_locals_ = first_stack_local_index_ - next_free_frame_index;
 }
 
 
+struct CatchParamDesc {
+  CatchParamDesc()
+      : token_pos(0), type(NULL), name(NULL), var(NULL) { }
+  intptr_t token_pos;
+  const AbstractType* type;
+  const String* name;
+  LocalVariable* var;
+};
+
+
 struct Parser::Block : public ZoneAllocated {
   Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
     : parent(outer_block), scope(local_scope), statements(seq) {
     ASSERT(scope != NULL);
     ASSERT(statements != NULL);
   }
   Block* parent;  // Enclosing block, or NULL if outermost.
   LocalScope* scope;
   SequenceNode* statements;
 };
@@ skipping 2751 matching lines @@
   }
   ASSERT((CurrentToken() == Token::kLPAREN) ||
          func.IsGetterFunction() ||
          func.is_async_closure());
   const bool allow_explicit_default_values = true;
   if (func.IsGetterFunction()) {
     // Populate function scope with the formal parameters. Since in this case
     // we are compiling a getter this will at most populate the receiver.
     AddFormalParamsToScope(&params, current_block_->scope);
   } else if (func.is_async_closure()) {
-    // Async closures have one optional parameter for continuation results.
+    // Async closures have two optional parameters:
+    // * A continuation result.
+    // * A continuation error.
+    //
+    // If the error!=null we rethrow the error at the next await.
+    const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
     ParamDesc result_param;
     result_param.name = &Symbols::AsyncOperationParam();
     result_param.default_value = &Object::null_instance();
-    result_param.type = &Type::ZoneHandle(I, Type::DynamicType());
+    result_param.type = &dynamic_type;
+    ParamDesc error_param;
+    error_param.name = &Symbols::AsyncOperationErrorParam();
+    error_param.default_value = &Object::null_instance();
+    error_param.type = &dynamic_type;
     params.parameters->Add(result_param);
-    params.num_optional_parameters++;
+    params.parameters->Add(error_param);
+    params.num_optional_parameters += 2;
     params.has_optional_positional_parameters = true;
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
     AddFormalParamsToScope(&params, current_block_->scope);
     ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
     if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
       // Parse away any formal parameters, as they are accessed as as context
       // variables.
       ParamList parse_away;
       ParseFormalParameterList(allow_explicit_default_values,
@@ skipping 41 matching lines @@
   }
 
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
   func.set_modifier(func_modifier);
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& async_closure = Function::ZoneHandle(I);
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     async_closure = OpenAsyncFunction(formal_params_pos);
-    async_temp_scope_ = current_block_->scope;
   } else if (func.is_async_closure()) {
     OpenAsyncClosure();
-    async_temp_scope_ = current_block_->scope;
   }
 
   bool saved_await_is_keyword = await_is_keyword_;
   if (func.IsAsyncFunction() || func.is_async_closure()) {
     await_is_keyword_ = true;
   }
 
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
@@ skipping 50 matching lines @@
     UnexpectedToken();
   }
 
   ASSERT(func.end_token_pos() == func.token_pos() ||
          func.end_token_pos() == end_token_pos);
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     body = CloseAsyncFunction(async_closure, body);
   } else if (func.is_async_closure()) {
-    CloseAsyncClosure(body);
+    body = CloseAsyncClosure(body);
   }
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   await_is_keyword_ = saved_await_is_keyword;
   async_temp_scope_ = saved_async_temp_scope;
   parsed_function()->set_saved_try_ctx(saved_saved_try_ctx);
   parsed_function()->set_async_saved_try_ctx_name(
       saved_async_saved_try_ctx_name);
   return CloseBlock();
@@ skipping 2388 matching lines @@
         new(I) LocalScope(current_block_->scope,
                                   current_block_->scope->function_level() + 1,
                                   0);
   }
   ChainNewBlock(outer_scope);
 }
 
 
 void Parser::OpenAsyncClosure() {
   TRACE_PARSER("OpenAsyncClosure");
+
+  async_temp_scope_ = current_block_->scope;
+
+  OpenAsyncTryBlock();
 }
 
 
+SequenceNode* Parser::CloseAsyncTryBlock(SequenceNode* try_block) {
+  try_blocks_list_->enter_catch();
+
+  OpenBlock();
+  OpenBlock();
+  const AbstractType& dynamic_type =
+      AbstractType::ZoneHandle(I, 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);
+  ASSERT(context_var != NULL);
+  LocalVariable* exception_var = current_block_->scope->LookupVariable(
+      Symbols::ExceptionVar(), false);
+  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(I) StoreLocalNode(
+        Scanner::kNoSourcePos,
+        exception_param.var,
+        new(I) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
+  }
+  LocalVariable* stack_trace_var =
+      current_block_->scope->LookupVariable(Symbols::StackTraceVar(), false);
+  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.
+    ArgumentListNode* no_args = new(I) ArgumentListNode(Scanner::kNoSourcePos);
+    ASSERT(stack_trace_var != NULL);
+    current_block_->statements->Add(new(I) StoreLocalNode(
+        Scanner::kNoSourcePos,
+        stack_trace_param.var,
+        new(I) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
+    current_block_->statements->Add(new(I) InstanceCallNode(
+        Scanner::kNoSourcePos,
+        new(I) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var),
+        Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
+        no_args));
+  }
+
+  ASSERT(try_blocks_list_ != NULL);
+  if (innermost_function().is_async_closure() ||
+      innermost_function().IsAsyncFunction()) {
+    if ((try_blocks_list_->outer_try_block() != NULL) &&
+        (try_blocks_list_->outer_try_block()->try_block()
+            ->scope->function_level() ==
+         current_block_->scope->function_level())) {
+      // We need to unchain three scope levels: catch clause, catch
+      // parameters, and the general try block.
+      RestoreSavedTryContext(
+          current_block_->scope->parent()->parent()->parent(),
+          try_blocks_list_->outer_try_block()->try_index(),
+          current_block_->statements);
+    } else {
+      parsed_function()->reset_saved_try_ctx_vars();
+    }
+  }
+
+  // Complete the async future with an error.
+  // Since we control the catch block there is no need to generate a nested
+  // if/then/else.
+  LocalVariable* async_completer = current_block_->scope->LookupVariable(
+      Symbols::AsyncCompleter(), false);
+  ASSERT(async_completer != NULL);
+  ArgumentListNode* completer_args =
+      new (I) ArgumentListNode(Scanner::kNoSourcePos);
+  completer_args->Add(
+      new (I) LoadLocalNode(Scanner::kNoSourcePos, exception_param.var));
+  completer_args->Add(
+      new (I) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var));
+  current_block_->statements->Add(new (I) InstanceCallNode(
+      Scanner::kNoSourcePos,
+      new (I) LoadLocalNode(Scanner::kNoSourcePos, async_completer),
+      Symbols::CompleterCompleteError(),
+      completer_args));
+  ReturnNode* return_node = new (I) ReturnNode(Scanner::kNoSourcePos);
+  // Behavior like a continuation return, i.e,. don't call a completer.
+  return_node->set_return_type(ReturnNode::kContinuation);
+  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(I, 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();
+
+  CatchClauseNode* catch_clause = new (I) CatchClauseNode(
+      Scanner::kNoSourcePos,
+      catch_handler_list,
+      Array::ZoneHandle(I, Array::MakeArray(handler_types)),
+      context_var,
+      exception_var,
+      stack_trace_var,
+      CatchClauseNode::kInvalidTryIndex,
+      true);
+  AstNode* try_catch_node = new (I) TryCatchNode(
+      Scanner::kNoSourcePos,
+      try_block,
+      context_var,
+      catch_clause,
+      NULL,
+      try_index);
+  current_block_->statements->Add(try_catch_node);
+  return CloseBlock();
+}
+
+
+void Parser::OpenAsyncTryBlock() {
+  // Manually wrapping the actual body into a try/catch block.
+  LocalVariable* context_var =
+      current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
+  if (context_var == NULL) {
+    context_var = new(I) LocalVariable(
+        TokenPos(),
+        Symbols::SavedTryContextVar(),
+        Type::ZoneHandle(I, Type::DynamicType()));
+    current_block_->scope->AddVariable(context_var);
+  }
+  LocalVariable* exception_var =
+      current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
+  if (exception_var == NULL) {
+    exception_var = new(I) LocalVariable(
+        TokenPos(),
+        Symbols::ExceptionVar(),
+        Type::ZoneHandle(I, Type::DynamicType()));
+    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(I) LocalVariable(
+        TokenPos(),
+        Symbols::StackTraceVar(),
+        Type::ZoneHandle(I, Type::DynamicType()));
+    current_block_->scope->AddVariable(stack_trace_var);
+  }
+
+  // Open the try block.
+  OpenBlock();
+  PushTryBlock(current_block_);
+
+  if (innermost_function().is_async_closure() ||
+      innermost_function().IsAsyncFunction()) {
+    SetupSavedTryContext(context_var);
+  }
+}
+
+
 RawFunction* Parser::OpenAsyncFunction(intptr_t formal_param_pos) {
   TRACE_PARSER("OpenAsyncFunction");
 
   AddAsyncClosureVariables();
 
   // Create the closure containing the old body of this function.
   Class& sig_cls = Class::ZoneHandle(I);
   Type& sig_type = Type::ZoneHandle(I);
   Function& closure = Function::ZoneHandle(I);
   String& sig = String::ZoneHandle(I);
   ParamList closure_params;
+  const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
   closure_params.AddFinalParameter(
-      formal_param_pos,
-      &Symbols::ClosureParameter(),
-      &Type::ZoneHandle(I, Type::DynamicType()));
+      formal_param_pos, &Symbols::ClosureParameter(), &dynamic_type);
   ParamDesc result_param;
   result_param.name = &Symbols::AsyncOperationParam();
   result_param.default_value = &Object::null_instance();
-  result_param.type = &Type::ZoneHandle(I, Type::DynamicType());
+  result_param.type = &dynamic_type;
+  ParamDesc error_param;
+  error_param.name = &Symbols::AsyncOperationErrorParam();
+  error_param.default_value = &Object::null_instance();
+  error_param.type = &dynamic_type;
   closure_params.parameters->Add(result_param);
+  closure_params.parameters->Add(error_param);
   closure_params.has_optional_positional_parameters = true;
-  closure_params.num_optional_parameters++;
+  closure_params.num_optional_parameters += 2;
   closure = Function::NewClosureFunction(
       Symbols::AnonymousClosure(),
       innermost_function(),
       formal_param_pos);
   AddFormalParamsToFunction(&closure_params, closure);
   closure.set_is_async_closure(true);
   closure.set_result_type(AbstractType::Handle(Type::DynamicType()));
   sig = closure.Signature();
   sig_cls = library_.LookupLocalClass(sig);
   if (sig_cls.IsNull()) {
     sig_cls = Class::NewSignatureClass(sig, closure, script_, formal_param_pos);
     library_.AddClass(sig_cls);
   }
   closure.set_signature_class(sig_cls);
   sig_type = sig_cls.SignatureType();
   if (!sig_type.IsFinalized()) {
     ClassFinalizer::FinalizeType(
         sig_cls, sig_type, ClassFinalizer::kCanonicalize);
   }
   ASSERT(AbstractType::Handle(I, closure.result_type()).IsResolved());
   ASSERT(closure.NumParameters() == closure_params.parameters->length());
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   OpenBlock();
+
+  async_temp_scope_ = current_block_->scope;
+
   return closure.raw();
 }
 
 
 void Parser::AddAsyncClosureVariables() {
   // Add to AST:
   //   var :await_jump_var;
   //   var :await_ctx_var;
   //   var :async_op;
   //   var :async_completer;
@@ skipping 123 matching lines @@
           Scanner::kNoSourcePos,
           new (I) LoadLocalNode(
               Scanner::kNoSourcePos,
               async_completer),
           Symbols::CompleterFuture()));
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
-void Parser::CloseAsyncClosure(SequenceNode* body) {
+SequenceNode* Parser::CloseAsyncClosure(SequenceNode* body) {
   TRACE_PARSER("CloseAsyncClosure");
+
   // We need a temporary expression to store intermediate return values.
   parsed_function()->EnsureExpressionTemp();
   // Implicitly mark those variables below as captured. We currently mark all
   // variables of all scopes as captured (below), but as soon as we do something
   // smarter we rely on these internal variables to be available.
-  body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
-  body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
-  body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
-  body->scope()->RecursivelyCaptureAllVariables();
+  SequenceNode* new_body = CloseAsyncTryBlock(body);
+  ASSERT(new_body != NULL);
+  ASSERT(new_body->scope() != NULL);
+  new_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
+  new_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
+  new_body->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
+  new_body->scope()->RecursivelyCaptureAllVariables();
+  return new_body;
 }
 
 
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList* params,
                                             Array* default_values) {
   if (params->num_optional_parameters > 0) {
     // Build array of default parameter values.
     ParamDesc* param =
       params->parameters->data() + params->num_fixed_parameters;
@@ skipping 1502 matching lines @@
   condition = new(I) UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new(I) IfNode(
       condition_pos,
       condition,
       NodeAsSequenceNode(condition_pos, assert_throw, NULL),
       NULL);
 }
 
 
-struct CatchParamDesc {
-  CatchParamDesc()
-      : token_pos(0), type(NULL), name(NULL), var(NULL) { }
-  intptr_t token_pos;
-  const AbstractType* type;
-  const String* name;
-  LocalVariable* var;
-};
-
-
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(CatchParamDesc* exception_param,
                                    CatchParamDesc* stack_trace_param,
                                    LocalScope* scope) {
   if (exception_param->name != NULL) {
     LocalVariable* var = new(I) LocalVariable(
         exception_param->token_pos,
         *exception_param->name,
         *exception_param->type);
     var->set_is_final();
@@ skipping 283 matching lines @@
     type_tests.RemoveLast();
     current_block_->statements->Add(catch_blocks.RemoveLast());
     current = CloseBlock();
   }
   // 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();
+
+    // 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().is_async_closure() ||
+        innermost_function().IsAsyncFunction()) {
+      if ((try_blocks_list_->outer_try_block() != NULL) &&
+          (try_blocks_list_->outer_try_block()->try_block()
+              ->scope->function_level() ==
+           current_block_->scope->function_level())) {
+        // We need to unchain three scope levels: catch clause, catch
+        // parameters, and the general try block.
+        RestoreSavedTryContext(
+            current_block_->scope->parent()->parent(),
+            try_blocks_list_->outer_try_block()->try_index(),
+            current_block_->statements);
+      } else {
+        parsed_function()->reset_saved_try_ctx_vars();
+      }
+    }
+
     current_block_->statements->Add(new(I) IfNode(
         type_test->token_pos(), type_test, catch_block, current));
     current = CloseBlock();
   }
   return current;
 }
 
 
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name =
@@ skipping 3968 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart