Force context allocation for variables in generator scopes.

src/scopes.h

 // Copyright 2012 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 251 matching lines @@
   //   end position: end position of last token of 'stmt'
   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;
   }
 
+  // In some cases we want to force context allocation for a whole scope.  For
+  // example in generators, allocating variables in contexts minimizes the work

[Michael Starzinger, 2013/04/05 11:38:42]

Can we move the second sentence of this comment to parser.cc where the context
allocation for generators is forced? Also I would rephrase it to "For now
generators ..." because we might want to change that in the (distant) future
when we add Crankshaft support for generators.

[wingo, 2013/04/05 12:25:06]

Done.

+  // to suspend and resume.
+  void ForceContextAllocation() {
+    ASSERT(!already_resolved());
+    force_context_allocation_ = true;
+  }
+  bool has_forced_context_allocation() const {
+    return force_context_allocation_;
+  }
+
   // ---------------------------------------------------------------------------
   // Predicates.
 
   // Specific scope types.
   bool is_eval_scope() const { return type_ == EVAL_SCOPE; }
   bool is_function_scope() const { return type_ == FUNCTION_SCOPE; }
   bool is_module_scope() const { return type_ == MODULE_SCOPE; }
   bool is_global_scope() const { return type_ == GLOBAL_SCOPE; }
   bool is_catch_scope() const { return type_ == CATCH_SCOPE; }
   bool is_block_scope() const { return type_ == BLOCK_SCOPE; }
@@ skipping 205 matching lines @@
   // The language mode of this scope.
   LanguageMode language_mode_;
   // Source positions.
   int start_position_;
   int end_position_;
 
   // Computed via PropagateScopeInfo.
   bool outer_scope_calls_non_strict_eval_;
   bool inner_scope_calls_eval_;
   bool force_eager_compilation_;
+  bool force_context_allocation_;
 
   // True if it doesn't need scope resolution (e.g., if the scope was
   // constructed based on a serialized scope info or a catch context).
   bool already_resolved_;
 
   // Computed as variables are declared.
   int num_var_or_const_;
 
   // Computed via AllocateVariables; function, block and catch scopes only.
   int num_stack_slots_;
@@ skipping 121 matching lines @@
   void SetDefaults(ScopeType type,
                    Scope* outer_scope,
                    Handle<ScopeInfo> scope_info);
 
   Zone* zone_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_