[esnext] implement frontend changes for async/await proposal

src/parsing/scanner.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #include "src/parsing/scanner.h"
 
 #include <stdint.h>
 
@@ skipping 231 matching lines @@
 
 Token::Value Scanner::Next() {
   if (next_.token == Token::EOS) {
     next_.location.beg_pos = current_.location.beg_pos;
     next_.location.end_pos = current_.location.end_pos;
   }
   current_ = next_;
   if (V8_UNLIKELY(next_next_.token != Token::UNINITIALIZED)) {
     next_ = next_next_;
     next_next_.token = Token::UNINITIALIZED;
+    has_line_terminator_before_next_ = has_line_terminator_before_next2_;
+    has_multiline_comment_before_next_ = has_multiline_comment_before_next2_;
     return current_.token;
   }
   has_line_terminator_before_next_ = false;
   has_multiline_comment_before_next_ = false;
   if (static_cast<unsigned>(c0_) <= 0x7f) {
     Token::Value token = static_cast<Token::Value>(one_char_tokens[c0_]);
     if (token != Token::ILLEGAL) {
       int pos = source_pos();
       next_.token = token;
       next_.location.beg_pos = pos;
       next_.location.end_pos = pos + 1;
       Advance();
       return current_.token;
     }
   }
   Scan();
   return current_.token;
 }
 
 
 Token::Value Scanner::PeekAhead() {
   if (next_next_.token != Token::UNINITIALIZED) {
     return next_next_.token;
   }
   TokenDesc prev = current_;
+  bool has_line_terminator_before_next = has_line_terminator_before_next_;
+  bool has_multiline_comment_before_next = has_multiline_comment_before_next_;
   Next();
+  has_line_terminator_before_next2_ = has_line_terminator_before_next_;
+  has_multiline_comment_before_next2_ = has_multiline_comment_before_next_;
+  has_line_terminator_before_next_ = has_line_terminator_before_next;
+  has_multiline_comment_before_next_ = has_multiline_comment_before_next;

[Dan Ehrenberg, 2016/05/05 01:14:40]

From my experience with let, I'd predict that maintaining these will cause a
noticeable regression on CodeLoad. I wonder if we could consolidate them into
one variable. I only see a single usage which separates the two--detecting
-->-style comments inside of SkipWhiteSpace. Do you think there's any way we
might refactor this?

[caitp (gmail), 2016/05/05 01:36:57]

Well, I've done this in the simplest way I could, so it's very likely it could
be done better. Maybe it's worth a look at the CodeLoad impact before that,
though?

[caitp (gmail), 2016/05/05 21:49:36]

I've had a go at refactoring this --- I doubt it has any substantial improvement
on CodeLoad, but maybe.

   Token::Value ret = next_.token;
   next_next_ = next_;
   next_ = current_;
   current_ = prev;
   return ret;
 }
 
 
 // TODO(yangguo): check whether this is actually necessary.
 static inline bool IsLittleEndianByteOrderMark(uc32 c) {
@@ skipping 1174 matching lines @@
 }
 
 
 const AstRawString* Scanner::NextSymbol(AstValueFactory* ast_value_factory) {
   if (is_next_literal_one_byte()) {
     return ast_value_factory->GetOneByteString(next_literal_one_byte_string());
   }
   return ast_value_factory->GetTwoByteString(next_literal_two_byte_string());
 }
 
+const AstRawString* Scanner::NextNextSymbol(
+    AstValueFactory* ast_value_factory) {
+  DCHECK(next_next_.token != Token::UNINITIALIZED);
+  LiteralBuffer* literal = next_next_.literal_chars;
+  if (literal->is_one_byte()) {
+    return ast_value_factory->GetOneByteString(literal->one_byte_literal());
+  }
+  return ast_value_factory->GetTwoByteString(literal->two_byte_literal());
+}
 
 const AstRawString* Scanner::CurrentRawSymbol(
     AstValueFactory* ast_value_factory) {
   if (is_raw_literal_one_byte()) {
     return ast_value_factory->GetOneByteString(raw_literal_one_byte_string());
   }
   return ast_value_factory->GetTwoByteString(raw_literal_two_byte_string());
 }
 
 
@@ skipping 205 matching lines @@
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 }  // namespace internal
 }  // namespace v8