Allow await expressions in arrow-style functions

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 81 matching lines @@
 int TraceParser::indent_ = 0;
 
 #define TRACE_PARSER(s) \
   TraceParser __p__(this->TokenPos(), this->script_, s)
 
 #else  // not DEBUG
 #define TRACE_PARSER(s)
 #endif  // DEBUG
 
 
+class BoolScope : public ValueObject {
+ public:
+  BoolScope(bool* addr, bool new_value) : _addr(addr), _saved_value(*addr) {
+    *_addr = new_value;
+  }
+  ~BoolScope() {
+    *_addr = _saved_value;
+  }
+
+ private:
+  bool* _addr;
+  bool _saved_value;
+};
+
+
 static RawTypeArguments* NewTypeArguments(const GrowableObjectArray& objs) {
   const TypeArguments& a =
       TypeArguments::Handle(TypeArguments::New(objs.Length()));
   AbstractType& type = AbstractType::Handle();
   for (int i = 0; i < objs.Length(); i++) {
     type ^= objs.At(i);
     a.SetTypeAt(i, type);
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
@@ skipping 2936 matching lines @@
 
   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);
   } else if (func.is_async_closure()) {
     OpenAsyncClosure();
   }
 
-  bool saved_await_is_keyword = await_is_keyword_;
-  await_is_keyword_ = func.IsAsyncFunction() || func.is_async_closure();
-
+  BoolScope allow_await(&this->await_is_keyword_,
+                        func.IsAsyncFunction() || func.is_async_closure());
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(I, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseStatementSequence();
     end_token_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     if (String::Handle(I, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     const intptr_t expr_pos = TokenPos();
-    AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
+    AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
     end_token_pos = TokenPos();
   } else if (IsLiteral("native")) {
     if (String::Handle(I, func.name()).Equals(
         Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
@@ skipping 25 matching lines @@
   SequenceNode* body = CloseBlock();
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     body = CloseAsyncFunction(async_closure, body);
     async_closure.set_end_token_pos(end_token_pos);
   } else if (func.is_async_closure()) {
     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();
 }
 
 
 void Parser::AddEqualityNullCheck() {
   AstNode* argument =
@@ skipping 335 matching lines @@
     if (method->redirect_name != NULL) {
       ReportError(method->name_pos,
                   "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
       method_end_pos = TokenPos();
       ExpectToken(Token::kRBRACE);
     } else {
       ConsumeToken();
+      BoolScope allow_await(&this->await_is_keyword_,
+                            async_modifier != RawFunction::kNoModifier);
       SkipExpr();
       method_end_pos = TokenPos();
       ExpectSemicolon();
     }
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ReportError(method->name_pos,
                   "abstract method '%s' may not have a function body",
                   method->name->ToCString());
     } else if (method->IsConstructor() && method->has_const) {
@@ skipping 1654 matching lines @@
   bool is_native = false;
   if (is_external) {
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     function_end_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
+    BoolScope allow_await(&this->await_is_keyword_,
+                          func_modifier != RawFunction::kNoModifier);
     SkipExpr();
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
     function_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
   } else {
     ReportError("function block expected");
@@ skipping 6627 matching lines @@
       SkipType(true);
     }
     ExpectIdentifier("function name expected");
   }
   if (CurrentToken() == Token::kLPAREN) {
     const bool allow_explicit_default_values = true;
     ParamList params;
     params.skipped = true;
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
-  ParseFunctionModifier();
+  RawFunction::AsyncModifier async_modifier = ParseFunctionModifier();
+  BoolScope allow_await(&this->await_is_keyword_,
+                        async_modifier != RawFunction::kNoModifier);
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
@@ skipping 226 matching lines @@
   SkipPrimary();
   SkipSelectors();
   if (IsIncrementOperator(CurrentToken())) {
     ConsumeToken();
   }
 }
 
 
 void Parser::SkipUnaryExpr() {
   if (IsPrefixOperator(CurrentToken()) ||
-      IsIncrementOperator(CurrentToken())) {
+      IsIncrementOperator(CurrentToken()) ||
+      IsAwaitKeyword()) {
     ConsumeToken();
     SkipUnaryExpr();
   } else {
     SkipPostfixExpr();
   }
 }
 
 
 void Parser::SkipBinaryExpr() {
   SkipUnaryExpr();
@@ skipping 54 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart