deps/v8/src/scopes.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_SCOPES_H_
   6 #define V8_SCOPES_H_
   7
   8 #include "src/ast.h"
   9 #include "src/zone.h"
  10
  11 namespace v8 {
  12 namespace internal {
  13
  14 class CompilationInfo;
  15
  16
  17 // A hash map to support fast variable declaration and lookup.
  18 class VariableMap: public ZoneHashMap {
  19  public:
  20   explicit VariableMap(Zone* zone);
  21
  22   virtual ~VariableMap();
  23
  24   Variable* Declare(Scope* scope, const AstRawString* name, VariableMode mode,
  25                     bool is_valid_lhs, Variable::Kind kind,
  26                     InitializationFlag initialization_flag,
  27                     MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
  28                     Interface* interface = Interface::NewValue());
  29
  30   Variable* Lookup(const AstRawString* name);
  31
  32   Zone* zone() const { return zone_; }
  33
  34  private:
  35   Zone* zone_;
  36 };
  37
  38
  39 // The dynamic scope part holds hash maps for the variables that will
  40 // be looked up dynamically from within eval and with scopes. The objects
  41 // are allocated on-demand from Scope::NonLocal to avoid wasting memory
  42 // and setup time for scopes that don't need them.
  43 class DynamicScopePart : public ZoneObject {
  44  public:
  45   explicit DynamicScopePart(Zone* zone) {
  46     for (int i = 0; i < 3; i++)
  47       maps_[i] = new(zone->New(sizeof(VariableMap))) VariableMap(zone);
  48   }
  49
  50   VariableMap* GetMap(VariableMode mode) {
  51     int index = mode - DYNAMIC;
  52     DCHECK(index >= 0 && index < 3);
  53     return maps_[index];
  54   }
  55
  56  private:
  57   VariableMap *maps_[3];
  58 };
  59
  60
  61 // Global invariants after AST construction: Each reference (i.e. identifier)
  62 // to a JavaScript variable (including global properties) is represented by a
  63 // VariableProxy node. Immediately after AST construction and before variable
  64 // allocation, most VariableProxy nodes are "unresolved", i.e. not bound to a
  65 // corresponding variable (though some are bound during parse time). Variable
  66 // allocation binds each unresolved VariableProxy to one Variable and assigns
  67 // a location. Note that many VariableProxy nodes may refer to the same Java-
  68 // Script variable.
  69
  70 class Scope: public ZoneObject {
  71  public:
  72   // ---------------------------------------------------------------------------
  73   // Construction
  74
  75   Scope(Scope* outer_scope, ScopeType scope_type,
  76         AstValueFactory* value_factory, Zone* zone);
  77
  78   // Compute top scope and allocate variables. For lazy compilation the top
  79   // scope only contains the single lazily compiled function, so this
  80   // doesn't re-allocate variables repeatedly.
  81   static bool Analyze(CompilationInfo* info);
  82
  83   static Scope* DeserializeScopeChain(Context* context, Scope* script_scope,
  84                                       Zone* zone);
  85
  86   // The scope name is only used for printing/debugging.
  87   void SetScopeName(const AstRawString* scope_name) {
  88     scope_name_ = scope_name;
  89   }
  90
  91   void Initialize();
  92
  93   // Checks if the block scope is redundant, i.e. it does not contain any
  94   // block scoped declarations. In that case it is removed from the scope
  95   // tree and its children are reparented.
  96   Scope* FinalizeBlockScope();
  97
  98   Zone* zone() const { return zone_; }
  99
 100   // ---------------------------------------------------------------------------
 101   // Declarations
 102
 103   // Lookup a variable in this scope. Returns the variable or NULL if not found.
 104   Variable* LookupLocal(const AstRawString* name);
 105
 106   // This lookup corresponds to a lookup in the "intermediate" scope sitting
 107   // between this scope and the outer scope. (ECMA-262, 3rd., requires that
 108   // the name of named function literal is kept in an intermediate scope
 109   // in between this scope and the next outer scope.)
 110   Variable* LookupFunctionVar(const AstRawString* name,
 111                               AstNodeFactory* factory);
 112
 113   // Lookup a variable in this scope or outer scopes.
 114   // Returns the variable or NULL if not found.
 115   Variable* Lookup(const AstRawString* name);
 116
 117   // Declare the function variable for a function literal. This variable
 118   // is in an intermediate scope between this function scope and the the
 119   // outer scope. Only possible for function scopes; at most one variable.
 120   void DeclareFunctionVar(VariableDeclaration* declaration) {
 121     DCHECK(is_function_scope());
 122     function_ = declaration;
 123   }
 124
 125   // Declare a parameter in this scope.  When there are duplicated
 126   // parameters the rightmost one 'wins'.  However, the implementation
 127   // expects all parameters to be declared and from left to right.
 128   Variable* DeclareParameter(const AstRawString* name, VariableMode mode);
 129
 130   // Declare a local variable in this scope. If the variable has been
 131   // declared before, the previously declared variable is returned.
 132   Variable* DeclareLocal(const AstRawString* name, VariableMode mode,
 133                          InitializationFlag init_flag,
 134                          MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
 135                          Interface* interface = Interface::NewValue());
 136
 137   // Declare an implicit global variable in this scope which must be a
 138   // script scope.  The variable was introduced (possibly from an inner
 139   // scope) by a reference to an unresolved variable with no intervening
 140   // with statements or eval calls.
 141   Variable* DeclareDynamicGlobal(const AstRawString* name);
 142
 143   // Create a new unresolved variable.
 144   VariableProxy* NewUnresolved(AstNodeFactory* factory,
 145                                const AstRawString* name,
 146                                Interface* interface = Interface::NewValue(),
 147                                int position = RelocInfo::kNoPosition) {
 148     // Note that we must not share the unresolved variables with
 149     // the same name because they may be removed selectively via
 150     // RemoveUnresolved().
 151     DCHECK(!already_resolved());
 152     VariableProxy* proxy =
 153         factory->NewVariableProxy(name, false, interface, position);
 154     unresolved_.Add(proxy, zone_);
 155     return proxy;
 156   }
 157
 158   // Remove a unresolved variable. During parsing, an unresolved variable
 159   // may have been added optimistically, but then only the variable name
 160   // was used (typically for labels). If the variable was not declared, the
 161   // addition introduced a new unresolved variable which may end up being
 162   // allocated globally as a "ghost" variable. RemoveUnresolved removes
 163   // such a variable again if it was added; otherwise this is a no-op.
 164   void RemoveUnresolved(VariableProxy* var);
 165
 166   // Creates a new internal variable in this scope.  The name is only used
 167   // for printing and cannot be used to find the variable.  In particular,
 168   // the only way to get hold of the temporary is by keeping the Variable*
 169   // around.
 170   Variable* NewInternal(const AstRawString* name);
 171
 172   // Creates a new temporary variable in this scope.  The name is only used
 173   // for printing and cannot be used to find the variable.  In particular,
 174   // the only way to get hold of the temporary is by keeping the Variable*
 175   // around.  The name should not clash with a legitimate variable names.
 176   Variable* NewTemporary(const AstRawString* name);
 177
 178   // Adds the specific declaration node to the list of declarations in
 179   // this scope. The declarations are processed as part of entering
 180   // the scope; see codegen.cc:ProcessDeclarations.
 181   void AddDeclaration(Declaration* declaration);
 182
 183   // ---------------------------------------------------------------------------
 184   // Illegal redeclaration support.
 185
 186   // Set an expression node that will be executed when the scope is
 187   // entered. We only keep track of one illegal redeclaration node per
 188   // scope - the first one - so if you try to set it multiple times
 189   // the additional requests will be silently ignored.
 190   void SetIllegalRedeclaration(Expression* expression);
 191
 192   // Visit the illegal redeclaration expression. Do not call if the
 193   // scope doesn't have an illegal redeclaration node.
 194   void VisitIllegalRedeclaration(AstVisitor* visitor);
 195
 196   // Check if the scope has (at least) one illegal redeclaration.
 197   bool HasIllegalRedeclaration() const { return illegal_redecl_ != NULL; }
 198
 199   // For harmony block scoping mode: Check if the scope has conflicting var
 200   // declarations, i.e. a var declaration that has been hoisted from a nested
 201   // scope over a let binding of the same name.
 202   Declaration* CheckConflictingVarDeclarations();
 203
 204   // ---------------------------------------------------------------------------
 205   // Scope-specific info.
 206
 207   // Inform the scope that the corresponding code contains a with statement.
 208   void RecordWithStatement() { scope_contains_with_ = true; }
 209
 210   // Inform the scope that the corresponding code contains an eval call.
 211   void RecordEvalCall() { if (!is_script_scope()) scope_calls_eval_ = true; }
 212
 213   // Inform the scope that the corresponding code uses "arguments".
 214   void RecordArgumentsUsage() { scope_uses_arguments_ = true; }
 215
 216   // Inform the scope that the corresponding code uses "super".
 217   void RecordSuperPropertyUsage() { scope_uses_super_property_ = true; }
 218
 219   // Inform the scope that the corresponding code invokes "super" constructor.
 220   void RecordSuperConstructorCallUsage() {
 221     scope_uses_super_constructor_call_ = true;
 222   }
 223
 224   // Inform the scope that the corresponding code uses "this".
 225   void RecordThisUsage() { scope_uses_this_ = true; }
 226
 227   // Set the strict mode flag (unless disabled by a global flag).
 228   void SetStrictMode(StrictMode strict_mode) { strict_mode_ = strict_mode; }
 229
 230   // Set the ASM module flag.
 231   void SetAsmModule() { asm_module_ = true; }
 232
 233   // Position in the source where this scope begins and ends.
 234   //
 235   // * For the scope of a with statement
 236   //     with (obj) stmt
 237   //   start position: start position of first token of 'stmt'
 238   //   end position: end position of last token of 'stmt'
 239   // * For the scope of a block
 240   //     { stmts }
 241   //   start position: start position of '{'
 242   //   end position: end position of '}'
 243   // * For the scope of a function literal or decalaration
 244   //     function fun(a,b) { stmts }
 245   //   start position: start position of '('
 246   //   end position: end position of '}'
 247   // * For the scope of a catch block
 248   //     try { stms } catch(e) { stmts }
 249   //   start position: start position of '('
 250   //   end position: end position of ')'
 251   // * For the scope of a for-statement
 252   //     for (let x ...) stmt
 253   //   start position: start position of '('
 254   //   end position: end position of last token of 'stmt'
 255   int start_position() const { return start_position_; }
 256   void set_start_position(int statement_pos) {
 257     start_position_ = statement_pos;
 258   }
 259   int end_position() const { return end_position_; }
 260   void set_end_position(int statement_pos) {
 261     end_position_ = statement_pos;
 262   }
 263
 264   // In some cases we want to force context allocation for a whole scope.
 265   void ForceContextAllocation() {
 266     DCHECK(!already_resolved());
 267     force_context_allocation_ = true;
 268   }
 269   bool has_forced_context_allocation() const {
 270     return force_context_allocation_;
 271   }
 272
 273   // ---------------------------------------------------------------------------
 274   // Predicates.
 275
 276   // Specific scope types.
 277   bool is_eval_scope() const { return scope_type_ == EVAL_SCOPE; }
 278   bool is_function_scope() const {
 279     return scope_type_ == FUNCTION_SCOPE || scope_type_ == ARROW_SCOPE;
 280   }
 281   bool is_module_scope() const { return scope_type_ == MODULE_SCOPE; }
 282   bool is_script_scope() const { return scope_type_ == SCRIPT_SCOPE; }
 283   bool is_catch_scope() const { return scope_type_ == CATCH_SCOPE; }
 284   bool is_block_scope() const { return scope_type_ == BLOCK_SCOPE; }
 285   bool is_with_scope() const { return scope_type_ == WITH_SCOPE; }
 286   bool is_arrow_scope() const { return scope_type_ == ARROW_SCOPE; }
 287   bool is_declaration_scope() const {
 288     return is_eval_scope() || is_function_scope() ||
 289         is_module_scope() || is_script_scope();
 290   }
 291   bool is_strict_eval_scope() const {
 292     return is_eval_scope() && strict_mode_ == STRICT;
 293   }
 294
 295   // Information about which scopes calls eval.
 296   bool calls_eval() const { return scope_calls_eval_; }
 297   bool calls_sloppy_eval() {
 298     return scope_calls_eval_ && strict_mode_ == SLOPPY;
 299   }
 300   bool outer_scope_calls_sloppy_eval() const {
 301     return outer_scope_calls_sloppy_eval_;
 302   }
 303   bool asm_module() const { return asm_module_; }
 304   bool asm_function() const { return asm_function_; }
 305
 306   // Is this scope inside a with statement.
 307   bool inside_with() const { return scope_inside_with_; }
 308   // Does this scope contain a with statement.
 309   bool contains_with() const { return scope_contains_with_; }
 310
 311   // Does this scope access "arguments".
 312   bool uses_arguments() const { return scope_uses_arguments_; }
 313   // Does any inner scope access "arguments".
 314   bool inner_uses_arguments() const { return inner_scope_uses_arguments_; }
 315   // Does this scope access "super" property (super.foo).
 316   bool uses_super_property() const { return scope_uses_super_property_; }
 317   // Does any inner scope access "super" property.
 318   bool inner_uses_super_property() const {
 319     return inner_scope_uses_super_property_;
 320   }
 321   // Does this scope calls "super" constructor.
 322   bool uses_super_constructor_call() const {
 323     return scope_uses_super_constructor_call_;
 324   }
 325   // Does  any inner scope calls "super" constructor.
 326   bool inner_uses_super_constructor_call() const {
 327     return inner_scope_uses_super_constructor_call_;
 328   }
 329   // Does this scope access "this".
 330   bool uses_this() const { return scope_uses_this_; }
 331   // Does any inner scope access "this".
 332   bool inner_uses_this() const { return inner_scope_uses_this_; }
 333
 334   // ---------------------------------------------------------------------------
 335   // Accessors.
 336
 337   // The type of this scope.
 338   ScopeType scope_type() const { return scope_type_; }
 339
 340   // The language mode of this scope.
 341   StrictMode strict_mode() const { return strict_mode_; }
 342
 343   // The variable corresponding the 'this' value.
 344   Variable* receiver() { return receiver_; }
 345
 346   // The variable holding the function literal for named function
 347   // literals, or NULL.  Only valid for function scopes.
 348   VariableDeclaration* function() const {
 349     DCHECK(is_function_scope());
 350     return function_;
 351   }
 352
 353   // Parameters. The left-most parameter has index 0.
 354   // Only valid for function scopes.
 355   Variable* parameter(int index) const {
 356     DCHECK(is_function_scope());
 357     return params_[index];
 358   }
 359
 360   int num_parameters() const { return params_.length(); }
 361
 362   // The local variable 'arguments' if we need to allocate it; NULL otherwise.
 363   Variable* arguments() const { return arguments_; }
 364
 365   // Declarations list.
 366   ZoneList<Declaration*>* declarations() { return &decls_; }
 367
 368   // Inner scope list.
 369   ZoneList<Scope*>* inner_scopes() { return &inner_scopes_; }
 370
 371   // The scope immediately surrounding this scope, or NULL.
 372   Scope* outer_scope() const { return outer_scope_; }
 373
 374   // The interface as inferred so far; only for module scopes.
 375   Interface* interface() const { return interface_; }
 376
 377   // ---------------------------------------------------------------------------
 378   // Variable allocation.
 379
 380   // Collect stack and context allocated local variables in this scope. Note
 381   // that the function variable - if present - is not collected and should be
 382   // handled separately.
 383   void CollectStackAndContextLocals(ZoneList<Variable*>* stack_locals,
 384                                     ZoneList<Variable*>* context_locals);
 385
 386   // Current number of var or const locals.
 387   int num_var_or_const() { return num_var_or_const_; }
 388
 389   // Result of variable allocation.
 390   int num_stack_slots() const { return num_stack_slots_; }
 391   int num_heap_slots() const { return num_heap_slots_; }
 392
 393   int StackLocalCount() const;
 394   int ContextLocalCount() const;
 395
 396   // For script scopes, the number of module literals (including nested ones).
 397   int num_modules() const { return num_modules_; }
 398
 399   // For module scopes, the host scope's internal variable binding this module.
 400   Variable* module_var() const { return module_var_; }
 401
 402   // Make sure this scope and all outer scopes are eagerly compiled.
 403   void ForceEagerCompilation()  { force_eager_compilation_ = true; }
 404
 405   // Determine if we can use lazy compilation for this scope.
 406   bool AllowsLazyCompilation() const;
 407
 408   // Determine if we can use lazy compilation for this scope without a context.
 409   bool AllowsLazyCompilationWithoutContext() const;
 410
 411   // True if the outer context of this scope is always the native context.
 412   bool HasTrivialOuterContext() const;
 413
 414   // True if the outer context allows lazy compilation of this scope.
 415   bool HasLazyCompilableOuterContext() const;
 416
 417   // The number of contexts between this and scope; zero if this == scope.
 418   int ContextChainLength(Scope* scope);
 419
 420   // Find the script scope.
 421   // Used in modules implemenetation to find hosting scope.
 422   // TODO(rossberg): is this needed?
 423   Scope* ScriptScope();
 424
 425   // Find the first function, global, or eval scope.  This is the scope
 426   // where var declarations will be hoisted to in the implementation.
 427   Scope* DeclarationScope();
 428
 429   Handle<ScopeInfo> GetScopeInfo();
 430
 431   // Get the chain of nested scopes within this scope for the source statement
 432   // position. The scopes will be added to the list from the outermost scope to
 433   // the innermost scope. Only nested block, catch or with scopes are tracked
 434   // and will be returned, but no inner function scopes.
 435   void GetNestedScopeChain(List<Handle<ScopeInfo> >* chain,
 436                            int statement_position);
 437
 438   // ---------------------------------------------------------------------------
 439   // Strict mode support.
 440   bool IsDeclared(const AstRawString* name) {
 441     // During formal parameter list parsing the scope only contains
 442     // two variables inserted at initialization: "this" and "arguments".
 443     // "this" is an invalid parameter name and "arguments" is invalid parameter
 444     // name in strict mode. Therefore looking up with the map which includes
 445     // "this" and "arguments" in addition to all formal parameters is safe.
 446     return variables_.Lookup(name) != NULL;
 447   }
 448
 449   // ---------------------------------------------------------------------------
 450   // Debugging.
 451
 452 #ifdef DEBUG
 453   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 454 #endif
 455
 456   // ---------------------------------------------------------------------------
 457   // Implementation.
 458  protected:
 459   friend class ParserFactory;
 460
 461   Isolate* const isolate_;
 462
 463   // Scope tree.
 464   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
 465   ZoneList<Scope*> inner_scopes_;  // the immediately enclosed inner scopes
 466
 467   // The scope type.
 468   ScopeType scope_type_;
 469
 470   // Debugging support.
 471   const AstRawString* scope_name_;
 472
 473   // The variables declared in this scope:
 474   //
 475   // All user-declared variables (incl. parameters).  For script scopes
 476   // variables may be implicitly 'declared' by being used (possibly in
 477   // an inner scope) with no intervening with statements or eval calls.
 478   VariableMap variables_;
 479   // Compiler-allocated (user-invisible) internals.
 480   ZoneList<Variable*> internals_;
 481   // Compiler-allocated (user-invisible) temporaries.
 482   ZoneList<Variable*> temps_;
 483   // Parameter list in source order.
 484   ZoneList<Variable*> params_;
 485   // Variables that must be looked up dynamically.
 486   DynamicScopePart* dynamics_;
 487   // Unresolved variables referred to from this scope.
 488   ZoneList<VariableProxy*> unresolved_;
 489   // Declarations.
 490   ZoneList<Declaration*> decls_;
 491   // Convenience variable.
 492   Variable* receiver_;
 493   // Function variable, if any; function scopes only.
 494   VariableDeclaration* function_;
 495   // Convenience variable; function scopes only.
 496   Variable* arguments_;
 497   // Interface; module scopes only.
 498   Interface* interface_;
 499
 500   // Illegal redeclaration.
 501   Expression* illegal_redecl_;
 502
 503   // Scope-specific information computed during parsing.
 504   //
 505   // This scope is inside a 'with' of some outer scope.
 506   bool scope_inside_with_;
 507   // This scope contains a 'with' statement.
 508   bool scope_contains_with_;
 509   // This scope or a nested catch scope or with scope contain an 'eval' call. At
 510   // the 'eval' call site this scope is the declaration scope.
 511   bool scope_calls_eval_;
 512   // This scope uses "arguments".
 513   bool scope_uses_arguments_;
 514   // This scope uses "super" property ('super.foo').
 515   bool scope_uses_super_property_;
 516   // This scope uses "super" constructor ('super(..)').
 517   bool scope_uses_super_constructor_call_;
 518   // This scope uses "this".
 519   bool scope_uses_this_;
 520   // This scope contains an "use asm" annotation.
 521   bool asm_module_;
 522   // This scope's outer context is an asm module.
 523   bool asm_function_;
 524   // The strict mode of this scope.
 525   StrictMode strict_mode_;
 526   // Source positions.
 527   int start_position_;
 528   int end_position_;
 529
 530   // Computed via PropagateScopeInfo.
 531   bool outer_scope_calls_sloppy_eval_;
 532   bool inner_scope_calls_eval_;
 533   bool inner_scope_uses_arguments_;
 534   bool inner_scope_uses_super_property_;
 535   bool inner_scope_uses_super_constructor_call_;
 536   bool inner_scope_uses_this_;
 537   bool force_eager_compilation_;
 538   bool force_context_allocation_;
 539
 540   // True if it doesn't need scope resolution (e.g., if the scope was
 541   // constructed based on a serialized scope info or a catch context).
 542   bool already_resolved_;
 543
 544   // Computed as variables are declared.
 545   int num_var_or_const_;
 546
 547   // Computed via AllocateVariables; function, block and catch scopes only.
 548   int num_stack_slots_;
 549   int num_heap_slots_;
 550
 551   // The number of modules (including nested ones).
 552   int num_modules_;
 553
 554   // For module scopes, the host scope's internal variable binding this module.
 555   Variable* module_var_;
 556
 557   // Serialized scope info support.
 558   Handle<ScopeInfo> scope_info_;
 559   bool already_resolved() { return already_resolved_; }
 560
 561   // Create a non-local variable with a given name.
 562   // These variables are looked up dynamically at runtime.
 563   Variable* NonLocal(const AstRawString* name, VariableMode mode);
 564
 565   // Variable resolution.
 566   // Possible results of a recursive variable lookup telling if and how a
 567   // variable is bound. These are returned in the output parameter *binding_kind
 568   // of the LookupRecursive function.
 569   enum BindingKind {
 570     // The variable reference could be statically resolved to a variable binding
 571     // which is returned. There is no 'with' statement between the reference and
 572     // the binding and no scope between the reference scope (inclusive) and
 573     // binding scope (exclusive) makes a sloppy 'eval' call.
 574     BOUND,
 575
 576     // The variable reference could be statically resolved to a variable binding
 577     // which is returned. There is no 'with' statement between the reference and
 578     // the binding, but some scope between the reference scope (inclusive) and
 579     // binding scope (exclusive) makes a sloppy 'eval' call, that might
 580     // possibly introduce variable bindings shadowing the found one. Thus the
 581     // found variable binding is just a guess.
 582     BOUND_EVAL_SHADOWED,
 583
 584     // The variable reference could not be statically resolved to any binding
 585     // and thus should be considered referencing a global variable. NULL is
 586     // returned. The variable reference is not inside any 'with' statement and
 587     // no scope between the reference scope (inclusive) and script scope
 588     // (exclusive) makes a sloppy 'eval' call.
 589     UNBOUND,
 590
 591     // The variable reference could not be statically resolved to any binding
 592     // NULL is returned. The variable reference is not inside any 'with'
 593     // statement, but some scope between the reference scope (inclusive) and
 594     // script scope (exclusive) makes a sloppy 'eval' call, that might
 595     // possibly introduce a variable binding. Thus the reference should be
 596     // considered referencing a global variable unless it is shadowed by an
 597     // 'eval' introduced binding.
 598     UNBOUND_EVAL_SHADOWED,
 599
 600     // The variable could not be statically resolved and needs to be looked up
 601     // dynamically. NULL is returned. There are two possible reasons:
 602     // * A 'with' statement has been encountered and there is no variable
 603     //   binding for the name between the variable reference and the 'with'.
 604     //   The variable potentially references a property of the 'with' object.
 605     // * The code is being executed as part of a call to 'eval' and the calling
 606     //   context chain contains either a variable binding for the name or it
 607     //   contains a 'with' context.
 608     DYNAMIC_LOOKUP
 609   };
 610
 611   // Lookup a variable reference given by name recursively starting with this
 612   // scope. If the code is executed because of a call to 'eval', the context
 613   // parameter should be set to the calling context of 'eval'.
 614   Variable* LookupRecursive(VariableProxy* proxy, BindingKind* binding_kind,
 615                             AstNodeFactory* factory);
 616   MUST_USE_RESULT
 617   bool ResolveVariable(CompilationInfo* info, VariableProxy* proxy,
 618                        AstNodeFactory* factory);
 619   MUST_USE_RESULT
 620   bool ResolveVariablesRecursively(CompilationInfo* info,
 621                                    AstNodeFactory* factory);
 622
 623   // Scope analysis.
 624   void PropagateScopeInfo(bool outer_scope_calls_sloppy_eval);
 625   bool HasTrivialContext() const;
 626
 627   // Predicates.
 628   bool MustAllocate(Variable* var);
 629   bool MustAllocateInContext(Variable* var);
 630   bool HasArgumentsParameter();
 631
 632   // Variable allocation.
 633   void AllocateStackSlot(Variable* var);
 634   void AllocateHeapSlot(Variable* var);
 635   void AllocateParameterLocals();
 636   void AllocateNonParameterLocal(Variable* var);
 637   void AllocateNonParameterLocals();
 638   void AllocateVariablesRecursively();
 639   void AllocateModulesRecursively(Scope* host_scope);
 640
 641   // Resolve and fill in the allocation information for all variables
 642   // in this scopes. Must be called *after* all scopes have been
 643   // processed (parsed) to ensure that unresolved variables can be
 644   // resolved properly.
 645   //
 646   // In the case of code compiled and run using 'eval', the context
 647   // parameter is the context in which eval was called.  In all other
 648   // cases the context parameter is an empty handle.
 649   MUST_USE_RESULT
 650   bool AllocateVariables(CompilationInfo* info, AstNodeFactory* factory);
 651
 652  private:
 653   // Construct a scope based on the scope info.
 654   Scope(Scope* inner_scope, ScopeType type, Handle<ScopeInfo> scope_info,
 655         AstValueFactory* value_factory, Zone* zone);
 656
 657   // Construct a catch scope with a binding for the name.
 658   Scope(Scope* inner_scope,
 659         const AstRawString* catch_variable_name,
 660         AstValueFactory* value_factory, Zone* zone);
 661
 662   void AddInnerScope(Scope* inner_scope) {
 663     if (inner_scope != NULL) {
 664       inner_scopes_.Add(inner_scope, zone_);
 665       inner_scope->outer_scope_ = this;
 666     }
 667   }
 668
 669   void SetDefaults(ScopeType type,
 670                    Scope* outer_scope,
 671                    Handle<ScopeInfo> scope_info);
 672
 673   AstValueFactory* ast_value_factory_;
 674   Zone* zone_;
 675 };
 676
 677 } }  // namespace v8::internal
 678
 679 #endif  // V8_SCOPES_H_