[ast][parser] Remove redundant Declaration::mode_.

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 325 matching lines @@
     AstNodeFactory factory(ast_value_factory);
     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 = new (zone())
           Variable(this, name, mode, Variable::NORMAL, kCreatedInitialized);
       VariableProxy* proxy = factory.NewVariableProxy(result);
       VariableDeclaration* declaration =
-          factory.NewVariableDeclaration(proxy, mode, this, kNoSourcePosition);
+          factory.NewVariableDeclaration(proxy, this, kNoSourcePosition);
       AsDeclarationScope()->DeclareFunctionVar(declaration);
       result->AllocateTo(VariableLocation::CONTEXT, index);
     }
   }
 
   scope_info_ = Handle<ScopeInfo>::null();
 }
 
 DeclarationScope* Scope::AsDeclarationScope() {
   DCHECK(is_declaration_scope());
@@ skipping 247 matching lines @@
   } else if (!scope_info_.is_null()) {
     // If we are backed by a scope info, try to lookup the variable there.
     VariableMode mode;
     int index = scope_info_->FunctionContextSlotIndex(*(name->string()), &mode);
     if (index < 0) return NULL;
     Variable* var = new (zone())
         Variable(this, name, mode, Variable::NORMAL, kCreatedInitialized);
     DCHECK_NOT_NULL(factory);
     VariableProxy* proxy = factory->NewVariableProxy(var);
     VariableDeclaration* declaration =
-        factory->NewVariableDeclaration(proxy, mode, this, kNoSourcePosition);
+        factory->NewVariableDeclaration(proxy, this, kNoSourcePosition);
     DCHECK_EQ(factory->zone(), zone());
     DeclareFunctionVar(declaration);
     var->AllocateTo(VariableLocation::CONTEXT, index);
     return var;
   } else {
     return NULL;
   }
 }
 
 
@@ skipping 112 matching lines @@
 void Scope::AddDeclaration(Declaration* declaration) {
   DCHECK(!already_resolved());
   decls_.Add(declaration, zone());
 }
 
 
 Declaration* Scope::CheckConflictingVarDeclarations() {
   int length = decls_.length();
   for (int i = 0; i < length; i++) {
     Declaration* decl = decls_[i];
+    VariableMode mode = decl->proxy()->var()->mode();
     // We don't create a separate scope to hold the function name of a function
     // expression, so we have to make sure not to consider it when checking for
     // conflicts (since it's conceptually "outside" the declaration scope).
     if (is_function_scope() && decl == AsDeclarationScope()->function())
       continue;
-    if (IsLexicalVariableMode(decl->mode()) && !is_block_scope()) continue;
-    const AstRawString* name = decl->proxy()->raw_name();
+    if (IsLexicalVariableMode(mode) && !is_block_scope()) continue;
 
     // Iterate through all scopes until and including the declaration scope.
     Scope* previous = NULL;
     Scope* current = decl->scope();
     // Lexical vs lexical conflicts within the same scope have already been
     // captured in Parser::Declare. The only conflicts we still need to check
     // are lexical vs VAR, or any declarations within a declaration block scope
     // vs lexical declarations in its surrounding (function) scope.
-    if (IsLexicalVariableMode(decl->mode())) current = current->outer_scope_;
+    if (IsLexicalVariableMode(mode)) current = current->outer_scope_;
     do {
       // There is a conflict if there exists a non-VAR binding.
-      Variable* other_var = current->variables_.Lookup(name);
+      Variable* other_var =
+          current->variables_.Lookup(decl->proxy()->raw_name());
       if (other_var != NULL && IsLexicalVariableMode(other_var->mode())) {
         return decl;
       }
       previous = current;
       current = current->outer_scope_;
     } while (!previous->is_declaration_scope());
   }
   return NULL;
 }
 
@@ skipping 1002 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