Fix scope/context behavior in await transformer.

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 6237 matching lines @@
     *value = Bool::True().raw();
     return true;
   } else if (CurrentToken() == Token::kFALSE) {
     *value = Bool::False().raw();
     return true;
   }
   return false;
 }
 
 
-// Returns true if the current token is kIDENT or a pseudo-keyword.
+// Returns true if the current token is
+// * kIDENT,
+// * or a pseudo-keyword,
+// * or is not the literal "await" in an async function.
 bool Parser::IsIdentifier() {
-  return Token::IsIdentifier(CurrentToken());
+  bool is_async = false;
+  if (parsed_function() != NULL) {
+    const Function& func = parsed_function()->function();
+    if (!func.IsNull()) {
+      is_async = func.IsAsyncFunction() || func.is_async_closure();

[hausner, 2014/08/26 20:45:47]

I think this is too expensive. I think it would make sense to cache a boolean
value in the parser object that determines whether "async" is a regular
identifier or a keyword.

The value is known when the parser object is created, I believe.

[Michael Lippautz (Google), 2014/08/26 22:07:44]

Agree. I added the proposed indicator to the parser. It is only set/reset when
actually parsing the function body, i.e., in ParseFunc().

+    }
+  }
+  return Token::IsIdentifier(CurrentToken()) &&
+         (!is_async || (CurrentLiteral()->raw() != Symbols::Await().raw()));
 }
 
 
 // Returns true if the next tokens can be parsed as a an optionally
 // qualified identifier: [ident '.'] ident.
 // Current token position is not restored.
 bool Parser::TryParseQualIdent() {
   if (CurrentToken() != Token::kIDENT) {
     return false;
   }
@@ skipping 2176 matching lines @@
   parsed_function()->reset_have_seen_await();
   AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (parsed_function()->have_seen_await()) {
     if (!current_block_->scope->LookupVariable(
           Symbols::AsyncOperation(), true)) {
       // Async operations are always encapsulated into a local function. We only
       // need to transform the expression when generating code for this inner
       // function.
       return expr;
     }
-    SequenceNode* intermediates_block = new(I) SequenceNode(
-        Scanner::kNoSourcePos, current_block_->scope);
-    AwaitTransformer at(intermediates_block, library_, parsed_function());
+    OpenBlock();
+    AwaitTransformer at(current_block_->statements,
+                        library_,
+                        parsed_function());
     AstNode* result = at.Transform(expr);
-    current_block_->statements->Add(intermediates_block);
+    current_block_->statements->Add(CloseBlock());
     parsed_function()->reset_have_seen_await();
     return result;
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
@@ skipping 2364 matching lines @@
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   const Token::Kind token = CurrentToken();
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
-  } else if (IsLiteral("await") &&
+  } else if ((CurrentLiteral()->raw() == Symbols::Await().raw()) &&
              (parsed_function()->function().IsAsyncFunction() ||
               parsed_function()->function().is_async_closure())) {
     // The body of an async function is parsed multiple times. The first time
     // when setting up an AsyncFunction() for generating relevant scope
     // information. The second time the body is parsed for actually generating
     // code.
     TRACE_PARSER("ParseAwaitExpr");
     ConsumeToken();
     parsed_function()->record_await();
     primary = new(I) AwaitNode(
@@ skipping 530 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart