Remove arguments shadow from scopes, stop rewriting parameters.

arguments/src/scopes.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 236 matching lines @@
     ASSERT(is_function_scope());
     return params_[index];
   }
 
   int num_parameters() const { return params_.length(); }
 
   // The local variable 'arguments' if we need to allocate it; NULL otherwise.
   // If arguments() exist, arguments_shadow() exists, too.
   Variable* arguments() const { return arguments_; }
 
-  // The '.arguments' shadow variable if we need to allocate it; NULL otherwise.
-  // If arguments_shadow() exist, arguments() exists, too.
-  Variable* arguments_shadow() const { return arguments_shadow_; }
-
   // Declarations list.
   ZoneList<Declaration*>* declarations() { return &decls_; }
 
 
 
   // ---------------------------------------------------------------------------
   // Variable allocation.
 
   // Collect all used locals in this scope.
   template<class Allocator>
@@ skipping 75 matching lines @@
   // Unresolved variables referred to from this scope.
   ZoneList<VariableProxy*> unresolved_;
   // Declarations.
   ZoneList<Declaration*> decls_;
   // Convenience variable.
   Variable* receiver_;
   // Function variable, if any; function scopes only.
   Variable* function_;
   // Convenience variable; function scopes only.
   Variable* arguments_;
-  // Convenience variable; function scopes only.
-  Variable* arguments_shadow_;
 
   // Illegal redeclaration.
   Expression* illegal_redecl_;
 
   // Scope-specific information.
   bool scope_inside_with_;  // this scope is inside a 'with' of some outer scope
   bool scope_contains_with_;  // this scope contains a 'with' statement
   bool scope_calls_eval_;  // this scope contains an 'eval' call
   bool strict_mode_;  // this scope is a strict mode scope
 
@@ skipping 56 matching lines @@
   void SetDefaults(Type type,
                    Scope* outer_scope,
                    SerializedScopeInfo* scope_info) {
     outer_scope_ = outer_scope;
     type_ = type;
     scope_name_ = Factory::empty_symbol();
     dynamics_ = NULL;
     receiver_ = NULL;
     function_ = NULL;
     arguments_ = NULL;
-    arguments_shadow_ = NULL;
     illegal_redecl_ = NULL;
     scope_inside_with_ = false;
     scope_contains_with_ = false;
     scope_calls_eval_ = false;
     // Inherit the strict mode from the parent scope.
     strict_mode_ = (outer_scope != NULL) && outer_scope->strict_mode_;
     outer_scope_calls_eval_ = false;
     inner_scope_calls_eval_ = false;
     outer_scope_is_eval_scope_ = false;
     force_eager_compilation_ = false;
@@ skipping 50 matching lines @@
   int nesting_level_;
   // Nesting level of outermost scope that is contained in a with statement,
   // or kNotInsideWith if there are no with's around the current scope.
   int inside_with_level_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_