Sloppy-mode let parsing

src/scanner.h

 // 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.
 
 #ifndef V8_SCANNER_H_
 #define V8_SCANNER_H_
 
 #include "src/allocation.h"
@@ skipping 381 matching lines @@
 
   // -1 is outside of the range of any real source code.
   static const int kNoOctalLocation = -1;
 
   explicit Scanner(UnicodeCache* scanner_contants);
 
   void Initialize(Utf16CharacterStream* source);
 
   // Returns the next token and advances input.
   Token::Value Next();
+  // Returns the token following peek()
+  Token::Value PeekAhead();
   // Returns the current token again.
   Token::Value current_token() { return current_.token; }
   // Returns the location information for the current token
   // (the token last returned by Next()).
   Location location() const { return current_.location; }
 
   // Similar functions for the upcoming token.
 
   // One token look-ahead (past the token returned by Next()).
   Token::Value peek() const { return next_.token; }
@@ skipping 108 matching lines @@
   uc32 ScanOctalEscape(uc32 c, int length);
 
   // Call this after setting source_ to the input.
   void Init() {
     // Set c0_ (one character ahead)
     STATIC_ASSERT(kCharacterLookaheadBufferSize == 1);
     Advance();
     // Initialize current_ to not refer to a literal.
     current_.literal_chars = NULL;
     current_.raw_literal_chars = NULL;
+    uber_next_.token = Token::UNINITIALIZED;
+    prev_.token = Token::UNINITIALIZED;
   }
 
   // Support BookmarkScope functionality.
   bool SetBookmark();
   void ResetToBookmark();
   bool BookmarkHasBeenSet();
   bool BookmarkHasBeenReset();
   void DropBookmark();
   static void CopyTokenDesc(TokenDesc* to, TokenDesc* from);
 
   // Literal buffer support
   inline void StartLiteral() {
-    LiteralBuffer* free_buffer = (current_.literal_chars == &literal_buffer1_) ?
-            &literal_buffer2_ : &literal_buffer1_;
+    LiteralBuffer* free_buffer =
+        (current_.literal_chars == &literal_buffers_[0])

[adamk, 2015/08/15 00:28:31]

Why switch to using an array for this? The advantage of separate names is that a
typo is a compile-time error, instead of an OOB access at runtime. I'd prefer to
go back unless there's a particular need for using an array.

[adamk, 2015/08/17 18:24:39]

I didn't see this addressed in the latest patch.

[Dan Ehrenberg, 2015/08/17 18:35:19]

Oops, fixed.

+            ? &literal_buffers_[1]
+            : (current_.literal_chars == &literal_buffers_[1])
+                  ? &literal_buffers_[2]
+                  : &literal_buffers_[0];
     free_buffer->Reset();
     next_.literal_chars = free_buffer;
   }
 
   inline void StartRawLiteral() {
     LiteralBuffer* free_buffer =
-        (current_.raw_literal_chars == &raw_literal_buffer1_) ?
-            &raw_literal_buffer2_ : &raw_literal_buffer1_;
+        (current_.raw_literal_chars == &raw_literal_buffers_[0])
+            ? &raw_literal_buffers_[1]
+            : (current_.raw_literal_chars == &raw_literal_buffers_[1])
+                  ? &raw_literal_buffers_[2]
+                  : &raw_literal_buffers_[0];
     free_buffer->Reset();
     next_.raw_literal_chars = free_buffer;
   }
 
   INLINE(void AddLiteralChar(uc32 c)) {
     DCHECK_NOT_NULL(next_.literal_chars);
     next_.literal_chars->AddChar(c);
   }
 
   INLINE(void AddRawLiteralChar(uc32 c)) {
@@ skipping 156 matching lines @@
   Token::Value ScanTemplateSpan();
 
   // Return the current source position.
   int source_pos() {
     return static_cast<int>(source_->pos()) - kCharacterLookaheadBufferSize;
   }
 
   UnicodeCache* unicode_cache_;
 
   // Buffers collecting literal strings, numbers, etc.
-  LiteralBuffer literal_buffer1_;
-  LiteralBuffer literal_buffer2_;
+  LiteralBuffer literal_buffers_[3];
 
   // Values parsed from magic comments.
   LiteralBuffer source_url_;
   LiteralBuffer source_mapping_url_;
 
   // Buffer to store raw string values
-  LiteralBuffer raw_literal_buffer1_;
-  LiteralBuffer raw_literal_buffer2_;
+  LiteralBuffer raw_literal_buffers_[3];
 
-  TokenDesc current_;  // desc for current token (as returned by Next())
-  TokenDesc next_;     // desc for next token (one token look-ahead)
+  TokenDesc current_;    // desc for current token (as returned by Next())
+  TokenDesc next_;       // desc for next token (one token look-ahead)
+  TokenDesc uber_next_;  // desc for the token after next (push-back)

[adamk, 2015/08/15 00:28:31]

I think "next_next_" is clearer in English. That's my vote for a name unless
Andreas has a better idea.

+  TokenDesc prev_;       // desc for the previous token (stash for pushback)
 
   // Variables for Scanner::BookmarkScope and the *Bookmark implementation.
   // These variables contain the scanner state when a bookmark is set.
   //
   // We will use bookmark_c0_ as a 'control' variable, where:
   // - bookmark_c0_ >= 0: A bookmark has been set and this contains c0_.
   // - bookmark_c0_ == -1: No bookmark has been set.
   // - bookmark_c0_ == -2: The bookmark has been applied (ResetToBookmark).
   //
   // Which state is being bookmarked? The parser state is distributed over
@@ skipping 34 matching lines @@
   // inside multiline comments.
   bool has_line_terminator_before_next_;
   // Whether there is a multi-line comment that contains a
   // line-terminator after the current token, and before the next.
   bool has_multiline_comment_before_next_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_