Calling a generator function returns a generator object

src/objects-debug.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 121 matching lines @@
     case CODE_TYPE:
       Code::cast(this)->CodeVerify();
       break;
     case ODDBALL_TYPE:
       Oddball::cast(this)->OddballVerify();
       break;
     case JS_OBJECT_TYPE:
     case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
       JSObject::cast(this)->JSObjectVerify();
       break;
+    case JS_GENERATOR_OBJECT_TYPE:
+      JSGeneratorObject::cast(this)->JSGeneratorObjectVerify();
+      break;
     case JS_MODULE_TYPE:
       JSModule::cast(this)->JSModuleVerify();
       break;
     case JS_VALUE_TYPE:
       JSValue::cast(this)->JSValueVerify();
       break;
     case JS_DATE_TYPE:
       JSDate::cast(this)->JSDateVerify();
       break;
     case JS_FUNCTION_TYPE:
@@ skipping 245 matching lines @@
       double value = get_scalar(i);
       CHECK(!isnan(value) ||
              (BitCast<uint64_t>(value) ==
               BitCast<uint64_t>(canonical_not_the_hole_nan_as_double())) ||
              ((BitCast<uint64_t>(value) & Double::kSignMask) != 0));
     }
   }
 }
 
 
+void JSGeneratorObject::JSGeneratorObjectVerify() {
+  VerifyObjectField(kFunctionOffset);
+  VerifyObjectField(kContextOffset);
+  VerifyObjectField(kOperandStackOffset);
+  if (function()->IsUndefined()) {

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

Just out of curiosity, is there a particular reason we are using Smi(0) as a
sentinel value instead of undefined? I would be fine with switching to undefined
as well. I'll leave that up to you.

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

Changed to use undefined.  I also relaxed these checks, as it's inconvenient to
type accessors while still allowing for that strange "might-be-undefined" moment
for the Smi and FixedArray fields.

+    // Uninitialized object from constructor.
+    CHECK(context()->IsUndefined());
+    CHECK(operand_stack()->IsUndefined());
+  } else {
+    CHECK(context() == Smi::FromInt(0) || context()->IsContext());
+    VerifySmiField(kContinuationOffset);
+    CHECK_GE(continuation(), 0);
+    CHECK(operand_stack() == Smi::FromInt(0) ||
+          operand_stack()->IsFixedArray());
+  }
+}
+
+
 void JSModule::JSModuleVerify() {
   VerifyObjectField(kContextOffset);
   VerifyObjectField(kScopeInfoOffset);
   CHECK(context()->IsUndefined() ||
         Context::cast(context())->IsModuleContext());
 }
 
 
 void JSValue::JSValueVerify() {
   Object* v = value();
@@ skipping 654 matching lines @@
   for (int i = 0; i < number_of_transitions(); ++i) {
     if (!CheckOneBackPointer(current_map, GetTarget(i))) return false;
   }
   return true;
 }
 
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal