arrange to create prototypes for generators

src/bootstrapper.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 1408 matching lines @@
                      ? top_context->builtins()
                      : top_context->global_object(),
                      isolate);
   bool has_pending_exception;
   Execution::Call(fun, receiver, 0, NULL, &has_pending_exception);
   if (has_pending_exception) return false;
   return true;
 }
 
 
+#define LOOKUP_NATIVE(Type, name, var)                                  \
+  Handle<String> var##_name =                                           \
+    factory()->NewStringFromOneByte(STATIC_ASCII_VECTOR(name));         \
+  Object* var##_obj =                                                   \
+      native_context()->builtins()->GetPropertyNoExceptionThrown(       \
+           *var##_name);                                                \
+  Handle<Type> var(Type::cast(var##_obj));
+
 #define INSTALL_NATIVE(Type, name, var)                                 \
   Handle<String> var##_name =                                           \
     factory()->InternalizeOneByteString(STATIC_ASCII_VECTOR(name));     \
   Object* var##_native =                                                \
       native_context()->builtins()->GetPropertyNoExceptionThrown(       \
            *var##_name);                                                \
   native_context()->set_##var(Type::cast(var##_native));
 
 
 void Genesis::InstallNativeFunctions() {
@@ skipping 21 matching lines @@
     INSTALL_NATIVE(JSFunction, "DerivedHasTrap", derived_has_trap);
     INSTALL_NATIVE(JSFunction, "DerivedGetTrap", derived_get_trap);
     INSTALL_NATIVE(JSFunction, "DerivedSetTrap", derived_set_trap);
     INSTALL_NATIVE(JSFunction, "ProxyEnumerate", proxy_enumerate);
   }
   if (FLAG_harmony_observation) {
     INSTALL_NATIVE(JSFunction, "NotifyChange", observers_notify_change);
     INSTALL_NATIVE(JSFunction, "DeliverChangeRecords",
                    observers_deliver_changes);
   }
+  if (FLAG_harmony_generators) {

[rossberg, 2013/04/09 16:44:14]

Why do these have to be created in a different manner than the other Harmony
constructor functions (see InitializeExperimentalGlobals above, and respective
.js files)? In particular, it feels a bit dubious to initialize the maps in the
context _after_ generator.js has already executed.

[wingo, 2013/04/10 14:28:52]

I have taken a look at this and I don't catch your meaning.  The code in my
patch makes maps not for the meta-objects themselves (the base level), but to
use when constructing per-generator objects (the middle level).  If I use
InstallFunction to make e.g. GeneratorFunctionObject in
InitializeExperimentalGlobals, that happens after generator.js runs, so I don't
have a chance to attach the next, send, etc functions on the
GeneratorFunctionObject.  I could of course do so in C++ but it seems better to
do that in JS, no?  And there's more to do there -- for example, I need to set
GeneratorFunctions's code to look like Function's, but to create a generator.

Have I misunderstood what you were getting at?

[wingo, 2013/04/10 14:44:28]

I think I misunderstood and found my error.  Please ignore the above comment.

+    HandleScope scope(isolate());
+    LOOKUP_NATIVE(JSFunction, "GeneratorFunctionPrototype",
+                  generator_function_prototype);
+    LOOKUP_NATIVE(JSObject, "GeneratorIteratorPrototype",
+                  generator_iterator_prototype);
+    Handle<Map> function_map(native_context()->function_map());
+    Handle<Map> strict_mode_function_map(
+        native_context()->strict_mode_function_map());
+    Handle<Map> object_map(native_context()->object_function()->initial_map());
+
+    Handle<Map> generator_function_map = factory()->CopyMap(function_map);
+    generator_function_map->set_prototype(*generator_function_prototype);
+    native_context()->set_generator_function_map(*generator_function_map);
+
+    Handle<Map> strict_mode_generator_function_map = factory()->CopyMap(
+        strict_mode_function_map);
+    strict_mode_generator_function_map->set_prototype(
+        *generator_function_prototype);
+    native_context()->set_strict_mode_generator_function_map(
+        *strict_mode_generator_function_map);
+
+    Handle<Map> generator_iterator_prototype_map = factory()->CopyMap(
+        object_map, 0);
+    generator_iterator_prototype_map->set_prototype(
+        *generator_iterator_prototype);
+    native_context()->set_generator_iterator_prototype_map(
+        *generator_iterator_prototype_map);
+  }
 }
 
 #undef INSTALL_NATIVE
 
 
 Handle<JSFunction> Genesis::InstallInternalArray(
     Handle<JSBuiltinsObject> builtins,
     const char* name,
     ElementsKind elements_kind) {
   // --- I n t e r n a l   A r r a y ---
@@ skipping 446 matching lines @@
     if (FLAG_harmony_observation &&
         strcmp(ExperimentalNatives::GetScriptName(i).start(),
                "native object-observe.js") == 0) {
       if (!CompileExperimentalBuiltin(isolate(), i)) return false;
     }
     if (FLAG_harmony_typed_arrays &&
         strcmp(ExperimentalNatives::GetScriptName(i).start(),
                "native typedarray.js") == 0) {
       if (!CompileExperimentalBuiltin(isolate(), i)) return false;
     }
+    if (FLAG_harmony_generators &&
+        strcmp(ExperimentalNatives::GetScriptName(i).start(),
+               "native generators.js") == 0) {
+      if (!CompileExperimentalBuiltin(isolate(), i)) return false;
+    }
   }
 
   InstallExperimentalNativeFunctions();
 
   return true;
 }
 
 
 static Handle<JSObject> ResolveBuiltinIdHolder(
     Handle<Context> native_context,
@@ skipping 564 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(!IsActive());
 }
 
 } }  // namespace v8::internal