Simplify the Scope API.

src/scopes.h

-// Copyright 2010 the V8 project authors. All rights reserved.
+// Copyright 2011 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
 //       with the distribution.
@@ skipping 76 matching lines @@
  public:
   // ---------------------------------------------------------------------------
   // Construction
 
   enum Type {
     EVAL_SCOPE,     // the top-level scope for an 'eval' source
     FUNCTION_SCOPE,  // the top-level scope for a function
     GLOBAL_SCOPE    // the top-level scope for a program or a top-level eval
   };
 
-  enum LocalType {
-    PARAMETER,
-    VAR_OR_CONST
-  };
-
   Scope(Scope* outer_scope, Type type);
 
   virtual ~Scope() { }
 
   // Compute top scope and allocate variables. For lazy compilation the top
   // scope only contains the single lazily compiled function, so this
   // doesn't re-allocate variables repeatedly.
   static bool Analyze(CompilationInfo* info);
 
   static Scope* DeserializeScopeChain(CompilationInfo* info,
@@ skipping 17 matching lines @@
 
   // Lookup a variable in this scope or outer scopes.
   // Returns the variable or NULL if not found.
   virtual Variable* Lookup(Handle<String> name);
 
   // Declare the function variable for a function literal. This variable
   // is in an intermediate scope between this function scope and the the
   // outer scope. Only possible for function scopes; at most one variable.
   Variable* DeclareFunctionVar(Handle<String> name);
 
+  // Declare a parameter in this scope.  When there are duplicated
+  // parameters the rightmost one 'wins'.  However, the implementation
+  // expects all parameters to be declared and from left to right.
+  void DeclareParameter(Handle<String> name);
+
   // Declare a local variable in this scope. If the variable has been
   // declared before, the previously declared variable is returned.
-  virtual Variable* DeclareLocal(Handle<String> name,
-                                 Variable::Mode mode,
-                                 LocalType type);
+  Variable* DeclareLocal(Handle<String> name, Variable::Mode mode);
 
   // Declare an implicit global variable in this scope which must be a
   // global scope.  The variable was introduced (possibly from an inner
   // scope) by a reference to an unresolved variable with no intervening
   // with statements or eval calls.
   Variable* DeclareGlobal(Handle<String> name);
 
-  // Add a parameter to the parameter list. The parameter must have been
-  // declared via Declare. The same parameter may occur more than once in
-  // the parameter list; they must be added in source order, from left to
-  // right.
-  void AddParameter(Variable* var);
-
   // Create a new unresolved variable.
   virtual VariableProxy* NewUnresolved(Handle<String> name,
                                        bool inside_with,
                                        int position = RelocInfo::kNoPosition);
 
   // Remove a unresolved variable. During parsing, an unresolved variable
   // may have been added optimistically, but then only the variable name
   // was used (typically for labels). If the variable was not declared, the
   // addition introduced a new unresolved variable which may end up being
   // allocated globally as a "ghost" variable. RemoveUnresolved removes
@@ skipping 330 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_