Reland of Add errors for declarations which conflict with catch parameters.

src/parsing/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/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 1865 matching lines @@
 
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 VariableProxy* Parser::NewUnresolved(const AstRawString* name,
                                      VariableMode mode) {
-  // If we are inside a function, a declaration of a var/const variable is a
+  // If we are inside a function, a declaration of a 'var' variable is a
   // truly local variable, and the scope of the variable is always the function
   // scope.
-  // Let/const variables in harmony mode are always added to the immediately
-  // enclosing scope.
+  // Let/const variables are always added to the immediately enclosing scope.
   Scope* scope =
       IsLexicalVariableMode(mode) ? scope_ : scope_->DeclarationScope();
   return scope->NewUnresolved(factory(), name, Variable::NORMAL,
                               scanner()->location().beg_pos,
                               scanner()->location().end_pos);
 }
 
 
 Variable* Parser::Declare(Declaration* declaration,
                           DeclarationDescriptor::Kind declaration_kind,
@@ skipping 397 matching lines @@
   return result;
 }
 
 
 Block* Parser::ParseVariableStatement(VariableDeclarationContext var_context,
                                       ZoneList<const AstRawString*>* names,
                                       bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
-  // The scope of a var/const declared variable anywhere inside a function
+  // The scope of a var declared variable anywhere inside a function
   // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). Thus we can
-  // transform a source-level var/const declaration into a (Function)
-  // Scope declaration, and rewrite the source-level initialization into an
-  // assignment statement. We use a block to collect multiple assignments.
+  // transform a source-level var declaration into a (Function) Scope
+  // declaration, and rewrite the source-level initialization into an assignment
+  // statement. We use a block to collect multiple assignments.
   //
   // We mark the block as initializer block because we don't want the
   // rewriter to add a '.result' assignment to such a block (to get compliant
   // behavior for code such as print(eval('var x = 7')), and for cosmetic
   // reasons when pretty-printing. Also, unless an assignment (initialization)
   // is inside an initializer block, it is ignored.
 
   DeclarationParsingResult parsing_result;
   Block* result =
       ParseVariableDeclarations(var_context, &parsing_result, names, CHECK_OK);
@@ skipping 677 matching lines @@
         if (is_simple) {
           auto proxy = pattern->AsVariableProxy();
           scope_->RemoveUnresolved(proxy);
           name = proxy->raw_name();
         }
         catch_variable = catch_scope->DeclareLocal(
             name, VAR, kCreatedInitialized, Variable::NORMAL);
 
         Expect(Token::RPAREN, CHECK_OK);
 
+        ZoneList<const AstRawString*> bound_names(1, zone());
+
         if (!is_simple) {
           DeclarationDescriptor descriptor;
           descriptor.declaration_kind = DeclarationDescriptor::NORMAL;
           descriptor.parser = this;
           descriptor.scope = scope_;
           descriptor.hoist_scope = nullptr;
           descriptor.mode = LET;
           descriptor.declaration_pos = pattern->position();
           descriptor.initialization_pos = pattern->position();
 
           DeclarationParsingResult::Declaration decl(
               pattern, pattern->position(),
               factory()->NewVariableProxy(catch_variable));
 
           Block* init_block =
               factory()->NewBlock(nullptr, 8, true, kNoSourcePosition);
           PatternRewriter::DeclareAndInitializeVariables(
-              init_block, &descriptor, &decl, nullptr, CHECK_OK);
+              init_block, &descriptor, &decl, &bound_names, CHECK_OK);
           catch_block->statements()->Add(init_block, zone());
+        } else {
+          bound_names.Add(name, zone());
         }
 
-        // TODO(adamk): This should call ParseBlock in order to properly
-        // add an additional block scope for the catch body.
-        Expect(Token::LBRACE, CHECK_OK);
-        while (peek() != Token::RBRACE) {
-          Statement* stat = ParseStatementListItem(CHECK_OK);
-          if (stat && !stat->IsEmpty()) {
-            catch_block->statements()->Add(stat, zone());
+        Block* inner_block = ParseBlock(nullptr, CHECK_OK);
+        catch_block->statements()->Add(inner_block, zone());
+
+        // Check for `catch(e) { let e; }` and similar errors.
+        Scope* inner_block_scope = inner_block->scope();
+        if (inner_block_scope != nullptr) {
+          Declaration* decl =
+              inner_block_scope->CheckLexDeclarationsConflictingWith(
+                  bound_names);
+          if (decl != nullptr) {
+            const AstRawString* name = decl->proxy()->raw_name();
+            int position = decl->proxy()->position();
+            Scanner::Location location =
+                position == kNoSourcePosition
+                    ? Scanner::Location::invalid()
+                    : Scanner::Location(position, position + 1);
+            ParserTraits::ReportMessageAt(
+                location, MessageTemplate::kVarRedeclaration, name);
+            *ok = false;
+            return nullptr;
           }
         }
-        Consume(Token::RBRACE);
       }
       block_scope->set_end_position(scanner()->location().end_pos);
       block_scope = block_scope->FinalizeBlockScope();
       catch_block->set_scope(block_scope);
     }
 
     catch_scope->set_end_position(scanner()->location().end_pos);
     tok = peek();
   }
 
@@ skipping 479 matching lines @@
     body_scope = body_scope->FinalizeBlockScope();
     block->set_scope(body_scope);
     return block;
   }
 }
 
 Statement* Parser::ParseForStatement(ZoneList<const AstRawString*>* labels,
                                      bool* ok) {
   int stmt_pos = peek_position();
   Statement* init = NULL;
-  ZoneList<const AstRawString*> lexical_bindings(1, zone());
+  ZoneList<const AstRawString*> bound_names(1, zone());
+  bool bound_names_are_lexical = false;
 
   // Create an in-between scope for let-bound iteration variables.
   Scope* for_scope = NewScope(scope_, BLOCK_SCOPE);
 
   BlockState block_state(&scope_, for_scope);
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   for_scope->set_start_position(scanner()->location().beg_pos);
   for_scope->set_is_hidden();
   DeclarationParsingResult parsing_result;
@@ skipping 30 matching lines @@
           }
           ParserTraits::ReportMessageAt(
               parsing_result.first_initializer_loc,
               MessageTemplate::kForInOfLoopInitializer,
               ForEachStatement::VisitModeString(mode));
           *ok = false;
           return nullptr;
         }
 
         Block* init_block = nullptr;
+        bound_names_are_lexical =
+            IsLexicalVariableMode(parsing_result.descriptor.mode);
 
