Bubble up exceptions throw async/await.

runtime/vm/ast_transformer.cc

 // Copyright (c) 2014, 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/ast_transformer.h"
 
 #include "vm/parser.h"
 
 namespace dart {
 
@@ skipping 98 matching lines @@
 }
 
 
 void AwaitTransformer::VisitAwaitNode(AwaitNode* node) {
   // Await transformation:
   //
   //   :await_temp_var_X = <expr>;
   //   :result_param = :await_temp_var_X;
   //   if (:result_param is Future) {
   //     AwaitMarker(kNewContinuationState);
-  //     :result_param.then(:async_op);
+  //     :result_param = :result_param.then(:async_op);
+  //     _asyncCatchHelper(:result_param.catchError, :async_op);
   //     return;  // (return_type() == kContinuation)
   //   }
   //   AwaitMarker(kTargetForContinuation);  // Join happens here.
   //   :saved_try_ctx_var = :await_saved_try_ctx_var_y;
   //   :await_temp_var_(X+1) = :result_param;
 
   LocalVariable* async_op = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncOperation());
   LocalVariable* result_param = GetVariableInScope(
       preamble_->scope(), Symbols::AsyncOperationParam());
+  LocalVariable* error_param = GetVariableInScope(
+      preamble_->scope(), Symbols::AsyncOperationErrorParam());
 
   node->expr()->Visit(this);
   preamble_->Add(new(I) StoreLocalNode(
       Scanner::kNoSourcePos, result_param, result_));
   LoadLocalNode* load_result_param = new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param);
   LocalScope* is_future_scope = ChainNewScope(preamble_->scope());
   SequenceNode* is_future_branch = new (I) SequenceNode(
       Scanner::kNoSourcePos, is_future_scope);
   AwaitMarkerNode* await_marker = new (I) AwaitMarkerNode(
       AwaitMarkerNode::kNewContinuationState);
   await_marker->set_scope(is_future_scope);
   GetVariableInScope(is_future_scope, Symbols::AwaitJumpVar());
   GetVariableInScope(is_future_scope, Symbols::AwaitContextVar());
   is_future_branch->Add(await_marker);
   ArgumentListNode* args = new(I) ArgumentListNode(Scanner::kNoSourcePos);
   args->Add(new(I) LoadLocalNode(Scanner::kNoSourcePos, async_op));
-  is_future_branch->Add(new(I) InstanceCallNode(
-      Scanner::kNoSourcePos, load_result_param, Symbols::FutureThen(), args));
+  is_future_branch->Add(new (I) StoreLocalNode(
+      Scanner::kNoSourcePos,
+      result_param,
+      new(I) InstanceCallNode(
+          Scanner::kNoSourcePos,
+          load_result_param,
+          Symbols::FutureThen(),
+          args)));
+  const Library& core_lib = Library::Handle(Library::CoreLibrary());
+  const Function& async_catch_helper = Function::ZoneHandle(
+      I, core_lib.LookupFunctionAllowPrivate(Symbols::AsyncCatchHelper()));
+  ASSERT(!async_catch_helper.IsNull());
+  ArgumentListNode* catch_helper_args = new (I) ArgumentListNode(
+      Scanner::kNoSourcePos);
+  InstanceGetterNode* catch_error_getter = new (I) InstanceGetterNode(
+      Scanner::kNoSourcePos,
+      load_result_param,
+      Symbols::FutureCatchError());
+  catch_helper_args->Add(catch_error_getter);
+  catch_helper_args->Add(new (I) LoadLocalNode(
+      Scanner::kNoSourcePos, async_op));
+  is_future_branch->Add(new (I) StaticCallNode(
+      Scanner::kNoSourcePos,
+      async_catch_helper,
+      catch_helper_args));
   ReturnNode* continuation_return = new(I) ReturnNode(Scanner::kNoSourcePos);
   continuation_return->set_return_type(ReturnNode::kContinuation);
   is_future_branch->Add(continuation_return);
 
   const Class& cls = Class::ZoneHandle(
       I, library_.LookupClass(Symbols::Future()));
   const AbstractType& future_type = AbstractType::ZoneHandle(I, cls.RareType());
   ASSERT(!future_type.IsNull());
   preamble_->Add(new(I) IfNode(
       Scanner::kNoSourcePos,
@@ skipping 13 matching lines @@
       String::Handle(I, parsed_function_->async_saved_try_ctx_name());
   if (!async_saved_try_ctx_name.IsNull()) {
     LocalVariable* async_saved_try_ctx =
         GetVariableInScope(preamble_->scope(), async_saved_try_ctx_name);
     preamble_->Add(new (I) StoreLocalNode(
         Scanner::kNoSourcePos,
         parsed_function_->saved_try_ctx(),
         new (I) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
   }
 
+  LoadLocalNode* load_error_param = new (I) LoadLocalNode(
+      Scanner::kNoSourcePos, error_param);
+  SequenceNode* error_ne_null_branch = new (I) SequenceNode(
+      Scanner::kNoSourcePos, ChainNewScope(preamble_->scope()));
+  error_ne_null_branch->Add(new (I) ThrowNode(
+      Scanner::kNoSourcePos,
+      load_error_param,
+      NULL));
+  preamble_->Add(new (I) IfNode(
+      Scanner::kNoSourcePos,
+      new (I) ComparisonNode(
+          Scanner::kNoSourcePos,
+          Token::kNE,
+          load_error_param,
+          new (I) LiteralNode(Scanner::kNoSourcePos,
+                              Object::null_instance())),
+          error_ne_null_branch,
+          NULL));
+
   LocalVariable* result = AddToPreambleNewTempVar(new(I) LoadLocalNode(
       Scanner::kNoSourcePos, result_param));
   result_ = new(I) LoadLocalNode(Scanner::kNoSourcePos, result);
 }
 
 
 // Transforms boolean expressions into a sequence of evaluatons that only lazily
 // evaluate subexpressions.
 //
 // Example:
@@ skipping 347 matching lines @@
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   // TODO(mlippautz): Check if relevant.
   AstNode* new_exception = Transform(node->exception());
   AstNode* new_stacktrace = Transform(node->stacktrace());
   result_ = new(I) ThrowNode(node->token_pos(),
                              new_exception,
                              new_stacktrace);
 }
 
 }  // namespace dart