Parameters are always context-allocated if accessible, so drop additional parameter lookup

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 <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 322 matching lines @@
   script_scope->PropagateScopeInfo();
   return innermost_scope;
 }
 
 void Scope::DeserializeScopeInfo(Isolate* isolate,
                                  AstValueFactory* ast_value_factory) {
   if (scope_info_.is_null()) return;
 
   DCHECK(ThreadId::Current().Equals(isolate->thread_id()));
 
-  std::set<const AstRawString*> names_seen;
   // Internalize context local & globals variables.
   for (int var = 0; var < scope_info_->ContextLocalCount() +
                               scope_info_->ContextGlobalCount();
        ++var) {
     Handle<String> name_handle(scope_info_->ContextLocalName(var), isolate);
     const AstRawString* name = ast_value_factory->GetString(name_handle);
-    if (!names_seen.insert(name).second) continue;
     int index = Context::MIN_CONTEXT_SLOTS + var;
     VariableMode mode = scope_info_->ContextLocalMode(var);
     InitializationFlag init_flag = scope_info_->ContextLocalInitFlag(var);
     MaybeAssignedFlag maybe_assigned_flag =
         scope_info_->ContextLocalMaybeAssignedFlag(var);
     VariableLocation location = var < scope_info_->ContextLocalCount()
                                     ? VariableLocation::CONTEXT
                                     : VariableLocation::GLOBAL;
     Variable::Kind kind = Variable::NORMAL;
     if (index == scope_info_->ReceiverContextSlotIndex()) {
       kind = Variable::THIS;
     }
 
     Variable* result = variables_.Declare(zone(), this, name, mode, kind,
                                           init_flag, maybe_assigned_flag);
     result->AllocateTo(location, index);
   }
 
-  // We must read parameters from the end since for multiply declared
-  // parameters the value of the last declaration of that parameter is used
-  // inside a function (and thus we need to look at the last index). Was bug#
-  // 1110337.
-  for (int index = scope_info_->ParameterCount() - 1; index >= 0; --index) {
-    Handle<String> name_handle(scope_info_->ParameterName(index), isolate);
-    const AstRawString* name = ast_value_factory->GetString(name_handle);
-    if (!names_seen.insert(name).second) continue;
-
-    VariableMode mode = DYNAMIC;
-    InitializationFlag init_flag = kCreatedInitialized;
-    MaybeAssignedFlag maybe_assigned_flag = kMaybeAssigned;
-    VariableLocation location = VariableLocation::LOOKUP;
-    Variable::Kind kind = Variable::NORMAL;
-
-    Variable* result = variables_.Declare(zone(), this, name, mode, kind,
-                                          init_flag, maybe_assigned_flag);
-    result->AllocateTo(location, index);
-  }
-
   // Internalize function proxy for this scope.
   if (scope_info_->HasFunctionName()) {
     Handle<String> name_handle(scope_info_->FunctionName(), isolate);
     const AstRawString* name = ast_value_factory->GetString(name_handle);
     VariableMode mode;
     int index = scope_info_->FunctionContextSlotIndex(*name_handle, &mode);
     if (index >= 0) {
       Variable* result = AsDeclarationScope()->DeclareFunctionVar(name);
       DCHECK_EQ(mode, result->mode());
       result->AllocateTo(VariableLocation::CONTEXT, index);
@@ skipping 210 matching lines @@
   if (calls_eval()) other->RecordEvalCall();
 }
 
 Variable* Scope::LookupInScopeInfo(const AstRawString* name) {
   Handle<String> name_handle = name->string();
   // The Scope is backed up by ScopeInfo. This means it cannot operate in a
   // heap-independent mode, and all strings must be internalized immediately. So
   // it's ok to get the Handle<String> here.
   // If we have a serialized scope info, we might find the variable there.
   // There should be no local slot with the given name.
-  DCHECK(scope_info_->StackSlotIndex(*name_handle) < 0);
+  DCHECK_LT(scope_info_->StackSlotIndex(*name_handle), 0);
 
   VariableMode mode;
   InitializationFlag init_flag;
   MaybeAssignedFlag maybe_assigned_flag;
 
   VariableLocation location = VariableLocation::CONTEXT;
   int index = ScopeInfo::ContextSlotIndex(scope_info_, name_handle, &mode,
                                           &init_flag, &maybe_assigned_flag);
   if (index < 0) {
     location = VariableLocation::GLOBAL;
     index = ScopeInfo::ContextGlobalSlotIndex(scope_info_, name_handle, &mode,
                                               &init_flag, &maybe_assigned_flag);
     DCHECK(index < 0 || (is_script_scope() && mode == VAR));
   }
-  if (index < 0) {
-    location = VariableLocation::LOOKUP;
-    index = scope_info_->ParameterIndex(*name_handle);
-    if (index >= 0) {
-      mode = DYNAMIC;
-      init_flag = kCreatedInitialized;
-      // Be conservative and flag parameters as maybe assigned. Better
-      // information would require ScopeInfo to serialize the maybe_assigned bit
-      // also for parameters.
-      maybe_assigned_flag = kMaybeAssigned;
-    }
-  }
   if (index < 0 && scope_type() == MODULE_SCOPE) {
     location = VariableLocation::MODULE;
     index = -1;  // TODO(neis): Find module variables in scope info.
   }
   if (index < 0) return nullptr;  // Nowhere found.
 
   Variable::Kind kind = Variable::NORMAL;
   if (location == VariableLocation::CONTEXT &&
       index == scope_info_->ReceiverContextSlotIndex()) {
     kind = Variable::THIS;
@@ skipping 994 matching lines @@
       function != nullptr && function->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