-        // special case for legacy for (var/const x =.... in)
-        if (!IsLexicalVariableMode(parsing_result.descriptor.mode) &&
-            decl.pattern->IsVariableProxy() && decl.initializer != nullptr) {
+        // special case for legacy for (var ... = ... in ...)
+        if (!bound_names_are_lexical && decl.pattern->IsVariableProxy() &&
+            decl.initializer != nullptr) {
           DCHECK(!allow_harmony_for_in());
           ++use_counts_[v8::Isolate::kForInInitializer];
           const AstRawString* name =
               decl.pattern->AsVariableProxy()->raw_name();
           VariableProxy* single_var = scope_->NewUnresolved(
               factory(), name, Variable::NORMAL, each_beg_pos, each_end_pos);
           init_block = factory()->NewBlock(
               nullptr, 2, true, parsing_result.descriptor.declaration_pos);
           init_block->statements()->Add(
               factory()->NewExpressionStatement(
@@ skipping 52 matching lines @@
           Statement* body = ParseScopedStatement(NULL, true, CHECK_OK);
 
           auto each_initialization_block =
               factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
           {
             auto descriptor = parsing_result.descriptor;
             descriptor.declaration_pos = kNoSourcePosition;
             descriptor.initialization_pos = kNoSourcePosition;
             decl.initializer = factory()->NewVariableProxy(temp);
 
+            bool is_for_var_of =
+                mode == ForEachStatement::ITERATE &&
+                parsing_result.descriptor.mode == VariableMode::VAR;
+
             PatternRewriter::DeclareAndInitializeVariables(
                 each_initialization_block, &descriptor, &decl,
-                IsLexicalVariableMode(descriptor.mode) ? &lexical_bindings
-                                                       : nullptr,
+                bound_names_are_lexical || is_for_var_of ? &bound_names
+                                                         : nullptr,
                 CHECK_OK);
+
+            // Annex B.3.5 prohibits the form
+            // `try {} catch(e) { for (var e of {}); }`
+            // So if we are parsing a statement like `for (var ... of ...)`
+            // we need to walk up the scope chain and look for catch scopes
+            // which have a simple binding, then compare their binding against
+            // all of the names declared in the init of the for-of we're
+            // parsing.
+            if (is_for_var_of) {
+              Scope* catch_scope = scope_;
+              while (catch_scope != nullptr &&
+                     !catch_scope->is_declaration_scope()) {
+                if (catch_scope->is_catch_scope()) {
+                  auto name = catch_scope->catch_variable_name();
+                  if (name !=
+                      ast_value_factory()
+                          ->dot_catch_string()) {  // i.e. is a simple binding
+                    if (bound_names.Contains(name)) {
+                      ParserTraits::ReportMessageAt(
+                          parsing_result.bindings_loc,
+                          MessageTemplate::kVarRedeclaration, name);
+                      *ok = false;
+                      return nullptr;
+                    }
+                  }
+                }
+                catch_scope = catch_scope->outer_scope();
+              }
+            }
           }
 
           body_block->statements()->Add(each_initialization_block, zone());
           body_block->statements()->Add(body, zone());
           VariableProxy* temp_proxy =
               factory()->NewVariableProxy(temp, each_beg_pos, each_end_pos);
           InitializeForEachStatement(loop, temp_proxy, enumerable, body_block,
                                      each_keyword_position);
         }
         body_scope->set_end_position(scanner()->location().end_pos);
         body_scope = body_scope->FinalizeBlockScope();
         body_block->set_scope(body_scope);
 
         // Create a TDZ for any lexically-bound names.
-        if (IsLexicalVariableMode(parsing_result.descriptor.mode)) {
+        if (bound_names_are_lexical) {
           DCHECK_NULL(init_block);
 
           init_block =
               factory()->NewBlock(nullptr, 1, false, kNoSourcePosition);
 
-          for (int i = 0; i < lexical_bindings.length(); ++i) {
+          for (int i = 0; i < bound_names.length(); ++i) {
             // TODO(adamk): This needs to be some sort of special
             // INTERNAL variable that's invisible to the debugger
             // but visible to everything else.
-            VariableProxy* tdz_proxy =
-                NewUnresolved(lexical_bindings[i], LET);
+            VariableProxy* tdz_proxy = NewUnresolved(bound_names[i], LET);
             Declaration* tdz_decl = factory()->NewVariableDeclaration(
                 tdz_proxy, LET, scope_, kNoSourcePosition);
             Variable* tdz_var = Declare(
                 tdz_decl, DeclarationDescriptor::NORMAL, true, CHECK_OK);
             tdz_var->set_initializer_position(position());
           }
         }
 
         Statement* final_loop =
             loop->IsForOfStatement()
                 ? FinalizeForOfStatement(loop->AsForOfStatement(),
                                          kNoSourcePosition)
                 : loop;
 
         for_scope->set_end_position(scanner()->location().end_pos);
         for_scope = for_scope->FinalizeBlockScope();
         // Parsed for-in loop w/ variable declarations.
         if (init_block != nullptr) {
           init_block->statements()->Add(final_loop, zone());
           init_block->set_scope(for_scope);
           return init_block;
         } else {
           DCHECK_NULL(for_scope);
           return final_loop;
         }
       } else {
+        bound_names_are_lexical =
+            IsLexicalVariableMode(parsing_result.descriptor.mode);
         init = parsing_result.BuildInitializationBlock(
-            IsLexicalVariableMode(parsing_result.descriptor.mode)
-                ? &lexical_bindings
-                : nullptr,
-            CHECK_OK);
+            bound_names_are_lexical ? &bound_names : nullptr, CHECK_OK);
       }
     } else {
       int lhs_beg_pos = peek_position();
       ExpressionClassifier classifier(this);
       Expression* expression = ParseExpression(false, &classifier, CHECK_OK);
       int lhs_end_pos = scanner()->location().end_pos;
       ForEachStatement::VisitMode mode = ForEachStatement::ENUMERATE;
 
       bool is_for_each = CheckInOrOf(&mode, ok);
       if (!*ok) return nullptr;
@@ skipping 60 matching lines @@
   // Parsed initializer at this point.
   Expect(Token::SEMICOLON, CHECK_OK);
 
   Expression* cond = NULL;
   Statement* next = NULL;
   Statement* body = NULL;
 
   // If there are let bindings, then condition and the next statement of the
   // for loop must be parsed in a new scope.
   Scope* inner_scope = scope_;
-  if (lexical_bindings.length() > 0) {
+  if (bound_names_are_lexical && bound_names.length() > 0) {
     inner_scope = NewScope(for_scope, BLOCK_SCOPE);
     inner_scope->set_start_position(scanner()->location().beg_pos);
   }
   {
     BlockState block_state(&scope_, inner_scope);
 
     if (peek() != Token::SEMICOLON) {
       cond = ParseExpression(true, CHECK_OK);
     }
     Expect(Token::SEMICOLON, CHECK_OK);
 
     if (peek() != Token::RPAREN) {
       Expression* exp = ParseExpression(true, CHECK_OK);
       next = factory()->NewExpressionStatement(exp, exp->position());
     }
     Expect(Token::RPAREN, CHECK_OK);
 
     body = ParseScopedStatement(NULL, true, CHECK_OK);
   }
 
   Statement* result = NULL;
-  if (lexical_bindings.length() > 0) {
+  if (bound_names_are_lexical && bound_names.length() > 0) {
     BlockState block_state(&scope_, for_scope);
     result = DesugarLexicalBindingsInForStatement(
-        inner_scope, parsing_result.descriptor.mode, &lexical_bindings, loop,
-        init, cond, next, body, CHECK_OK);
+        inner_scope, parsing_result.descriptor.mode, &bound_names, loop, init,
+        cond, next, body, CHECK_OK);
     for_scope->set_end_position(scanner()->location().end_pos);
   } else {
     for_scope->set_end_position(scanner()->location().end_pos);
     for_scope = for_scope->FinalizeBlockScope();
     if (for_scope) {
       // Rewrite a for statement of the form
       //   for (const x = i; c; n) b
       //
       // into
       //
@@ skipping 3151 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8