Calling a generator function returns a generator object

src/runtime.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 2274 matching lines @@
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   CONVERT_SMI_ARG_CHECKED(num, 1);
   RUNTIME_ASSERT(num >= 0);
   SetExpectedNofProperties(function, num);
   return isolate->heap()->undefined_value();
 }
 
 
+RUNTIME_FUNCTION(MaybeObject*, Runtime_CreateJSGeneratorObject) {
+  NoHandleAllocation ha(isolate);
+  ASSERT(args.length() == 0);
+  JavaScriptFrameIterator it(isolate);
+  JavaScriptFrame* frame = it.frame();
+  JSFunction* function = JSFunction::cast(frame->function());
+  ASSERT(function->shared()->is_generator());
+
+  JSGeneratorObject* generator;
+  if (frame->IsConstructor()) {
+    generator = JSGeneratorObject::cast(frame->receiver());

[Michael Starzinger, 2013/04/12 16:53:31]

We shouldn't use the implicit receiver as the resulting generator, but allocate
a new one here and return that instead. It will override the implicit receiver.
That's also the solution that we discussed some time ago.

[Michael Starzinger, 2013/04/14 21:32:50]

You are right, I totally missed the fact that the "this" variable will stay
bound to the implicit receiver for the entire lifetime of the generator. Good
point.

+  } else {
+    Map *map;
+    if (function->has_initial_map()) {

[Michael Starzinger, 2013/04/12 16:53:31]

I think we can get by without tweaking the initial map of the generator function
to represent a JSGeneratorObject. It can represent some arbitrary empty
JSObject. Is there another reason why we need to set the initial map of the
generator function at all?

+      map = function->initial_map();
+    } else {
+      // Allocate the initial map if absent.
+      MaybeObject* maybe_map = isolate->heap()->AllocateInitialMap(function);
+      if (!maybe_map->To(&map)) return maybe_map;
+      function->set_initial_map(map);
+    }
+    ASSERT(map->instance_type() == JS_GENERATOR_OBJECT_TYPE);
+    // Allocate the generator.
+    MaybeObject* maybe_generator = isolate->heap()->Allocate(map, NEW_SPACE);

[Michael Starzinger, 2013/04/14 21:32:50]

Please move the JSGenerator allocation back into heap.cc as in the previous
patch that I already reviewed. I am fine with not allocating a new JSGenerator
but reusing the implicit receiver for constructor calls. Not passing the
function to the allocator but leaving it undefined in the allocator is fine. The
values of "function", "context", "continuation" and "operand_stack" can be set
in this runtime function, the allocator can leave them as undefined.

[wingo, 2013/04/15 09:24:57]

Done.

+    if (!maybe_generator->To(&generator)) return maybe_generator;
+    generator->initialize_properties();
+    generator->initialize_elements();
+  }
+  generator->set_function(function);
+  generator->set_context(Smi::FromInt(0));
+  generator->set_continuation(0);
+  generator->set_operand_stack(Smi::FromInt(0));
+  return generator;
+}
+
+
 MUST_USE_RESULT static MaybeObject* CharFromCode(Isolate* isolate,
                                                  Object* char_code) {
   uint32_t code;
   if (char_code->ToArrayIndex(&code)) {
     if (code <= 0xffff) {
       return isolate->heap()->LookupSingleCharacterStringFromCode(code);
     }
   }
   return isolate->heap()->empty_string();
 }
@@ skipping 10779 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal