Do not permit binding over catch parameters in for-of

src/parser.cc

 // 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.
 
 #include "src/parser.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 3599 matching lines @@
             // TODO(caitp): This should be an error in sloppy mode too.
             ReportMessageAt(parsing_result.first_initializer_loc,
                             MessageTemplate::kForInLoopInitializer);
           }
           *ok = false;
           return nullptr;
         }
 
         DCHECK(parsing_result.declarations.length() == 1);
         Block* init_block = nullptr;
+        const AstRawString* name = parsing_result.SingleName();
 
         // special case for legacy for (var/const x =.... in)
         if (!IsLexicalVariableMode(parsing_result.descriptor.mode) &&
             parsing_result.declarations[0].initializer != nullptr) {
           VariableProxy* single_var = scope_->NewUnresolved(
-              factory(), parsing_result.SingleName(), Variable::NORMAL,
-              each_beg_pos, each_end_pos);
+              factory(), name, Variable::NORMAL, each_beg_pos, each_end_pos);
           init_block = factory()->NewBlock(
               nullptr, 2, true, parsing_result.descriptor.declaration_pos);
           init_block->AddStatement(
               factory()->NewExpressionStatement(
                   factory()->NewAssignment(
                       Token::ASSIGN, single_var,
                       parsing_result.declarations[0].initializer,
                       RelocInfo::kNoPosition),
                   RelocInfo::kNoPosition),
               zone());
         }
 
+        // For some reason, we can't bind over catch parameters in for-of.
+        if (mode == ForEachStatement::ITERATE &&
+            IsDeclaredAsCatchParameter(scope_, name)) {
+          ParserTraits::ReportMessageAt(parsing_result.first_initializer_loc,
+                                        MessageTemplate::kVarRedeclaration,
+                                        name);
+          *ok = false;
+          return nullptr;
+        }
+
         // Rewrite a for-in/of statement of the form
         //
         //   for (let/const/var x in/of e) b
         //
         // into
         //
         //   {
         //     <let x' be a temporary variable>
         //     for (x' in/of e) {
         //       let/const/var x;
@@ skipping 1160 matching lines @@
     int position = decl->proxy()->position();
     Scanner::Location location = position == RelocInfo::kNoPosition
         ? Scanner::Location::invalid()
         : Scanner::Location(position, position + 1);
     ParserTraits::ReportMessageAt(location, MessageTemplate::kVarRedeclaration,
                                   name);
     *ok = false;
   }
 }
 
+bool Parser::IsDeclaredAsCatchParameter(Scope* scope,
+                                        const AstRawString* name) {
+  for (; scope != NULL; scope = scope->outer_scope())
+    if (scope->is_catch_scope() && scope->LookupLocal(name)) return true;
+  return false;
+}
+
 
 // ----------------------------------------------------------------------------
 // Parser support
 
 bool Parser::TargetStackContainsLabel(const AstRawString* label) {
   for (Target* t = target_stack_; t != NULL; t = t->previous()) {
     if (ContainsLabel(t->statement()->labels(), label)) return true;
   }
   return false;
 }
@@ skipping 1292 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args, pos);
 }
 }  // namespace internal
 }  // namespace v8