Add parser support for generators.

src/scopes.cc

 // 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 172 matching lines @@
   outer_scope_ = outer_scope;
   type_ = type;
   scope_name_ = isolate_->factory()->empty_string();
   dynamics_ = NULL;
   receiver_ = NULL;
   function_ = NULL;
   arguments_ = NULL;
   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)
       ? outer_scope->language_mode_ : CLASSIC_MODE;
   outer_scope_calls_non_strict_eval_ = false;
   inner_scope_calls_eval_ = false;
   force_eager_compilation_ = false;
   num_var_or_const_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
@@ skipping 38 matching lines @@
       current_scope = new(zone) Scope(current_scope,
                                       MODULE_SCOPE,
                                       Handle<ScopeInfo>(scope_info),
                                       zone);
     } else if (context->IsFunctionContext()) {
       ScopeInfo* scope_info = context->closure()->shared()->scope_info();
       current_scope = new(zone) Scope(current_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,
                                       BLOCK_SCOPE,
                                       Handle<ScopeInfo>(scope_info),
                                       zone);
     } else {
       ASSERT(context->IsCatchContext());
       String* name = String::cast(context->extension());
       current_scope = new(zone) Scope(
@@ skipping 52 matching lines @@
 }
 
 
 void Scope::Initialize() {
   ASSERT(!already_resolved());
 
   // Add this scope as a new inner scope of the outer scope.
   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();
   }
 
   // Declare convenience variables.
   // Declare and allocate receiver (even for the global scope, and even
   // if naccesses_ == 0).
   // NOTE: When loading parameters in the global scope, we must take
   // care not to access them as properties of the global object, but
   // instead load them directly from the stack. Currently, the only
@@ skipping 544 matching lines @@
     case CLASSIC_MODE:
       break;
     case STRICT_MODE:
       Indent(n1, "// strict mode scope\n");
       break;
     case EXTENDED_MODE:
       Indent(n1, "// extended mode scope\n");
       break;
   }
   if (scope_inside_with_) Indent(n1, "// scope inside 'with'\n");
   if (scope_contains_with_) Indent(n1, "// scope contains 'with'\n");

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

We should add the following debug output here for --print-scopes to be usable
with generators ...

if (scope_inside_generator_) Indent(n1, "// scope inside 'function*'\n");

   if (scope_calls_eval_) Indent(n1, "// scope calls 'eval'\n");
   if (outer_scope_calls_non_strict_eval_) {
     Indent(n1, "// outer scope calls 'eval' in non-strict context\n");
   }
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
   if (num_stack_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d stack slots\n", num_stack_slots_); }
   if (num_heap_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d heap slots\n", num_heap_slots_); }
 
@@ skipping 481 matching lines @@
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->proxy()->var()->IsContextSlot() ? 1 : 0);
 }
 
 } }  // namespace v8::internal