[es6] parse arrow ConciseBody with accept_IN flag

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3709 matching lines @@
     "(c, a.b) => {}",
     "(a['b'], c) => {}",
     "(c, a['b']) => {}",
     NULL
   };
 
   // The test is quite slow, so run it with a reduced set of flags.
   static const ParserFlag flags[] = {kAllowLazy};
   RunParserSyncTest(context_data, statement_data, kError, flags,
                     arraysize(flags));
+
+  // In a context where a concise arrow body is parsed with [~In] variant,
+  // ensure that an error is reported in both full parser and preparser.
+  const char* loop_context_data[][2] = {{"for (", "; 0;);"},
+                                        {nullptr, nullptr}};
+  const char* loop_expr_data[] = {"f => 'key' in {}", nullptr};
+  RunParserSyncTest(loop_context_data, loop_expr_data, kError, flags,
+                    arraysize(flags));
 }
 
 
 TEST(NoErrorsArrowFunctions) {
   // Tests that parser and preparser accept valid arrow functions syntax.
   const char* context_data[][2] = {
     {"", ";"},
     {"bar ? (", ") : baz;"},
     {"bar ? baz : (", ");"},
     {"bar, ", ";"},
@@ skipping 54 matching lines @@
     "({a = 42}) => {}",
     "([x = 0]) => {}",
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowHarmonyDefaultParameters,
                                             kAllowHarmonyRestParameters,
                                             kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
+
+  static const ParserFlag flags[] = {kAllowLazy};
+  // In a context where a concise arrow body is parsed with [~In] variant,
+  // ensure that nested expressions can still use the 'in' operator,
+  const char* loop_context_data[][2] = {{"for (", "; 0;);"},
+                                        {nullptr, nullptr}};
+  const char* loop_expr_data[] = {"f => ('key' in {})", nullptr};
+  RunParserSyncTest(loop_context_data, loop_expr_data, kSuccess, flags,
+                    arraysize(flags));
 }
 
 
 TEST(ArrowFunctionsSloppyParameterNames) {
   const char* strong_context_data[][2] = {
     {"'use strong'; ", ";"},
     {"'use strong'; bar ? (", ") : baz;"},
     {"'use strong'; bar ? baz : (", ");"},
     {"'use strong'; bar, ", ";"},
     {"'use strong'; ", ", bar;"},
@@ skipping 3420 matching lines @@
     NULL
   };
   // clang-format on
 
   static const ParserFlag fail_flags[] = {
       kAllowHarmonySloppy, kAllowHarmonySloppyLet, kNoLegacyConst,
       kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, fail_data, kError, NULL, 0, fail_flags,
                     arraysize(fail_flags));
 }