Add errors for declarations which conflict with catch parameters.

src/ast/scopes.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/ast/scopes.h"
 
 #include "src/accessors.h"
 #include "src/ast/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
@@ skipping 123 matching lines @@
       params_(0, zone),
       unresolved_(0, zone),
       decls_(0, zone),
       module_descriptor_(NULL),
       sloppy_block_function_map_(zone),
       already_resolved_(true),
       ast_value_factory_(value_factory),
       zone_(zone) {
   SetDefaults(CATCH_SCOPE, NULL, Handle<ScopeInfo>::null());
   AddInnerScope(inner_scope);
-  ++num_var_or_const_;
+  ++num_var_;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   Variable* variable = variables_.Declare(this,
                                           catch_variable_name,
                                           VAR,
                                           Variable::NORMAL,
                                           kCreatedInitialized);
   AllocateHeapSlot(variable);
 }
 
 
@@ skipping 23 matching lines @@
   language_mode_ =
       is_module_scope()
           ? STRICT
           : (outer_scope != NULL ? outer_scope->language_mode_ : SLOPPY);
   outer_scope_calls_sloppy_eval_ = false;
   inner_scope_calls_eval_ = false;
   scope_nonlinear_ = false;
   force_eager_compilation_ = false;
   force_context_allocation_ = (outer_scope != NULL && !is_function_scope())
       ? outer_scope->has_forced_context_allocation() : false;
-  num_var_or_const_ = 0;
+  num_var_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
   num_global_slots_ = 0;
   arity_ = 0;
   has_simple_parameters_ = true;
   rest_parameter_ = NULL;
   rest_index_ = -1;
   scope_info_ = scope_info;
   start_position_ = kNoSourcePosition;
   end_position_ = kNoSourcePosition;
@@ skipping 133 matching lines @@
     }
   }
 }
 
 
 Scope* Scope::FinalizeBlockScope() {
   DCHECK(is_block_scope());
   DCHECK(temps_.is_empty());
   DCHECK(params_.is_empty());
 
-  if (num_var_or_const() > 0 ||
-      (is_declaration_scope() && calls_sloppy_eval())) {
+  if (num_var() > 0 || (is_declaration_scope() && calls_sloppy_eval())) {
     return this;
   }
 
   // Remove this scope from outer scope.
   outer_scope()->RemoveInnerScope(this);
 
   // Reparent inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
     outer_scope()->AddInnerScope(inner_scopes_[i]);
   }
@@ skipping 151 matching lines @@
 }
 
 Variable* Scope::DeclareLocal(const AstRawString* name, VariableMode mode,
                               InitializationFlag init_flag, Variable::Kind kind,
                               MaybeAssignedFlag maybe_assigned_flag) {
   DCHECK(!already_resolved());
   // This function handles VAR, LET, and CONST modes.  DYNAMIC variables are
   // introduced during variable allocation, and TEMPORARY variables are
   // allocated via NewTemporary().
   DCHECK(IsDeclaredVariableMode(mode));
-  ++num_var_or_const_;
+  ++num_var_;
   return variables_.Declare(this, name, mode, kind, init_flag,
                             maybe_assigned_flag);
 }
 
 
 Variable* Scope::DeclareDynamicGlobal(const AstRawString* name) {
   DCHECK(is_script_scope());
   return variables_.Declare(this,
                             name,
                             DYNAMIC_GLOBAL,
@@ skipping 78 matching lines @@
       if (other_var != NULL && IsLexicalVariableMode(other_var->mode())) {
         return decl;
       }
       previous = current;
       current = current->outer_scope_;
     } while (!previous->is_declaration_scope());
   }
   return NULL;
 }
 
+Declaration* Scope::CheckLexDeclarationsConflictingWith(

[adamk, 2016/07/01 19:14:03]

Is this only called on block scopes? Can you add a DCHECK to that effect if it's
true?

+    ZoneList<const AstRawString*>* names) {
+  int length = names->length();

[adamk, 2016/07/01 19:14:04]

Nit: should be no need to hoist this.

+  for (int i = 0; i < length; ++i) {
+    Variable* var = LookupLocal(names->at(i));
+    if (var != nullptr && IsLexicalVariableMode(var->mode())) {

[adamk, 2016/07/01 19:14:03]

If my DCHECK suggestion above is correct, then can IsLexicalVariableMode ever be
false here?

+      // Conflict; find and return its declaration.
+      const AstRawString* name = names->at(i);
+      int decls_length = decls_.length();

[adamk, 2016/07/01 19:14:04]

Again, no need to hoist this out of the loop.

+      for (int j = 0; j < decls_length; ++j) {
+        if (decls_[j]->proxy()->raw_name() == name) {
+          return decls_[j];
+        }
+      }
+      DCHECK(false);
+    }
+  }
+  return nullptr;
+}
 
 class VarAndOrder {
  public:
   VarAndOrder(Variable* var, int order) : var_(var), order_(order) { }
   Variable* var() const { return var_; }
   int order() const { return order_; }
   static int Compare(const VarAndOrder* a, const VarAndOrder* b) {
     return a->order_ - b->order_;
   }
 
@@ skipping 893 matching lines @@
       function_ != NULL && function_->proxy()->var()->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8