Raise SyntaxError on let [ starting an ExpressionStatement

src/parsing/parser-base.h

 // Copyright 2012 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 4978 matching lines @@
   int pos = peek_position();
 
   switch (peek()) {
     case Token::FUNCTION:
     case Token::LBRACE:
       UNREACHABLE();  // Always handled by the callers.
     case Token::CLASS:
       ReportUnexpectedToken(Next());
       *ok = false;
       return impl()->NullStatement();
+    case Token::LET:
+      if (PeekAhead() != Token::LBRACK) break;
+      impl()->ReportMessageAt(scanner()->peek_location(),
+                              MessageTemplate::kUnexpectedTokenLetLBrack);
+      *ok = false;
+      return impl()->NullStatement();
     default:
       break;
   }
 
   bool starts_with_identifier = peek_any_identifier();
   ExpressionT expr = ParseExpression(true, CHECK_OK);
   if (peek() == Token::COLON && starts_with_identifier &&
       impl()->IsIdentifier(expr)) {
     // The whole expression was a single identifier, and not, e.g.,
     // something starting with an identifier or a parenthesized identifier.
@@ skipping 430 matching lines @@
 
   // Create an in-between scope for let-bound iteration variables.
   BlockState for_state(zone(), &scope_state_);
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   for_state.set_start_position(scanner()->location().beg_pos);
   for_state.set_is_hidden();
 
   StatementT init = impl()->NullStatement();
 
+  // "let [" is forbidden in the initializer of the for loop.
+  if (peek() == Token::LET && PeekAhead() == Token::LBRACK) {
+    impl()->ReportMessageAt(scanner()->peek_location(),
+                            MessageTemplate::kUnexpectedTokenLetLBrack);
+    *ok = false;
+    return init;
+  }

[Dan Ehrenberg, 2017/02/13 19:26:57]

I'm not sure I agree with your reading of the specification. Yes, the case Andre
mentioned (which you handled above, and which seems good to me AFAICT) is
prohibited, but I think the negative lookahead in IterationStatement is more for
disambiguation, so that "let [" is forced to be parsed as part of a
LexicalDeclaration rather than an Expression (otherwise, there's ambiguity and
lookahead would have to continue further). I believe this disagreement is what's
causing your test failures.

[vabr (Chromium), 2017/02/13 20:14:46]

The test failures are due to not restricting this check to for(;;) (as opposed
to for-each and for-in).

If the parser gets here, the attempt to parse the "let [" as LexicalDeclaration
has already failed (see ParseStatementListItem).

[vabr (Chromium), 2017/02/13 20:29:20]

Hm, now I see how I misunderstood your comment and mixed my observation about
the ExpressionStatement case.

Let me think about this a little more, I will update the CL with the next
proposal (which might be to restrict this change just to address the
ExpressionStatement case).

   if (peek() == Token::VAR || peek() == Token::CONST ||
       (peek() == Token::LET && IsNextLetKeyword())) {
     // The initializer contains declarations.
     ParseVariableDeclarations(kForStatement, &for_info.parsing_result, nullptr,
                               CHECK_OK);
     bound_names_are_lexical =
         IsLexicalVariableMode(for_info.parsing_result.descriptor.mode);
     for_info.position = scanner()->location().beg_pos;
 
     if (CheckInOrOf(&for_info.mode)) {
@@ skipping 308 matching lines @@
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 #undef CHECK_OK_VOID
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H