Add parser support for generators.

src/scopes.cc

Index: src/scopes.cc
diff --git a/src/scopes.cc b/src/scopes.cc
index 4ac9d0e6a463047319ef43317ebd6551b798e110..77e644b25c046e369f3fa4d0133026f594ec008d 100644
--- a/src/scopes.cc
+++ b/src/scopes.cc
@@ -190,6 +190,7 @@ void Scope::SetDefaults(ScopeType type,
   illegal_redecl_ = NULL;
   scope_inside_with_ = false;
   scope_contains_with_ = false;
+  scope_inside_generator_ = false;
   scope_calls_eval_ = false;
   // Inherit the strict mode from the parent scope.
   language_mode_ = (outer_scope != NULL)
@@ -248,6 +249,25 @@ Scope* Scope::DeserializeScopeChain(Context* context, Scope* global_scope,
                                       FUNCTION_SCOPE,
                                       Handle<ScopeInfo>(scope_info),
                                       zone);
+      if (context->closure()->shared()->is_generator()) {
+        if (innermost_scope) {
+          // Find the deepest scope that's still in this function.

[Michael Starzinger, 2013/03/14 22:29:24]

Instead of searching for the next function scope down the chain, we could just
keep track of said function scope in a next_function_scope variable. Note that I
only jotted this down without actually trying it, so take it with a grain of
salt.

At top of function:
  Scope* next_function_scope = NULL;

Here:
  // All the inner scopes up to the next function scope are inside this
  // generator if we are deserializing a generator scope.
  if (context->closure()->shared()->is_generator()) {
    current_scope->scope_inside_generator_ = true;
    Scope* inner_scope = (next_function_scope != NULL)
        ? next_function_scope->outer_scope() : innermost_scope;
    for (Scope* s = inner_scope; s != NULL; s = s->outer_scope()) {
      s->scope_inside_generator_ = true;
    }
  }
  next_function_scope = current_scope;

+          Scope *inner_scope = innermost_scope;
+          for (Scope *s = innermost_scope;
+               s != current_scope;
+               s = s->outer_scope()) {
+            inner_scope = s;
+            while (!s->is_function_scope())
+              s = s->outer_scope();
+          }
+          // Mark intervening scopes (inclusive) as being inside a generator.
+          while (inner_scope != current_scope) {
+            inner_scope->scope_inside_generator_ = true;
+            inner_scope = inner_scope->outer_scope();
+          }
+        }
+        current_scope->scope_inside_generator_ = true;
+      }
     } else if (context->IsBlockContext()) {
       ScopeInfo* scope_info = ScopeInfo::cast(context->extension());
       current_scope = new(zone) Scope(current_scope,
@@ -320,6 +340,7 @@ void Scope::Initialize() {
   if (outer_scope_ != NULL) {
     outer_scope_->inner_scopes_.Add(this, zone());
     scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
+    scope_inside_generator_ = outer_scope_->inside_generator();

[Michael Starzinger, 2013/03/14 22:29:24]

We should only inherit this property from the outer scope if we are not
initializing a function scope. Otherwise this property is first set here and
later overridden by the parser again, that is confusing (it took me a while to
figure out why it works at all). How about the following instead ...

scope_inside_generator_ = outer_scope_->inside_generator() &&
!is_function_scope();

   } else {
     scope_inside_with_ = is_with_scope();
   }