[runtime] Support Proxy setPrototypeOf trap

src/ast/scopes.h

 // 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.
 
 #ifndef V8_AST_SCOPES_H_
 #define V8_AST_SCOPES_H_
 
 #include "src/ast/ast.h"
 #include "src/pending-compilation-error-handler.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 class ParseInfo;
 
 // A hash map to support fast variable declaration and lookup.
-class VariableMap: public ZoneHashMap {
+class VariableMap : public ZoneHashMap {
  public:
   explicit VariableMap(Zone* zone);
 
   virtual ~VariableMap();
 
   Variable* Declare(Scope* scope, const AstRawString* name, VariableMode mode,
                     Variable::Kind kind, InitializationFlag initialization_flag,
                     MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
                     int declaration_group_start = -1);
 
   Variable* Lookup(const AstRawString* name);
 
   Zone* zone() const { return zone_; }
 
  private:
   Zone* zone_;
 };
 
 
 // The dynamic scope part holds hash maps for the variables that will
 // be looked up dynamically from within eval and with scopes. The objects
 // are allocated on-demand from Scope::NonLocal to avoid wasting memory
 // and setup time for scopes that don't need them.
 class DynamicScopePart : public ZoneObject {
  public:
   explicit DynamicScopePart(Zone* zone) {
     for (int i = 0; i < 3; i++)
-      maps_[i] = new(zone->New(sizeof(VariableMap))) VariableMap(zone);
+      maps_[i] = new (zone->New(sizeof(VariableMap))) VariableMap(zone);
   }
 
   VariableMap* GetMap(VariableMode mode) {
     int index = mode - DYNAMIC;
     DCHECK(index >= 0 && index < 3);
     return maps_[index];
   }
 
  private:
-  VariableMap *maps_[3];
+  VariableMap* maps_[3];
 };
 
 
 // Sloppy block-scoped function declarations to var-bind
 class SloppyBlockFunctionMap : public ZoneHashMap {
  public:
   explicit SloppyBlockFunctionMap(Zone* zone);
 
   virtual ~SloppyBlockFunctionMap();
 
   void Declare(const AstRawString* name,
                SloppyBlockFunctionStatement* statement);
 
   typedef ZoneVector<SloppyBlockFunctionStatement*> Vector;
 
  private:
   Zone* zone_;
 };
 
 
 // Global invariants after AST construction: Each reference (i.e. identifier)
 // to a JavaScript variable (including global properties) is represented by a
 // VariableProxy node. Immediately after AST construction and before variable
 // allocation, most VariableProxy nodes are "unresolved", i.e. not bound to a
 // corresponding variable (though some are bound during parse time). Variable
 // allocation binds each unresolved VariableProxy to one Variable and assigns
 // a location. Note that many VariableProxy nodes may refer to the same Java-
 // Script variable.
 
-class Scope: public ZoneObject {
+class Scope : public ZoneObject {
  public:
   // ---------------------------------------------------------------------------
   // Construction
 
   Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type,
         AstValueFactory* value_factory,
         FunctionKind function_kind = kNormalFunction);
 
   // Compute top scope and allocate variables. For lazy compilation the top
   // scope only contains the single lazily compiled function, so this
@@ skipping 50 matching lines @@
     DCHECK(is_function_scope());
     // Handle implicit declaration of the function name in named function
     // expressions before other declarations.
     decls_.InsertAt(0, declaration, zone());
     function_ = declaration;
   }
 
   // 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.
-  Variable* DeclareParameter(
-      const AstRawString* name, VariableMode mode,
-      bool is_optional, bool is_rest, bool* is_duplicate);
+  Variable* DeclareParameter(const AstRawString* name, VariableMode mode,
+                             bool is_optional, bool is_rest,
+                             bool* is_duplicate);
 
   // Declare a local variable in this scope. If the variable has been
   // declared before, the previously declared variable is returned.
   Variable* DeclareLocal(const AstRawString* name, VariableMode mode,
                          InitializationFlag init_flag, Variable::Kind kind,
                          MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
                          int declaration_group_start = -1);
 
   // Declare an implicit global variable in this scope which must be a
   // script scope.  The variable was introduced (possibly from an inner
@@ skipping 122 matching lines @@
   //   end position: end position of last token of 'stmt'
   // * For the scope of a switch statement
   //     switch (tag) { cases }
   //   start position: start position of '{'
   //   end position: end position of '}'
   int start_position() const { return start_position_; }
   void set_start_position(int statement_pos) {
     start_position_ = statement_pos;
   }
   int end_position() const { return end_position_; }
-  void set_end_position(int statement_pos) {
-    end_position_ = statement_pos;
-  }
+  void set_end_position(int statement_pos) { end_position_ = statement_pos; }
 
   // In some cases we want to force context allocation for a whole scope.
   void ForceContextAllocation() {
     DCHECK(!already_resolved());
     force_context_allocation_ = true;
   }
   bool has_forced_context_allocation() const {
     return force_context_allocation_;
   }
 
@@ skipping 105 matching lines @@
 
   int num_parameters() const { return params_.length(); }
 
   // A function can have at most one rest parameter. Returns Variable* or NULL.
   Variable* rest_parameter(int* index) const {
     *index = rest_index_;
     if (rest_index_ < 0) return NULL;
     return rest_parameter_;
   }
 
-  bool has_rest_parameter() const {
-    return rest_index_ >= 0;
-  }
+  bool has_rest_parameter() const { return rest_index_ >= 0; }
 
-  bool has_simple_parameters() const {
-    return has_simple_parameters_;
-  }
+  bool has_simple_parameters() const { return has_simple_parameters_; }
 
   // TODO(caitp): manage this state in a better way. PreParser must be able to
   // communicate that the scope is non-simple, without allocating any parameters
   // as the Parser does. This is necessary to ensure that TC39's proposed early
   // error can be reported consistently regardless of whether lazily parsed or
   // not.
   void SetHasNonSimpleParameters() {
     DCHECK(is_function_scope());
     has_simple_parameters_ = false;
   }
@@ skipping 63 matching lines @@
   int ContextLocalCount() const;
   int ContextGlobalCount() const;
 
   // For script scopes, the number of module literals (including nested ones).
   int num_modules() const { return num_modules_; }
 
   // For module scopes, the host scope's internal variable binding this module.
   Variable* module_var() const { return module_var_; }
 
   // Make sure this scope and all outer scopes are eagerly compiled.
-  void ForceEagerCompilation()  { force_eager_compilation_ = true; }
+  void ForceEagerCompilation() { force_eager_compilation_ = true; }
 
   // Determine if we can parse a function literal in this scope lazily.
   bool AllowsLazyParsing() const;
 
   // Determine if we can use lazy compilation for this scope.
   bool AllowsLazyCompilation() const;
 
   // Determine if we can use lazy compilation for this scope without a context.
   bool AllowsLazyCompilationWithoutContext() const;
 
@@ skipping 51 matching lines @@
 
   SloppyBlockFunctionMap* sloppy_block_function_map() {
     return &sloppy_block_function_map_;
   }
 
   // Error handling.
   void ReportMessage(int start_position, int end_position,
                      MessageTemplate::Template message,
                      const AstRawString* arg);
 
-  // ---------------------------------------------------------------------------
-  // Debugging.
+// ---------------------------------------------------------------------------
+// Debugging.
 
 #ifdef DEBUG
   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  private:
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
@@ skipping 239 matching lines @@
 
   // For tracking which classes are declared consecutively. Needed for strong
   // mode.
   int class_declaration_group_start_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_