Introduce with scope and rework variable resolution.

src/scopes.h

 // 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
@@ skipping 76 matching lines @@
 class Scope: public ZoneObject {
  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.
     CATCH_SCOPE,     // The scope introduced by catch.
-    BLOCK_SCOPE      // The scope introduced by a new block.
+    BLOCK_SCOPE,     // The scope introduced by a new block.
+    WITH_SCOPE       // The scope introduced by with.
   };
 
   Scope(Scope* outer_scope, Type type);
 
   // 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 95 matching lines @@
 
   // Enable strict mode for the scope (unless disabled by a global flag).
   void EnableStrictMode() {
     strict_mode_ = FLAG_strict_mode;
   }
 
   // ---------------------------------------------------------------------------
   // Predicates.
 
   // Specific scope types.
+  Type type() const { return type_; }

[Kevin Millikin (Chromium), 2011/09/15 09:38:13]

Don't introduce this until you have a caller for it (in fact, can you make the
Type enum private?).

[Steven, 2011/09/15 19:54:06]

Will remove it for for now. But I will need it later.

The enum values are used in the parser to create scopes, so I wouldn't want to
make it private now.
On 2011/09/15 09:38:13, Kevin Millikin wrote:

   bool is_eval_scope() const { return type_ == EVAL_SCOPE; }
   bool is_function_scope() const { return type_ == FUNCTION_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; }
+  bool is_with_scope() const { return type_ == WITH_SCOPE; }
+  bool is_declaration_scope() const {
+    return is_eval_scope() || is_function_scope() || is_global_scope();
+  }
   bool is_strict_mode() const { return strict_mode_; }
   bool is_strict_mode_eval_scope() const {
     return is_eval_scope() && is_strict_mode();
   }
 
   // Information about which scopes calls eval.
   bool calls_eval() const { return scope_calls_eval_; }
   bool outer_scope_calls_eval() const { return outer_scope_calls_eval_; }
   bool outer_scope_calls_non_strict_eval() const {
     return outer_scope_calls_non_strict_eval_;
@@ skipping 161 matching lines @@
   bool outer_scope_is_eval_scope_;
   bool force_eager_compilation_;
 
   // 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 scopes only.
+  // Computed via AllocateVariables; function, block and catch scopes only.
   int num_stack_slots_;
   int num_heap_slots_;
 
   // Serialized scopes support.
   Handle<SerializedScopeInfo> scope_info_;
   bool already_resolved() { return already_resolved_; }
 
   // Create a non-local variable with a given name.
   // These variables are looked up dynamically at runtime.
   Variable* NonLocal(Handle<String> name, Variable::Mode mode);
 
   // Variable resolution.
-  Variable* LookupRecursive(Handle<String> name,
-                            bool from_inner_function,
-                            Variable** invalidated_local);
+
+  // Possible results of a variable lookup.
+  enum LookupResult {
+    // The variable could be statically resolved to a non-global outer
+    // scope. There is no 'with' statement in between and no in between
+    // scope calls 'eval'.
+    FOUND,

[Kevin Millikin (Chromium), 2011/09/15 09:38:13]

Since GLOBAL can also be found, perhaps it's clearer to rename FOUND => LOCAL
and likewise with FOUND_EVAL and FOUND_WITH.

[Steven, 2011/09/15 19:54:06]

Done.

+
+    // The variable could be statically resolved to a non-global outer
+    // scope, but an in between scope calls 'eval' that might possibly
+    // introduce variables shadowing the found one. Thus the found variable
+    // is just a guess.
+    FOUND_EVAL,
+
+    // We may have statically resolved a variable to a non-global outer
+    // scope, but there is a 'with' statement in between. The 'with' object
+    // may have a property with the same name, so if a variable has been
+    // found, it is just a guess.
+    FOUND_WITH,

[Kevin Millikin (Chromium), 2011/09/15 09:38:13]

On the other hand, this case includes the case of a variable that statically
resolves to a global var/function/const binding.  The comment should reflect
that, as well as the name.  Something like: LOCAL_PAST_EVAL, FOUND_PAST_WITH or
the like.

[Steven, 2011/09/15 19:54:06]

Done.

+
+    // The variable could not be resolved to any local binding and is thus
+    // a global variable unless it is shadowed by an eval-introduced variable.
+    GLOBAL

[Kevin Millikin (Chromium), 2011/09/15 09:38:13]

This case is also used for when the variable is resolved to a variable in the
global scope, so the comment should include that.

[Steven, 2011/09/15 19:54:06]

Done.

+  };
+
+  // Lookup a variable starting with this scope.
+  LookupResult LookupRecursive(Handle<String> name,
+                               bool from_inner_scope,
+                               Variable** var);
   void ResolveVariable(Scope* global_scope,
                        Handle<Context> context,
                        VariableProxy* proxy);
   void ResolveVariablesRecursively(Scope* global_scope,
                                    Handle<Context> context);
 
   // Scope analysis.
   bool PropagateScopeInfo(bool outer_scope_calls_eval,
                           bool outer_scope_calls_non_strict_eval,
                           bool outer_scope_is_eval_scope);
@@ skipping 27 matching lines @@
   }
 
   void SetDefaults(Type type,
                    Scope* outer_scope,
                    Handle<SerializedScopeInfo> scope_info);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_