[strong] Deprecate for-in

src/preparser.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.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 697 matching lines @@
 
   Expect(Token::WHILE, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   ParseSubStatement(ok);
   return Statement::Default();
 }
 
 
-bool PreParser::CheckInOrOf(bool accept_OF) {
-  if (Check(Token::IN) ||
-      (accept_OF && CheckContextualKeyword(CStrVector("of")))) {
+bool PreParser::CheckInOrOf(bool accept_OF, bool* ok) {
+  if (Check(Token::IN)) {
+    if (is_strong(language_mode())) {
+      ReportMessageAt(scanner()->location(), "strong_for_in");
+      *ok = false;
+    }
+    return true;
+  } else if (accept_OF && CheckContextualKeyword(CStrVector("of"))) {
     return true;
   }
   return false;
 }
 
 
 PreParser::Statement PreParser::ParseForStatement(bool* ok) {
   // ForStatement ::
   //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
 
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   bool is_let_identifier_expression = false;
   if (peek() != Token::SEMICOLON) {
     if (peek() == Token::VAR || peek() == Token::CONST ||
         (peek() == Token::LET && is_strict(language_mode()))) {
       bool is_lexical = peek() == Token::LET ||
                         (peek() == Token::CONST && is_strict(language_mode()));
       int decl_count;
       VariableDeclarationProperties decl_props = kHasNoInitializers;
       ParseVariableDeclarations(
           kForStatement, &decl_props, &decl_count, CHECK_OK);
       bool has_initializers = decl_props == kHasInitializers;
       bool accept_IN = decl_count == 1 && !(is_lexical && has_initializers);
       bool accept_OF = !has_initializers;
-      if (accept_IN && CheckInOrOf(accept_OF)) {
-        ParseExpression(true, CHECK_OK);
-        Expect(Token::RPAREN, CHECK_OK);
-
-        ParseSubStatement(CHECK_OK);
+      if (accept_IN && CheckInOrOf(accept_OF, ok)) {
+        if (*ok) {

[marja, 2015/02/19 12:34:22]

Nit: I'd write this the same style as Parser, so,

if (!*ok) early return_;
go_on();

... just to keep the logic as unified as possible. It's just a tiny thing but
Parser / PreParser are full of these unnecessary "let's inverse the condition
and write the blocks in a different order" things which accumulate and make the
eventual unification more tedious.

[rossberg, 2015/02/19 13:23:05]

Done.

+          ParseExpression(true, CHECK_OK);
+          Expect(Token::RPAREN, CHECK_OK);
+          ParseSubStatement(CHECK_OK);
+        }
         return Statement::Default();
       }
     } else {
       Expression lhs = ParseExpression(false, CHECK_OK);
       is_let_identifier_expression =
           lhs.IsIdentifier() && lhs.AsIdentifier().IsLet();
-      if (CheckInOrOf(lhs.IsIdentifier())) {
-        ParseExpression(true, CHECK_OK);
-        Expect(Token::RPAREN, CHECK_OK);
-
-        ParseSubStatement(CHECK_OK);
+      if (CheckInOrOf(lhs.IsIdentifier(), ok)) {
+        if (*ok) {
+          ParseExpression(true, CHECK_OK);
+          Expect(Token::RPAREN, CHECK_OK);
+          ParseSubStatement(CHECK_OK);
+        }
         return Statement::Default();
       }
     }
   }
 
   // Parsed initializer at this point.
   // Detect attempts at 'let' declarations in sloppy mode.
   if (peek() == Token::IDENTIFIER && is_sloppy(language_mode()) &&
       is_let_identifier_expression) {
     ReportMessage("sloppy_lexical", NULL);
@@ skipping 267 matching lines @@
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal